@codingame/monaco-vscode-chat-service-override 15.0.2 → 16.0.0

package/vscode/src/vs/workbench/contrib/chat/common/chatProgressTypes/chatToolInvocation.js

@@ -18,18 +18,20 @@ class ChatToolInvocation {
     get resultDetails() {
         return this._resultDetails;
     }
-    constructor(preparedInvocation, toolData) {
+    constructor(preparedInvocation, toolData, toolCallId) {
+        this.toolCallId = toolCallId;
         this.kind = 'toolInvocation';
         this._isComplete = false;
         this._isCompleteDeferred = ( new DeferredPromise());
         this._confirmDeferred = ( new DeferredPromise());
-        const defaultMessage = ( localize(4856, "Using {0}", `"${toolData.displayName}"`));
+        const defaultMessage = ( localize(4983, "Using {0}", `"${toolData.displayName}"`));
         const invocationMessage = preparedInvocation?.invocationMessage ?? defaultMessage;
         this.invocationMessage = invocationMessage;
         this.pastTenseMessage = preparedInvocation?.pastTenseMessage;
         this._confirmationMessages = preparedInvocation?.confirmationMessages;
         this.presentation = preparedInvocation?.presentation;
         this.toolSpecificData = preparedInvocation?.toolSpecificData;
+        this.toolId = toolData.id;
         if (!this._confirmationMessages) {
             this._isConfirmed = true;
             this._confirmDeferred.complete(true);
@@ -62,6 +64,7 @@ class ChatToolInvocation {
             isComplete: this._isComplete,
             resultDetails: this._resultDetails,
             toolSpecificData: this.toolSpecificData,
+            toolCallId: this.toolCallId,
         };
     }
 }

package/vscode/src/vs/workbench/contrib/chat/common/chatServiceImpl.d.ts

@@ -10,7 +10,6 @@ import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platfo
 import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
 import { IWorkbenchAssignmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/assignment/common/assignmentService.service";
 import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
-import { ChatAgentLocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents";
 import { IChatAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service";
 import { ChatModel, IChatModel, IChatRequestModel, IChatRequestVariableData, IExportableChatData, ISerializableChatData } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatModel";
 import { IParsedChatRequest } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatParserTypes";
@@ -18,6 +17,7 @@ import { IChatCompleteResponse, IChatDetail, IChatSendRequestData, IChatSendRequ
 import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
 import { IChatSlashCommandService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSlashCommands.service";
 import { IChatVariablesService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatVariables.service";
+import { ChatAgentLocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
 export declare class ChatService extends Disposable implements IChatService {
     private readonly storageService;
     private readonly logService;
@@ -50,24 +50,29 @@ export declare class ChatService extends Disposable implements IChatService {
     }>;
     private readonly _sessionFollowupCancelTokens;
     private readonly _chatServiceTelemetry;
+    private readonly _chatSessionStore;
+    get unifiedViewEnabled(): boolean;
+    private get useFileStorage();
+    private get isEmptyWindow();
     constructor(storageService: IStorageService, logService: ILogService, extensionService: IExtensionService, instantiationService: IInstantiationService, telemetryService: ITelemetryService, workspaceContextService: IWorkspaceContextService, chatSlashCommandService: IChatSlashCommandService, chatVariablesService: IChatVariablesService, chatAgentService: IChatAgentService, configurationService: IConfigurationService, experimentService: IWorkbenchAssignmentService);
     isEnabled(location: ChatAgentLocation): boolean;
     private saveState;
     private syncEmptyWindowChats;
     notifyUserAction(action: IChatUserActionEvent): void;
-    setChatSessionTitle(sessionId: string, title: string): void;
+    setChatSessionTitle(sessionId: string, title: string): Promise<void>;
     private trace;
     private error;
     private deserializeChats;
     private getTransferredSessionData;
-    getHistory(): IChatDetail[];
-    removeHistoryEntry(sessionId: string): void;
-    clearAllHistoryEntries(): void;
-    startSession(location: ChatAgentLocation, token: CancellationToken): ChatModel;
+    getHistory(): Promise<IChatDetail[]>;
+    removeHistoryEntry(sessionId: string): Promise<void>;
+    clearAllHistoryEntries(): Promise<void>;
+    startSession(location: ChatAgentLocation, token: CancellationToken, isGlobalEditingSession?: boolean): ChatModel;
     private _startSession;
     private initializeSession;
     getSession(sessionId: string): IChatModel | undefined;
-    getOrRestoreSession(sessionId: string): ChatModel | undefined;
+    getOrRestoreSession(sessionId: string): Promise<ChatModel | undefined>;
+    isPersistedSessionEmpty(sessionId: string): boolean;
     loadSessionFromContent(data: IExportableChatData | ISerializableChatData): IChatModel | undefined;
     resendRequest(request: IChatRequestModel, options?: IChatSendRequestOptions): Promise<void>;
     sendRequest(sessionId: string, request: string, options?: IChatSendRequestOptions): Promise<IChatSendRequestData | undefined>;
@@ -81,7 +86,10 @@ export declare class ChatService extends Disposable implements IChatService {
     adoptRequest(sessionId: string, request: IChatRequestModel): Promise<void>;
     addCompleteRequest(sessionId: string, message: IParsedChatRequest | string, variableData: IChatRequestVariableData | undefined, attempt: number | undefined, response: IChatCompleteResponse): Promise<void>;
     cancelCurrentRequestForSession(sessionId: string): void;
-    clearSession(sessionId: string): void;
+    clearSession(sessionId: string): Promise<void>;
     hasSessions(): boolean;
     transferChatSession(transferredSessionData: IChatTransferredSessionData, toWorkspace: URI): void;
+    isEditingLocation(location: ChatAgentLocation): boolean;
+    getChatStorageFolder(): URI;
+    logChatIndex(): void;
 }

package/vscode/src/vs/workbench/contrib/chat/common/chatServiceImpl.js

@@ -2,6 +2,7 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { CancellationToken, CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { memoize } from '@codingame/monaco-vscode-api/vscode/vs/base/common/decorators';
 import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
 import { ErrorNoTelemetry } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
@@ -23,14 +24,15 @@ import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platfo
 import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
 import { IWorkbenchAssignmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/assignment/common/assignmentService.service';
 import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
-import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents';
 import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
 import { normalizeSerializableChatData, ChatModel, ChatRequestRemovalReason, updateRanges, toChatHistoryContent, ChatRequestModel } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatModel';
 import { ChatRequestAgentPart, ChatRequestAgentSubcommandPart, chatSubcommandLeader, chatAgentLeader, ChatRequestSlashCommandPart, getPromptText } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
 import { ChatRequestParser } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatRequestParser';
 import { ChatServiceTelemetry } from './chatServiceTelemetry.js';
+import { ChatSessionStore } from './chatSessionStore.js';
 import { IChatSlashCommandService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSlashCommands.service';
 import { IChatVariablesService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatVariables.service';
+import { ChatConfiguration, ChatAgentLocation, ChatMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { ChatMessageRole } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
 import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
 
@@ -61,6 +63,16 @@ let ChatService = class ChatService extends Disposable {
     get transferredSessionData() {
         return this._transferredSessionData;
     }
+    get unifiedViewEnabled() {
+        return !!this.configurationService.getValue(ChatConfiguration.UnifiedChatView);
+    }
+    get useFileStorage() {
+        return this.configurationService.getValue(ChatConfiguration.UseFileStorage);
+    }
+    get isEmptyWindow() {
+        const workspace = this.workspaceContextService.getWorkspace();
+        return !workspace.configuration && workspace.folders.length === 0;
+    }
     constructor(storageService, logService, extensionService, instantiationService, telemetryService, workspaceContextService, chatSlashCommandService, chatVariablesService, chatAgentService, configurationService, experimentService) {
         super();
         this.storageService = storageService;
@@ -85,8 +97,7 @@ let ChatService = class ChatService extends Disposable {
         this.onDidDisposeSession = this._onDidDisposeSession.event;
         this._sessionFollowupCancelTokens = this._register(( new DisposableMap()));
         this._chatServiceTelemetry = this.instantiationService.createInstance(ChatServiceTelemetry);
-        const isEmptyWindow = !workspaceContextService.getWorkspace().folders.length;
-        const sessionData = storageService.get(serializedChatKey, isEmptyWindow ? StorageScope.APPLICATION : StorageScope.WORKSPACE, '');
+        const sessionData = storageService.get(serializedChatKey, this.isEmptyWindow ? StorageScope.APPLICATION : StorageScope.WORKSPACE, '');
         if (sessionData) {
             this._persistedSessions = this.deserializeChats(sessionData);
             const countsForLog = ( Object.keys(this._persistedSessions)).length;
@@ -106,9 +117,13 @@ let ChatService = class ChatService extends Disposable {
                 sessionId: transferredChat.sessionId,
                 inputValue: transferredData.inputValue,
                 location: transferredData.location,
-                toolsAgentModeEnabled: transferredData.toolsAgentModeEnabled,
+                mode: transferredData.mode,
             };
         }
+        this._chatSessionStore = this._register(this.instantiationService.createInstance(ChatSessionStore));
+        if (this.useFileStorage) {
+            this._chatSessionStore.migrateDataIfNeeded(() => this._persistedSessions);
+        }
         this._register(storageService.onWillSaveState(() => this.saveState()));
     }
     isEnabled(location) {
@@ -116,27 +131,43 @@ let ChatService = class ChatService extends Disposable {
     }
     saveState() {
         const liveChats = Array.from(( this._sessionModels.values()))
-            .filter(session => session.initialLocation === ChatAgentLocation.Panel || session.initialLocation === ChatAgentLocation.EditingSession)
-            .filter(session => session.getRequests().length > 0);
-        const isEmptyWindow = !this.workspaceContextService.getWorkspace().folders.length;
-        if (isEmptyWindow) {
-            this.syncEmptyWindowChats(liveChats);
+            .filter(session => session.initialLocation === ChatAgentLocation.Panel || session.initialLocation === ChatAgentLocation.EditingSession);
+        if (this.useFileStorage) {
+            this._chatSessionStore.storeSessions(liveChats);
         }
         else {
-            let allSessions = liveChats;
-            allSessions = allSessions.concat(( Object.values(this._persistedSessions))
-                .filter(session => !( this._sessionModels.has(session.sessionId)))
-                .filter(session => session.requests.length));
-            allSessions.sort((a, b) => (b.creationDate ?? 0) - (a.creationDate ?? 0));
-            allSessions = allSessions.slice(0, maxPersistedSessions);
-            if (allSessions.length) {
-                this.trace('onWillSaveState', `Persisting ${allSessions.length} sessions`);
+            if (this.isEmptyWindow) {
+                this.syncEmptyWindowChats(liveChats);
             }
-            const serialized = JSON.stringify(allSessions);
-            if (allSessions.length) {
-                this.trace('onWillSaveState', `Persisting ${serialized.length} chars`);
+            else {
+                let allSessions = liveChats;
+                allSessions = allSessions.concat(( Object.values(this._persistedSessions))
+                    .filter(session => !( this._sessionModels.has(session.sessionId)))
+                    .filter(session => session.requests.length));
+                allSessions.sort((a, b) => (b.creationDate ?? 0) - (a.creationDate ?? 0));
+                let hasPersistedEditSession = false;
+                allSessions = allSessions.filter(s => {
+                    if (s.initialLocation === ChatAgentLocation.EditingSession) {
+                        if (hasPersistedEditSession) {
+                            return false;
+                        }
+                        else {
+                            hasPersistedEditSession = true;
+                            return true;
+                        }
+                    }
+                    return true;
+                });
+                allSessions = allSessions.slice(0, maxPersistedSessions);
+                if (allSessions.length) {
+                    this.trace('onWillSaveState', `Persisting ${allSessions.length} sessions`);
+                }
+                const serialized = JSON.stringify(allSessions);
+                if (allSessions.length) {
+                    this.trace('onWillSaveState', `Persisting ${serialized.length} chars`);
+                }
+                this.storageService.store(serializedChatKey, serialized, StorageScope.WORKSPACE, StorageTarget.MACHINE);
             }
-            this.storageService.store(serializedChatKey, serialized, StorageScope.WORKSPACE, StorageTarget.MACHINE);
         }
         this._deletedChatIds.clear();
     }
@@ -180,12 +211,16 @@ let ChatService = class ChatService extends Disposable {
         this._chatServiceTelemetry.notifyUserAction(action);
         this._onDidPerformUserAction.fire(action);
     }
-    setChatSessionTitle(sessionId, title) {
+    async setChatSessionTitle(sessionId, title) {
         const model = this._sessionModels.get(sessionId);
         if (model) {
             model.setCustomTitle(title);
             return;
         }
+        if (this.useFileStorage) {
+            await this._chatSessionStore.setSessionTitle(sessionId, title);
+            return;
+        }
         const session = this._persistedSessions[sessionId];
         if (session) {
             session.customTitle = title;
@@ -245,7 +280,28 @@ let ChatService = class ChatService extends Disposable {
         this.storageService.store(globalChatKey, JSON.stringify(filtered), StorageScope.PROFILE, StorageTarget.MACHINE);
         return transferred;
     }
-    getHistory() {
+    async getHistory() {
+        if (this.useFileStorage) {
+            const liveSessionItems = ( Array.from(( this._sessionModels.values()))
+                .filter(session => !session.isImported && (session.initialLocation !== ChatAgentLocation.EditingSession || this.unifiedViewEnabled))
+                .map(session => {
+                const title = session.title || ( localize(4984, "New Chat"));
+                return {
+                    sessionId: session.sessionId,
+                    title,
+                    lastMessageDate: session.lastMessageDate,
+                    isActive: true,
+                };
+            }));
+            const index = await this._chatSessionStore.getIndex();
+            const entries = ( ( Object.values(index))
+                .filter(entry => !( this._sessionModels.has(entry.sessionId)) && !entry.isImported && !entry.isEmpty)
+                .map((entry) => ({
+                ...entry,
+                isActive: ( this._sessionModels.has(entry.sessionId)),
+            })));
+            return [...liveSessionItems, ...entries];
+        }
         const persistedSessions = ( Object.values(this._persistedSessions))
             .filter(session => session.requests.length > 0)
             .filter(session => !( this._sessionModels.has(session.sessionId)));
@@ -263,7 +319,7 @@ let ChatService = class ChatService extends Disposable {
         const liveSessionItems = ( Array.from(( this._sessionModels.values()))
             .filter(session => !session.isImported && session.initialLocation !== ChatAgentLocation.EditingSession)
             .map(session => {
-            const title = session.title || ( localize(4857, "New Chat"));
+            const title = session.title || ( localize(4984, "New Chat"));
             return {
                 sessionId: session.sessionId,
                 title,
@@ -273,24 +329,35 @@ let ChatService = class ChatService extends Disposable {
         }));
         return [...liveSessionItems, ...persistedSessionItems];
     }
-    removeHistoryEntry(sessionId) {
+    async removeHistoryEntry(sessionId) {
+        if (this.useFileStorage) {
+            await this._chatSessionStore.deleteSession(sessionId);
+            return;
+        }
         if (this._persistedSessions[sessionId]) {
             this._deletedChatIds.add(sessionId);
             delete this._persistedSessions[sessionId];
             this.saveState();
         }
     }
-    clearAllHistoryEntries() {
+    async clearAllHistoryEntries() {
+        if (this.useFileStorage) {
+            await this._chatSessionStore.clearAllSessions();
+            return;
+        }
         ( Object.values(this._persistedSessions)).forEach(session => this._deletedChatIds.add(session.sessionId));
         this._persistedSessions = {};
         this.saveState();
     }
-    startSession(location, token) {
+    startSession(location, token, isGlobalEditingSession = true) {
         this.trace('startSession');
-        return this._startSession(undefined, location, token);
+        return this._startSession(undefined, location, isGlobalEditingSession, token);
     }
-    _startSession(someSessionHistory, location, token) {
+    _startSession(someSessionHistory, location, isGlobalEditingSession, token) {
         const model = this.instantiationService.createInstance(ChatModel, someSessionHistory, location);
+        if (location === ChatAgentLocation.EditingSession || (this.unifiedViewEnabled && location === ChatAgentLocation.Panel)) {
+            model.startEditingSession(isGlobalEditingSession);
+        }
         this._sessionModels.set(model.sessionId, model);
         this.initializeSession(model, token);
         return model;
@@ -304,14 +371,17 @@ let ChatService = class ChatService extends Disposable {
             if (!defaultAgentData) {
                 throw ( new ErrorNoTelemetry('No default agent contributed'));
             }
-            await this.extensionService.activateByEvent(`onChatParticipant:${defaultAgentData.id}`);
-            const defaultAgent = this.chatAgentService.getActivatedAgents().find(agent => agent.id === defaultAgentData.id);
-            if (!defaultAgent) {
-                throw ( new ErrorNoTelemetry('No default agent registered'));
+            if (this.configurationService.getValue('chat.setupFromDialog')) {
+                this.extensionService.activateByEvent(`onChatParticipant:${defaultAgentData.id}`);
+            }
+            else {
+                await this.extensionService.activateByEvent(`onChatParticipant:${defaultAgentData.id}`);
+                const defaultAgent = this.chatAgentService.getActivatedAgents().find(agent => agent.id === defaultAgentData.id);
+                if (!defaultAgent) {
+                    throw ( new ErrorNoTelemetry('No default agent registered'));
+                }
             }
-            const welcomeMessage = (await defaultAgent.provideWelcomeMessage?.(token)) ?? undefined;
-            const sampleQuestions = (await defaultAgent.provideSampleQuestions?.(model.initialLocation, token)) ?? undefined;
-            model.initialize(welcomeMessage, sampleQuestions);
+            model.initialize();
         }
         catch (err) {
             this.trace('startSession', `initializeSession failed: ${err}`);
@@ -323,26 +393,38 @@ let ChatService = class ChatService extends Disposable {
     getSession(sessionId) {
         return this._sessionModels.get(sessionId);
     }
-    getOrRestoreSession(sessionId) {
+    async getOrRestoreSession(sessionId) {
         this.trace('getOrRestoreSession', `sessionId: ${sessionId}`);
         const model = this._sessionModels.get(sessionId);
         if (model) {
             return model;
         }
-        const sessionData = revive(this._persistedSessions[sessionId]);
+        let sessionData;
+        if (this.useFileStorage) {
+            sessionData = revive(await this._chatSessionStore.readSession(sessionId));
+        }
+        else {
+            sessionData = revive(this._persistedSessions[sessionId]);
+        }
         if (!sessionData) {
             return undefined;
         }
-        const session = this._startSession(sessionData, sessionData.initialLocation ?? ChatAgentLocation.Panel, CancellationToken.None);
+        const session = this._startSession(sessionData, sessionData.initialLocation ?? ChatAgentLocation.Panel, true, CancellationToken.None);
         const isTransferred = this.transferredSessionData?.sessionId === sessionId;
         if (isTransferred) {
-            this.chatAgentService.toggleToolsAgentMode(this.transferredSessionData.toolsAgentModeEnabled);
             this._transferredSessionData = undefined;
         }
         return session;
     }
+    isPersistedSessionEmpty(sessionId) {
+        const session = this._persistedSessions[sessionId];
+        if (session) {
+            return session.requests.length === 0;
+        }
+        return this._chatSessionStore.isSessionEmpty(sessionId);
+    }
     loadSessionFromContent(data) {
-        return this._startSession(data, data.initialLocation ?? ChatAgentLocation.Panel, CancellationToken.None);
+        return this._startSession(data, data.initialLocation ?? ChatAgentLocation.Panel, true, CancellationToken.None);
     }
     async resendRequest(request, options) {
         const model = this._sessionModels.get(request.session.sessionId);
@@ -358,7 +440,7 @@ let ChatService = class ChatService extends Disposable {
         const location = options?.location ?? model.initialLocation;
         const attempt = options?.attempt ?? 0;
         const enableCommandDetection = !options?.noCommandDetection;
-        const defaultAgent = this.chatAgentService.getDefaultAgent(location);
+        const defaultAgent = this.chatAgentService.getDefaultAgent(location, options?.mode);
         model.removeRequest(request.id, ChatRequestRemovalReason.Resend);
         const resendOptions = {
             ...options,
@@ -400,7 +482,7 @@ let ChatService = class ChatService extends Disposable {
         }
         const location = options?.location ?? model.initialLocation;
         const attempt = options?.attempt ?? 0;
-        const defaultAgent = this.chatAgentService.getDefaultAgent(location);
+        const defaultAgent = this.chatAgentService.getDefaultAgent(location, options?.mode);
         const parsedRequest = this.parseChatRequest(sessionId, request, location, options);
         const agent = parsedRequest.parts.find((r) => r instanceof ChatRequestAgentPart)?.agent ?? defaultAgent;
         const agentSlashCommandPart = parsedRequest.parts.find((r) => r instanceof ChatRequestAgentSubcommandPart);
@@ -417,7 +499,7 @@ let ChatService = class ChatService extends Disposable {
             if (!agent) {
                 throw ( new Error(`Unknown agent: ${options.agentId}`));
             }
-            parserContext = { selectedAgent: agent };
+            parserContext = { selectedAgent: agent, mode: options.mode };
             const commandPart = options.slashCommand ? ` ${chatSubcommandLeader}${options.slashCommand}` : '';
             request = `${chatAgentLeader}${agent.name}${commandPart} ${request}`;
         }
@@ -494,7 +576,7 @@ let ChatService = class ChatService extends Disposable {
                 if (agentPart || (defaultAgent && !commandPart)) {
                     const prepareChatAgentRequest = async (agent, command, enableCommandDetection, chatRequest, isParticipantDetected) => {
                         const initVariableData = { variables: [] };
-                        request = chatRequest ?? model.addRequest(parsedRequest, initVariableData, attempt, agent, command, options?.confirmation, options?.locationData, options?.attachedContext);
+                        request = chatRequest ?? model.addRequest(parsedRequest, initVariableData, attempt, agent, command, options?.confirmation, options?.locationData, options?.attachedContext, undefined, options?.userSelectedModelId);
                         let variableData;
                         let message;
                         if (chatRequest) {
@@ -522,10 +604,11 @@ let ChatService = class ChatService extends Disposable {
                             locationData: request.locationData,
                             acceptedConfirmationData: options?.acceptedConfirmationData,
                             rejectedConfirmationData: options?.rejectedConfirmationData,
-                            userSelectedModelId: options?.userSelectedModelId
+                            userSelectedModelId: options?.userSelectedModelId,
+                            userSelectedTools: options?.userSelectedTools
                         };
                     };
-                    if (this.configurationService.getValue('chat.detectParticipant.enabled') !== false && this.chatAgentService.hasChatParticipantDetectionProviders() && !agentPart && !commandPart && !agentSlashCommandPart && enableCommandDetection) {
+                    if (this.configurationService.getValue('chat.detectParticipant.enabled') !== false && this.chatAgentService.hasChatParticipantDetectionProviders() && !agentPart && !commandPart && !agentSlashCommandPart && enableCommandDetection && options?.mode !== ChatMode.Agent && options?.mode !== ChatMode.Edit) {
                         const defaultAgentHistory = this.getHistoryEntriesFromModel(requests, model.sessionId, location, defaultAgent.id);
                         const chatAgentRequest = await prepareChatAgentRequest(defaultAgent, undefined, enableCommandDetection, undefined, false);
                         const result = await this.chatAgentService.detectAgentOrCommand(chatAgentRequest, defaultAgentHistory, { location }, token);
@@ -578,7 +661,7 @@ let ChatService = class ChatService extends Disposable {
                 else {
                     if (!rawResult) {
                         this.trace('sendRequest', `Provider returned no response for session ${model.sessionId}`);
-                        rawResult = { errorDetails: { message: ( localize(4858, "Provider returned null response")) } };
+                        rawResult = { errorDetails: { message: ( localize(4985, "Provider returned null response")) } };
                     }
                     const result = rawResult.errorDetails?.responseIsFiltered ? 'filtered' :
                         rawResult.errorDetails && gotProgress ? 'errorWithOutput' :
@@ -710,12 +793,12 @@ let ChatService = class ChatService extends Disposable {
     }
     getHistoryEntriesFromModel(requests, sessionId, location, forAgentId) {
         const history = [];
+        const agent = this.chatAgentService.getAgent(forAgentId);
         for (const request of requests) {
             if (!request.response) {
                 continue;
             }
-            const defaultAgentId = this.chatAgentService.getDefaultAgent(location)?.id;
-            if (forAgentId !== request.response.agent?.id && forAgentId !== defaultAgentId) {
+            if (forAgentId !== request.response.agent?.id && !agent?.isDefault) {
                 continue;
             }
             const promptTextResult = getPromptText(request.message);
@@ -774,7 +857,7 @@ let ChatService = class ChatService extends Disposable {
         const parsedRequest = typeof message === 'string' ?
             this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(sessionId, message) :
             message;
-        const request = model.addRequest(parsedRequest, variableData || { variables: [] }, attempt ?? 0, undefined, undefined, undefined, undefined, undefined, undefined, true);
+        const request = model.addRequest(parsedRequest, variableData || { variables: [] }, attempt ?? 0, undefined, undefined, undefined, undefined, undefined, true);
         if (typeof response.message === 'string') {
             model.acceptResponseProgress(request, { content: ( new MarkdownString(response.message)), kind: 'markdownContent' });
         }
@@ -794,16 +877,31 @@ let ChatService = class ChatService extends Disposable {
         this._pendingRequests.get(sessionId)?.cancel();
         this._pendingRequests.deleteAndDispose(sessionId);
     }
-    clearSession(sessionId) {
+    async clearSession(sessionId) {
         this.trace('clearSession', `sessionId: ${sessionId}`);
         const model = this._sessionModels.get(sessionId);
         if (!model) {
             throw ( new Error(`Unknown session: ${sessionId}`));
         }
         if (model.initialLocation === ChatAgentLocation.Panel) {
-            const sessionData = JSON.parse(JSON.stringify(model));
-            sessionData.isNew = true;
-            this._persistedSessions[sessionId] = sessionData;
+            if (this.useFileStorage) {
+                if (model.getRequests().length === 0) {
+                    await this._chatSessionStore.deleteSession(sessionId);
+                }
+                else {
+                    await this._chatSessionStore.storeSessions([model]);
+                }
+            }
+            else {
+                if (model.getRequests().length === 0) {
+                    delete this._persistedSessions[sessionId];
+                }
+                else {
+                    const sessionData = JSON.parse(JSON.stringify(model));
+                    sessionData.isNew = true;
+                    this._persistedSessions[sessionId] = sessionData;
+                }
+            }
         }
         this._sessionModels.deleteAndDispose(sessionId);
         this._pendingRequests.get(sessionId)?.cancel();
@@ -811,7 +909,12 @@ let ChatService = class ChatService extends Disposable {
         this._onDidDisposeSession.fire({ sessionId, reason: 'cleared' });
     }
     hasSessions() {
-        return ( Object.values(this._persistedSessions)).length > 0;
+        if (this.useFileStorage) {
+            return this._chatSessionStore.hasSessions();
+        }
+        else {
+            return ( Object.values(this._persistedSessions)).length > 0;
+        }
     }
     transferChatSession(transferredSessionData, toWorkspace) {
         const model = Iterable.find(( this._sessionModels.values()), model => model.sessionId === transferredSessionData.sessionId);
@@ -827,12 +930,27 @@ let ChatService = class ChatService extends Disposable {
             toWorkspace: toWorkspace,
             inputValue: transferredSessionData.inputValue,
             location: transferredSessionData.location,
-            toolsAgentModeEnabled: transferredSessionData.toolsAgentModeEnabled,
+            mode: transferredSessionData.mode,
         });
         this.storageService.store(globalChatKey, JSON.stringify(existingRaw), StorageScope.PROFILE, StorageTarget.MACHINE);
         this.trace('transferChatSession', `Transferred session ${model.sessionId} to workspace ${( toWorkspace.toString())}`);
     }
+    isEditingLocation(location) {
+        return location === ChatAgentLocation.EditingSession || this.unifiedViewEnabled;
+    }
+    getChatStorageFolder() {
+        return this._chatSessionStore.getChatStorageFolder();
+    }
+    logChatIndex() {
+        this._chatSessionStore.logIndex();
+    }
 };
+ChatService.__decorator = ( __decorate([
+    memoize
+], ChatService.prototype, "unifiedViewEnabled", null));
+ChatService.__decorator = ( __decorate([
+    memoize
+], ChatService.prototype, "useFileStorage", null));
 ChatService = ( __decorate([
     ( __param(0, IStorageService)),
     ( __param(1, ILogService)),

package/vscode/src/vs/workbench/contrib/chat/common/chatSessionStore.d.ts

@@ -0,0 +1,66 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+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 { ChatModel, ISerializableChatData, ISerializableChatsData } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatModel";
+import { ChatAgentLocation, ChatMode } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
+export declare class ChatSessionStore extends Disposable {
+    private readonly fileService;
+    private readonly environmentService;
+    private readonly logService;
+    private readonly workspaceContextService;
+    private readonly telemetryService;
+    private readonly storageService;
+    private readonly lifecycleService;
+    private readonly storageRoot;
+    private readonly storeQueue;
+    private storeTask;
+    private shuttingDown;
+    constructor(fileService: IFileService, environmentService: IEnvironmentService, logService: ILogService, workspaceContextService: IWorkspaceContextService, telemetryService: ITelemetryService, storageService: IStorageService, lifecycleService: ILifecycleService);
+    storeSessions(sessions: ChatModel[]): Promise<void>;
+    private writeSession;
+    private flushIndex;
+    private getIndexStorageScope;
+    private trimEntries;
+    private internalDeleteSession;
+    hasSessions(): boolean;
+    isSessionEmpty(sessionId: string): boolean;
+    deleteSession(sessionId: string): Promise<void>;
+    clearAllSessions(): Promise<void>;
+    setSessionTitle(sessionId: string, title: string): Promise<void>;
+    private reportError;
+    private indexCache;
+    private internalGetIndex;
+    getIndex(): Promise<IChatSessionIndex>;
+    logIndex(): void;
+    migrateDataIfNeeded(getInitialData: () => ISerializableChatsData | undefined): Promise<void>;
+    private migrate;
+    readSession(sessionId: string): Promise<ISerializableChatData | undefined>;
+    private getStorageLocation;
+    getChatStorageFolder(): URI;
+}
+interface IChatSessionEntryMetadata {
+    sessionId: string;
+    title: string;
+    lastMessageDate: number;
+    isImported?: boolean;
+    initialLocation?: ChatAgentLocation;
+    isEmpty?: boolean;
+}
+export type IChatSessionIndex = Record<string, IChatSessionEntryMetadata>;
+export interface IChatTransfer {
+    toWorkspace: URI;
+    timestampInMilliseconds: number;
+    inputValue: string;
+    location: ChatAgentLocation;
+    mode: ChatMode;
+}
+export interface IChatTransfer2 extends IChatTransfer {
+    chat: ISerializableChatData;
+}
+export {};