@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/chat/common/model/chatSessionStore.js

@@ -9,6 +9,7 @@ import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marsh
 import { joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';
 import { toFileOperationResult, FileOperationResult } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
 import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
@@ -20,18 +21,31 @@ import { IUserDataProfilesService } from '@codingame/monaco-vscode-api/vscode/vs
 import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
 import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
 import { awaitStatsForSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chat';
-import { ModifiedFileEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService';
-import { normalizeSerializableChatData, ChatModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel';
 import { ResponseModelState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+import { ModifiedFileEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService';
+import { ChatModel, normalizeSerializableChatData } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel';
+import { ChatSessionOperationLog } from './chatSessionOperationLog.js';
 import { LocalChatSessionUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 
 var ChatSessionStore_1;
-const maxPersistedSessions = 25;
-const ChatIndexStorageKey = 'chat.ChatSessionStore.index';
-const ChatTransferIndexStorageKey = 'ChatSessionStore.transferIndex';
+const maxPersistedSessions = 50;
+const ChatIndexStorageKey = "chat.ChatSessionStore.index";
+const ChatTransferIndexStorageKey = "ChatSessionStore.transferIndex";
 let ChatSessionStore = class ChatSessionStore extends Disposable {
-    static { ChatSessionStore_1 = this; }
-    constructor(fileService, environmentService, logService, workspaceContextService, telemetryService, storageService, lifecycleService, userDataProfilesService) {
+    static {
+        ChatSessionStore_1 = this;
+    }
+    constructor(
+        fileService,
+        environmentService,
+        logService,
+        workspaceContextService,
+        telemetryService,
+        storageService,
+        lifecycleService,
+        userDataProfilesService,
+        configurationService
+    ) {
         super();
         this.fileService = fileService;
         this.environmentService = environmentService;
@@ -41,26 +55,33 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
         this.storageService = storageService;
         this.lifecycleService = lifecycleService;
         this.userDataProfilesService = userDataProfilesService;
+        this.configurationService = configurationService;
         this.storeQueue = ( new Sequencer());
         this.shuttingDown = false;
         const workspace = this.workspaceContextService.getWorkspace();
         const isEmptyWindow = !workspace.configuration && workspace.folders.length === 0;
         const workspaceId = this.workspaceContextService.getWorkspace().id;
-        this.storageRoot = isEmptyWindow ?
-            joinPath(this.userDataProfilesService.defaultProfile.globalStorageHome, 'emptyWindowChatSessions') :
-            joinPath(this.environmentService.workspaceStorageHome, workspaceId, 'chatSessions');
-        this.previousEmptyWindowStorageRoot = isEmptyWindow ?
-            joinPath(this.environmentService.workspaceStorageHome, 'no-workspace', 'chatSessions') :
-            undefined;
-        this.transferredSessionStorageRoot = joinPath(this.userDataProfilesService.defaultProfile.globalStorageHome, 'transferredChatSessions');
+        this.storageRoot = isEmptyWindow ? joinPath(
+            this.userDataProfilesService.defaultProfile.globalStorageHome,
+            "emptyWindowChatSessions"
+        ) : joinPath(this.environmentService.workspaceStorageHome, workspaceId, "chatSessions");
+        this.previousEmptyWindowStorageRoot = isEmptyWindow ? joinPath(
+            this.environmentService.workspaceStorageHome,
+            "no-workspace",
+            "chatSessions"
+        ) : undefined;
+        this.transferredSessionStorageRoot = joinPath(
+            this.userDataProfilesService.defaultProfile.globalStorageHome,
+            "transferredChatSessions"
+        );
         this._register(this.lifecycleService.onWillShutdown(e => {
             this.shuttingDown = true;
             if (!this.storeTask) {
                 return;
             }
             e.join(this.storeTask, {
-                id: 'join.chatSessionStore',
-                label: ( localize(5966, "Saving chat history"))
+                id: "join.chatSessionStore",
+                label: ( localize(6253, "Saving chat history"))
             });
         }));
     }
@@ -74,14 +95,12 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
                     await Promise.all(( sessions.map(session => this.writeSession(session))));
                     await this.trimEntries();
                     await this.flushIndex();
-                }
-                catch (e) {
-                    this.reportError('storeSessions', 'Error storing chat sessions', e);
+                } catch (e) {
+                    this.reportError("storeSessions", "Error storing chat sessions", e);
                 }
             });
             await this.storeTask;
-        }
-        finally {
+        } finally {
             this.storeTask = undefined;
         }
     }
@@ -94,14 +113,12 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
                 try {
                     await Promise.all(( sessions.map(session => this.writeSessionMetadataOnly(session))));
                     await this.flushIndex();
-                }
-                catch (e) {
-                    this.reportError('storeSessions', 'Error storing chat sessions', e);
+                } catch (e) {
+                    this.reportError("storeSessions", "Error storing chat sessions", e);
                 }
             });
             await this.storeTask;
-        }
-        finally {
+        } finally {
             this.storeTask = undefined;
         }
     }
@@ -116,10 +133,9 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
                     const existingStorageLocation = this.getTransferredSessionStorageLocation(existingSessionResource);
                     await this.fileService.del(existingStorageLocation);
                 }
-            }
-            catch (e) {
+            } catch (e) {
                 if (toFileOperationResult(e) !== FileOperationResult.FILE_NOT_FOUND) {
-                    this.reportError('storeTransferSession', 'Error deleting old transferred session file', e);
+                    this.reportError("storeTransferSession", "Error deleting old transferred session file", e);
                 }
             }
         }
@@ -127,30 +143,34 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
             const content = JSON.stringify(session, undefined, 2);
             const storageLocation = this.getTransferredSessionStorageLocation(session.sessionResource);
             await this.fileService.writeFile(storageLocation, VSBuffer.fromString(content));
-        }
-        catch (e) {
-            this.reportError('sessionWrite', 'Error writing chat session', e);
+        } catch (e) {
+            this.reportError("sessionWrite", "Error writing chat session", e);
             return;
         }
         index[workspaceKey] = transferData;
         try {
-            this.storageService.store(ChatTransferIndexStorageKey, index, StorageScope.PROFILE, StorageTarget.MACHINE);
-        }
-        catch (e) {
-            this.reportError('storeTransferSession', 'Error storing chat transfer session', e);
+            this.storageService.store(
+                ChatTransferIndexStorageKey,
+                index,
+                StorageScope.PROFILE,
+                StorageTarget.MACHINE
+            );
+        } catch (e) {
+            this.reportError("storeTransferSession", "Error storing chat transfer session", e);
         }
     }
     getTransferredSessionIndex() {
         try {
             const data = this.storageService.getObject(ChatTransferIndexStorageKey, StorageScope.PROFILE, {});
             return data;
-        }
-        catch (e) {
-            this.reportError('getTransferredSessionIndex', 'Error reading chat transfer index', e);
+        } catch (e) {
+            this.reportError("getTransferredSessionIndex", "Error reading chat transfer index", e);
             return {};
         }
     }
-    static { this.TRANSFER_EXPIRATION_MS = 60 * 1000 * 5; }
+    static {
+        this.TRANSFER_EXPIRATION_MS = 60 * 1000 * 5;
+    }
     getTransferredSessionData() {
         try {
             const index = this.getTransferredSessionIndex();
@@ -165,14 +185,13 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
             }
             const revivedTransferData = revive(transferredSessionForWorkspace);
             if (Date.now() - transferredSessionForWorkspace.timestampInMilliseconds > ChatSessionStore_1.TRANSFER_EXPIRATION_MS) {
-                this.logService.info('ChatSessionStore: Transferred session has expired');
+                this.logService.info("ChatSessionStore: Transferred session has expired");
                 this.cleanupTransferredSession(revivedTransferData.sessionResource);
                 return undefined;
             }
             return !!LocalChatSessionUri.parseLocalSessionId(revivedTransferData.sessionResource) && revivedTransferData.sessionResource;
-        }
-        catch (e) {
-            this.reportError('getTransferredSession', 'Error getting transferred chat session URI', e);
+        } catch (e) {
+            this.reportError("getTransferredSession", "Error getting transferred chat session URI", e);
             return undefined;
         }
     }
@@ -183,12 +202,11 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
             if (!sessionId) {
                 return undefined;
             }
-            const sessionData = await this.readSessionFromLocation(storageLocation, sessionId);
+            const sessionData = await this.readSessionFromLocation(storageLocation, undefined, sessionId);
             await this.cleanupTransferredSession(sessionResource);
             return sessionData;
-        }
-        catch (e) {
-            this.reportError('getTransferredSession', 'Error getting transferred chat session', e);
+        } catch (e) {
+            this.reportError("getTransferredSession", "Error getting transferred chat session", e);
             return undefined;
         }
     }
@@ -199,14 +217,18 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
             if (workspaceFolders.length === 1) {
                 const workspaceKey = ( workspaceFolders[0].uri.toString());
                 delete index[workspaceKey];
-                this.storageService.store(ChatTransferIndexStorageKey, index, StorageScope.PROFILE, StorageTarget.MACHINE);
+                this.storageService.store(
+                    ChatTransferIndexStorageKey,
+                    index,
+                    StorageScope.PROFILE,
+                    StorageTarget.MACHINE
+                );
             }
             const storageLocation = this.getTransferredSessionStorageLocation(sessionResource);
             await this.fileService.del(storageLocation);
-        }
-        catch (e) {
+        } catch (e) {
             if (toFileOperationResult(e) !== FileOperationResult.FILE_NOT_FOUND) {
-                this.reportError('cleanupTransferredSession', 'Error cleaning up transferred session', e);
+                this.reportError("cleanupTransferredSession", "Error cleaning up transferred session", e);
             }
         }
     }
@@ -214,12 +236,30 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
         try {
             const index = this.internalGetIndex();
             const storageLocation = this.getStorageLocation(session.sessionId);
-            const content = JSON.stringify(session, undefined, 2);
-            await this.fileService.writeFile(storageLocation, VSBuffer.fromString(content));
+            if (storageLocation.log) {
+                if (session instanceof ChatModel) {
+                    if (!session.dataSerializer) {
+                        session.dataSerializer = ( new ChatSessionOperationLog());
+                    }
+                    const {
+                        op,
+                        data
+                    } = session.dataSerializer.write(session);
+                    if (data.byteLength > 0) {
+                        await this.fileService.writeFile(storageLocation.log, data, {
+                            append: op === "append"
+                        });
+                    }
+                } else {
+                    const content = ( new ChatSessionOperationLog()).createInitialFromSerialized(session);
+                    await this.fileService.writeFile(storageLocation.log, content);
+                }
+            } else {
+                await this.fileService.writeFile(storageLocation.flat, VSBuffer.fromString(JSON.stringify(session)));
+            }
             index.entries[session.sessionId] = await getSessionMetadata(session);
-        }
-        catch (e) {
-            this.reportError('sessionWrite', 'Error writing chat session', e);
+        } catch (e) {
+            this.reportError("sessionWrite", "Error writing chat session", e);
         }
     }
     async writeSessionMetadataOnly(session) {
@@ -230,18 +270,21 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
             const index = this.internalGetIndex();
             const externalSessionId = ( session.sessionResource.toString());
             index.entries[externalSessionId] = await getSessionMetadata(session);
-        }
-        catch (e) {
-            this.reportError('sessionMetadataWrite', 'Error writing chat session metadata', e);
+        } catch (e) {
+            this.reportError("sessionMetadataWrite", "Error writing chat session metadata", e);
         }
     }
     async flushIndex() {
         const index = this.internalGetIndex();
         try {
-            this.storageService.store(ChatIndexStorageKey, index, this.getIndexStorageScope(), StorageTarget.MACHINE);
-        }
-        catch (e) {
-            this.reportError('indexWrite', 'Error writing index', e);
+            this.storageService.store(
+                ChatIndexStorageKey,
+                index,
+                this.getIndexStorageScope(),
+                StorageTarget.MACHINE
+            );
+        } catch (e) {
+            this.reportError("indexWrite", "Error writing index", e);
         }
     }
     getIndexStorageScope() {
@@ -251,16 +294,15 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
     }
     async trimEntries() {
         const index = this.internalGetIndex();
-        const entries = ( Object.entries(index.entries)
-            .filter(([_id, entry]) => !entry.isExternal)
-            .sort((a, b) => b[1].lastMessageDate - a[1].lastMessageDate)
-            .map(([id]) => id));
+        const entries = ( Object.entries(index.entries).filter(([_id, entry]) => !entry.isExternal).sort((a, b) => b[1].lastMessageDate - a[1].lastMessageDate).map(([id]) => id));
         if (entries.length > maxPersistedSessions) {
             const entriesToDelete = entries.slice(maxPersistedSessions);
             for (const entry of entriesToDelete) {
                 delete index.entries[entry];
             }
-            this.logService.trace(`ChatSessionStore: Trimmed ${entriesToDelete.length} old chat sessions from index`);
+            this.logService.trace(
+                `ChatSessionStore: Trimmed ${entriesToDelete.length} old chat sessions from index`
+            );
         }
     }
     async internalDeleteSession(sessionId) {
@@ -269,15 +311,16 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
             return;
         }
         const storageLocation = this.getStorageLocation(sessionId);
-        try {
-            await this.fileService.del(storageLocation);
-        }
-        catch (e) {
-            if (toFileOperationResult(e) !== FileOperationResult.FILE_NOT_FOUND) {
-                this.reportError('sessionDelete', 'Error deleting chat session', e);
+        for (const uri of [storageLocation.flat, storageLocation.log]) {
+            try {
+                if (uri) {
+                    await this.fileService.del(uri);
+                }
+            } catch (e) {
+                if (toFileOperationResult(e) !== FileOperationResult.FILE_NOT_FOUND) {
+                    this.reportError("sessionDelete", "Error deleting chat session", e);
+                }
             }
-        }
-        finally {
             delete index.entries[sessionId];
         }
     }
@@ -312,9 +355,13 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
         });
     }
     reportError(reasonForTelemetry, message, error) {
-        this.logService.error(`ChatSessionStore: ` + message, toErrorMessage(error));
         const fileOperationReason = error && toFileOperationResult(error);
-        this.telemetryService.publicLog2('chatSessionStoreError', {
+        if (fileOperationReason === FileOperationResult.FILE_NOT_FOUND) {
+            this.logService.trace(`ChatSessionStore: ` + message, toErrorMessage(error));
+        } else {
+            this.logService.error(`ChatSessionStore: ` + message, toErrorMessage(error));
+        }
+        this.telemetryService.publicLog2("chatSessionStoreError", {
             reason: reasonForTelemetry,
             fileOperationReason: fileOperationReason ?? -1
         });
@@ -325,23 +372,30 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
         }
         const data = this.storageService.get(ChatIndexStorageKey, this.getIndexStorageScope(), undefined);
         if (!data) {
-            this.indexCache = { version: 1, entries: {} };
+            this.indexCache = {
+                version: 1,
+                entries: {}
+            };
             return this.indexCache;
         }
         try {
             const index = JSON.parse(data);
             if (isChatSessionIndex(index)) {
                 this.indexCache = index;
-            }
-            else {
-                this.reportError('invalidIndexFormat', `Invalid index format: ${data}`);
-                this.indexCache = { version: 1, entries: {} };
+            } else {
+                this.reportError("invalidIndexFormat", `Invalid index format: ${data}`);
+                this.indexCache = {
+                    version: 1,
+                    entries: {}
+                };
             }
             return this.indexCache;
-        }
-        catch (e) {
-            this.reportError('invalidIndexJSON', `Index corrupt: ${data}`, e);
-            this.indexCache = { version: 1, entries: {} };
+        } catch (e) {
+            this.reportError("invalidIndexJSON", `Index corrupt: ${data}`, e);
+            this.indexCache = {
+                version: 1,
+                entries: {}
+            };
             return this.indexCache;
         }
     }
@@ -360,7 +414,7 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
     }
     logIndex() {
         const data = this.storageService.get(ChatIndexStorageKey, this.getIndexStorageScope(), undefined);
-        this.logService.info('ChatSessionStore index: ', data);
+        this.logService.info("ChatSessionStore index: ", data);
     }
     async migrateDataIfNeeded(getInitialData) {
         await this.storeQueue.queue(async () => {
@@ -376,8 +430,10 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
     }
     async migrate(initialData) {
         const numSessions = ( Object.keys(initialData)).length;
-        this.logService.info(`ChatSessionStore: Migrating ${numSessions} chat sessions from storage service to file system`);
-        await Promise.all(( ( Object.values(initialData)).map(async (session) => {
+        this.logService.info(
+            `ChatSessionStore: Migrating ${numSessions} chat sessions from storage service to file system`
+        );
+        await Promise.all(( ( Object.values(initialData)).map(async session => {
             await this.writeSession(session);
         })));
         await this.flushIndex();
@@ -385,42 +441,64 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
     async readSession(sessionId) {
         return await this.storeQueue.queue(async () => {
             const storageLocation = this.getStorageLocation(sessionId);
-            return this.readSessionFromLocation(storageLocation, sessionId);
+            return this.readSessionFromLocation(storageLocation.flat, storageLocation.log, sessionId);
         });
     }
-    async readSessionFromLocation(storageLocation, sessionId) {
+    async readSessionFromLocation(flatStorageLocation, logStorageLocation, sessionId) {
+        let fromLocation = flatStorageLocation;
         let rawData;
-        try {
-            rawData = ( (await this.fileService.readFile(storageLocation)).value.toString());
-        }
-        catch (e) {
-            this.reportError('sessionReadFile', `Error reading chat session file ${sessionId}`, e);
-            if (toFileOperationResult(e) === FileOperationResult.FILE_NOT_FOUND && this.previousEmptyWindowStorageRoot) {
-                rawData = await this.readSessionFromPreviousLocation(sessionId);
+        if (logStorageLocation) {
+            try {
+                rawData = (await this.fileService.readFile(logStorageLocation)).value;
+                fromLocation = logStorageLocation;
+            } catch (e) {
+                this.reportError("sessionReadFile", `Error reading log chat session file ${sessionId}`, e);
             }
-            if (!rawData) {
-                return undefined;
+        }
+        if (!rawData) {
+            try {
+                rawData = (await this.fileService.readFile(flatStorageLocation)).value;
+                fromLocation = flatStorageLocation;
+            } catch (e) {
+                this.reportError("sessionReadFile", `Error reading flat chat session file ${sessionId}`, e);
+                if (toFileOperationResult(e) === FileOperationResult.FILE_NOT_FOUND && this.previousEmptyWindowStorageRoot) {
+                    rawData = await this.readSessionFromPreviousLocation(sessionId);
+                }
             }
         }
+        if (!rawData) {
+            return undefined;
+        }
         try {
-            const session = revive(JSON.parse(rawData));
+            let session;
+            const log = ( new ChatSessionOperationLog());
+            if (fromLocation === logStorageLocation) {
+                session = revive(log.read(rawData));
+            } else {
+                session = revive(JSON.parse(( rawData.toString())));
+            }
             for (const request of session.requests) {
                 if (Array.isArray(request.response)) {
-                    request.response = ( request.response.map((response) => {
-                        if (typeof response === 'string') {
+                    request.response = ( request.response.map(response => {
+                        if (typeof response === "string") {
                             return ( new MarkdownString(response));
                         }
                         return response;
                     }));
-                }
-                else if (typeof request.response === 'string') {
+                } else if (typeof request.response === "string") {
                     request.response = [( new MarkdownString(request.response))];
                 }
             }
-            return normalizeSerializableChatData(session);
-        }
-        catch (err) {
-            this.reportError('malformedSession', `Malformed session data in ${storageLocation.fsPath}: [${rawData.substring(0, 20)}${rawData.length > 20 ? '...' : ''}]`, err);
+            return {
+                value: normalizeSerializableChatData(session),
+                serializer: log
+            };
+        } catch (err) {
+            this.reportError(
+                "malformedSession",
+                `Malformed session data in ${fromLocation.fsPath}: [${( rawData.slice(0, 20).toString())}${rawData.byteLength > 20 ? "..." : ""}]`,
+                err
+            );
             return undefined;
         }
     }
@@ -429,18 +507,24 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
         if (this.previousEmptyWindowStorageRoot) {
             const storageLocation2 = joinPath(this.previousEmptyWindowStorageRoot, `${sessionId}.json`);
             try {
-                rawData = ( (await this.fileService.readFile(storageLocation2)).value.toString());
+                rawData = (await this.fileService.readFile(storageLocation2)).value;
                 this.logService.info(`ChatSessionStore: Read chat session ${sessionId} from previous location`);
-            }
-            catch (e) {
-                this.reportError('sessionReadFile', `Error reading chat session file ${sessionId} from previous location`, e);
+            } catch (e) {
+                this.reportError(
+                    "sessionReadFile",
+                    `Error reading chat session file ${sessionId} from previous location`,
+                    e
+                );
                 return undefined;
             }
         }
         return rawData;
     }
     getStorageLocation(chatSessionId) {
-        return joinPath(this.storageRoot, `${chatSessionId}.json`);
+        return {
+            flat: joinPath(this.storageRoot, `${chatSessionId}.json`),
+            log: this.configurationService.getValue("chat.useLogSessionStorage") !== false ? joinPath(this.storageRoot, `${chatSessionId}.jsonl`) : undefined
+        };
     }
     getTransferredSessionStorageLocation(sessionResource) {
         const sessionId = LocalChatSessionUri.parseLocalSessionId(sessionResource);
@@ -450,32 +534,19 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
         return this.storageRoot;
     }
 };
-ChatSessionStore = ChatSessionStore_1 = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, IEnvironmentService)),
-    ( __param(2, ILogService)),
-    ( __param(3, IWorkspaceContextService)),
-    ( __param(4, ITelemetryService)),
-    ( __param(5, IStorageService)),
-    ( __param(6, ILifecycleService)),
-    ( __param(7, IUserDataProfilesService))
-], ChatSessionStore));
+ChatSessionStore = ChatSessionStore_1 = ( __decorate([( __param(0, IFileService)), ( __param(1, IEnvironmentService)), ( __param(2, ILogService)), ( __param(3, IWorkspaceContextService)), ( __param(4, ITelemetryService)), ( __param(5, IStorageService)), ( __param(6, ILifecycleService)), ( __param(7, IUserDataProfilesService)), ( __param(8, IConfigurationService))], ChatSessionStore));
 function isChatSessionEntryMetadata(obj) {
-    return (!!obj &&
-        typeof obj === 'object' &&
-        typeof obj.sessionId === 'string' &&
-        typeof obj.title === 'string' &&
-        typeof obj.lastMessageDate === 'number');
+    return (!!obj && typeof obj === "object" && typeof obj.sessionId === "string" && typeof obj.title === "string" && typeof obj.lastMessageDate === "number");
 }
 function isChatSessionIndex(data) {
-    if (typeof data !== 'object' || data === null) {
+    if (typeof data !== "object" || data === null) {
         return false;
     }
     const index = data;
     if (index.version !== 1) {
         return false;
     }
-    if (typeof index.entries !== 'object' || index.entries === null) {
+    if (typeof index.entries !== "object" || index.entries === null) {
         return false;
     }
     for (const key in index.entries) {
@@ -491,25 +562,28 @@ async function getSessionMetadata(session) {
     if (session instanceof ChatModel) {
         stats = await awaitStatsForSession(session);
     }
-    const timing = session instanceof ChatModel ?
-        session.timing :
-        {
-            startTime: session.creationDate,
-            endTime: session.lastMessageDate
-        };
+    const lastMessageDate = session instanceof ChatModel ? session.lastMessageDate : session.requests.at(-1)?.timestamp ?? session.creationDate;
+    const timing = session instanceof ChatModel ? session.timing :
+    {
+        created: session.creationDate,
+        lastRequestStarted: session.requests.at(-1)?.timestamp,
+        lastRequestEnded: lastMessageDate
+    };
+    let lastResponseState = session instanceof ChatModel ? (session.lastRequest?.response?.state ?? ResponseModelState.Complete) : ResponseModelState.Complete;
+    if (lastResponseState === ResponseModelState.Pending || lastResponseState === ResponseModelState.NeedsInput) {
+        lastResponseState = ResponseModelState.Cancelled;
+    }
     return {
         sessionId: session.sessionId,
-        title: title || ( localize(5967, "New Chat")),
-        lastMessageDate: session.lastMessageDate,
+        title: title || ( localize(6254, "New Chat")),
+        lastMessageDate,
         timing,
         initialLocation: session.initialLocation,
         hasPendingEdits: session instanceof ChatModel ? (session.editingSession?.entries.get().some(e => e.state.get() === ModifiedFileEntryState.Modified)) : false,
         isEmpty: session instanceof ChatModel ? session.getRequests().length === 0 : session.requests.length === 0,
         stats,
         isExternal: session instanceof ChatModel && !LocalChatSessionUri.parseLocalSessionId(session.sessionResource),
-        lastResponseState: session instanceof ChatModel ?
-            (session.lastRequest?.response?.state ?? ResponseModelState.Complete) :
-            ResponseModelState.Complete
+        lastResponseState
     };
 }