@codingame/monaco-vscode-chat-service-override 8.0.4 → 9.0.0

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

@@ -11,6 +11,8 @@ import { revive } from 'vscode/vscode/vs/base/common/marshalling';
 import { StopWatch } from 'vscode/vscode/vs/base/common/stopwatch';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { localize } from 'vscode/vscode/vs/nls';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { Progress } from 'vscode/vscode/vs/platform/progress/common/progress';
@@ -20,24 +22,38 @@ import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/te
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
 import { ChatAgentLocation } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
 import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
-import { ChatModel, ChatWelcomeMessageModel, ChatRequestRemovalReason, getHistoryEntriesFromModel, updateRanges, ChatRequestModel } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatModel';
+import { CONTEXT_VOTE_UP_ENABLED } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { normalizeSerializableChatData, ChatModel, ChatWelcomeMessageModel, ChatRequestRemovalReason, updateRanges, ChatRequestModel } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatModel';
 import { ChatRequestAgentPart, ChatRequestAgentSubcommandPart, chatSubcommandLeader, chatAgentLeader, ChatRequestSlashCommandPart, getPromptText } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
 import { ChatRequestParser } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatRequestParser';
 import { ChatServiceTelemetry } from './chatServiceTelemetry.js';
 import { IChatSlashCommandService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatSlashCommands.service';
 import { IChatVariablesService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatVariables.service';
 import { ChatMessageRole } from 'vscode/vscode/vs/workbench/contrib/chat/common/languageModels';
+import { IWorkbenchAssignmentService } from 'vscode/vscode/vs/workbench/services/assignment/common/assignmentService.service';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
 
 const serializedChatKey = 'interactive.sessions';
 const globalChatKey = 'chat.workspaceTransfer';
 const SESSION_TRANSFER_EXPIRATION_IN_MILLISECONDS = 1000 * 60;
 const maxPersistedSessions = 25;
+class CancellableRequest {
+    constructor(cancellationTokenSource, requestId) {
+        this.cancellationTokenSource = cancellationTokenSource;
+        this.requestId = requestId;
+    }
+    dispose() {
+        this.cancellationTokenSource.dispose();
+    }
+    cancel() {
+        this.cancellationTokenSource.cancel();
+    }
+}
 let ChatService = class ChatService extends Disposable {
     get transferredSessionData() {
         return this._transferredSessionData;
     }
-    constructor(storageService, logService, extensionService, instantiationService, telemetryService, workspaceContextService, chatSlashCommandService, chatVariablesService, chatAgentService) {
+    constructor(storageService, logService, extensionService, instantiationService, telemetryService, workspaceContextService, chatSlashCommandService, chatVariablesService, chatAgentService, workbenchAssignmentService, contextKeyService, configurationService) {
         super();
         this.storageService = storageService;
         this.logService = logService;
@@ -48,15 +64,18 @@ let ChatService = class ChatService extends Disposable {
         this.chatSlashCommandService = chatSlashCommandService;
         this.chatVariablesService = chatVariablesService;
         this.chatAgentService = chatAgentService;
+        this.configurationService = configurationService;
         this._sessionModels = this._register(( (new DisposableMap())));
         this._pendingRequests = this._register(( (new DisposableMap())));
+        this._deletedChatIds = ( (new Set()));
         this._onDidPerformUserAction = this._register(( (new Emitter())));
         this.onDidPerformUserAction = this._onDidPerformUserAction.event;
         this._onDidDisposeSession = this._register(( (new Emitter())));
         this.onDidDisposeSession = this._onDidDisposeSession.event;
         this._sessionFollowupCancelTokens = this._register(( (new DisposableMap())));
         this._chatServiceTelemetry = this.instantiationService.createInstance(ChatServiceTelemetry);
-        const sessionData = storageService.get(serializedChatKey, StorageScope.WORKSPACE, '');
+        const isEmptyWindow = !workspaceContextService.getWorkspace().folders.length;
+        const sessionData = storageService.get(serializedChatKey, isEmptyWindow ? StorageScope.APPLICATION : StorageScope.WORKSPACE, '');
         if (sessionData) {
             this._persistedSessions = this.deserializeChats(sessionData);
             const countsForLog = ( (Object.keys(this._persistedSessions))).length;
@@ -75,32 +94,90 @@ let ChatService = class ChatService extends Disposable {
             this._transferredSessionData = { sessionId: transferredChat.sessionId, inputValue: transferredData.inputValue };
         }
         this._register(storageService.onWillSaveState(() => this.saveState()));
+        const voteUpEnabled = CONTEXT_VOTE_UP_ENABLED.bindTo(contextKeyService);
+        workbenchAssignmentService.getTreatment('chatVoteUpEnabled')
+            .then(value => voteUpEnabled.set(!!value));
     }
     isEnabled(location) {
         return this.chatAgentService.getContributedDefaultAgent(location) !== undefined;
     }
     saveState() {
-        let allSessions = Array.from(( (this._sessionModels.values())))
+        const liveChats = Array.from(( (this._sessionModels.values())))
             .filter(session => session.initialLocation === ChatAgentLocation.Panel)
             .filter(session => session.getRequests().length > 0);
-        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`);
+        const isEmptyWindow = !this.workspaceContextService.getWorkspace().folders.length;
+        if (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));
+            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();
+    }
+    syncEmptyWindowChats(thisWindowChats) {
+        const sessionData = this.storageService.get(serializedChatKey, StorageScope.APPLICATION, '');
+        const originalPersistedSessions = this._persistedSessions;
+        let persistedSessions;
+        if (sessionData) {
+            persistedSessions = this.deserializeChats(sessionData);
+            const countsForLog = ( (Object.keys(persistedSessions))).length;
+            if (countsForLog > 0) {
+                this.trace('constructor', `Restored ${countsForLog} persisted sessions`);
+            }
+        }
+        else {
+            persistedSessions = {};
+        }
+        this._deletedChatIds.forEach(id => delete persistedSessions[id]);
+        ( (Object.values(originalPersistedSessions))).forEach(session => {
+            const persistedSession = persistedSessions[session.sessionId];
+            if (persistedSession && session.requests.length > persistedSession.requests.length) {
+                persistedSessions[session.sessionId] = session;
+            }
+            else if (!persistedSession && session.isNew) {
+                session.isNew = false;
+                persistedSessions[session.sessionId] = session;
+            }
+        });
+        this._persistedSessions = persistedSessions;
+        const allSessions = { ...this._persistedSessions };
+        for (const chat of thisWindowChats) {
+            allSessions[chat.sessionId] = chat;
+        }
+        let sessionsList = ( (Object.values(allSessions)));
+        sessionsList.sort((a, b) => (b.creationDate ?? 0) - (a.creationDate ?? 0));
+        sessionsList = sessionsList.slice(0, maxPersistedSessions);
+        const data = JSON.stringify(sessionsList);
+        this.storageService.store(serializedChatKey, data, StorageScope.APPLICATION, StorageTarget.MACHINE);
     }
     notifyUserAction(action) {
         this._chatServiceTelemetry.notifyUserAction(action);
         this._onDidPerformUserAction.fire(action);
     }
+    setChatSessionTitle(sessionId, title) {
+        const model = this._sessionModels.get(sessionId);
+        if (model) {
+            model.setCustomTitle(title);
+            return;
+        }
+        const session = this._persistedSessions[sessionId];
+        if (session) {
+            session.customTitle = title;
+        }
+    }
     trace(method, message) {
         if (message) {
             this.logService.trace(`ChatService#${method}: ${message}`);
@@ -134,7 +211,7 @@ let ChatService = class ChatService extends Disposable {
                         request.response = [( (new MarkdownString(request.response)))];
                     }
                 }
-                acc[session.sessionId] = session;
+                acc[session.sessionId] = normalizeSerializableChatData(session);
                 return acc;
             }, {});
             return sessions;
@@ -158,27 +235,42 @@ let ChatService = class ChatService extends Disposable {
         return transferred;
     }
     getHistory() {
-        const sessions = ( (Object.values(this._persistedSessions)))
-            .filter(session => session.requests.length > 0);
-        sessions.sort((a, b) => (b.creationDate ?? 0) - (a.creationDate ?? 0));
-        return (
-             (sessions
-                .filter(session => !( (this._sessionModels.has(session.sessionId))))
-                .filter(session => !session.isImported)
-                .map(item => {
-                const title = ChatModel.getDefaultTitle(item.requests);
-                return {
-                    sessionId: item.sessionId,
-                    title
-                };
-            }))
-        );
+        const persistedSessions = ( (Object.values(this._persistedSessions)))
+            .filter(session => session.requests.length > 0)
+            .filter(session => !( (this._sessionModels.has(session.sessionId))));
+        const persistedSessionItems = ( (persistedSessions
+            .filter(session => !session.isImported)
+            .map(session => {
+            const title = session.customTitle ?? ChatModel.getDefaultTitle(session.requests);
+            return {
+                sessionId: session.sessionId,
+                title,
+                lastMessageDate: session.lastMessageDate,
+                isActive: false,
+            };
+        })));
+        const liveSessionItems = ( (Array.from(( (this._sessionModels.values())))
+            .filter(session => !session.isImported)
+            .map(session => {
+            const title = session.title || ( localize(2568, "New Chat"));
+            return {
+                sessionId: session.sessionId,
+                title,
+                lastMessageDate: session.lastMessageDate,
+                isActive: true,
+            };
+        })));
+        return [...liveSessionItems, ...persistedSessionItems];
     }
     removeHistoryEntry(sessionId) {
-        delete this._persistedSessions[sessionId];
-        this.saveState();
+        if (this._persistedSessions[sessionId]) {
+            this._deletedChatIds.add(sessionId);
+            delete this._persistedSessions[sessionId];
+            this.saveState();
+        }
     }
     clearAllHistoryEntries() {
+        ( (Object.values(this._persistedSessions))).forEach(session => this._deletedChatIds.add(session.sessionId));
         this._persistedSessions = {};
         this.saveState();
     }
@@ -258,13 +350,14 @@ let ChatService = class ChatService extends Disposable {
         model.removeRequest(request.id, ChatRequestRemovalReason.Resend);
         const resendOptions = {
             ...options,
-            locationData: request.locationData
+            locationData: request.locationData,
+            attachedContext: request.attachedContext,
         };
         await this._sendRequestAsync(model, model.sessionId, request.message, attempt, enableCommandDetection, defaultAgent, location, resendOptions).responseCompletePromise;
     }
     async sendRequest(sessionId, request, options) {
         this.trace('sendRequest', `sessionId: ${sessionId}, message: ${request.substring(0, 20)}${request.length > 20 ? '[...]' : ''}}`);
-        if (!request.trim()) {
+        if (!request.trim() && !options?.slashCommand && !options?.agentId) {
             this.trace('sendRequest', 'Rejected empty message');
             return;
         }
@@ -315,6 +408,7 @@ let ChatService = class ChatService extends Disposable {
         const agentPart = 'kind' in parsedRequest ? undefined : parsedRequest.parts.find((r) => r instanceof ChatRequestAgentPart);
         const agentSlashCommandPart = 'kind' in parsedRequest ? undefined : parsedRequest.parts.find((r) => r instanceof ChatRequestAgentSubcommandPart);
         const commandPart = 'kind' in parsedRequest ? undefined : parsedRequest.parts.find((r) => r instanceof ChatRequestSlashCommandPart);
+        const requests = [...model.getRequests()];
         let gotProgress = false;
         const requestType = commandPart ? 'slashCommand' : 'string';
         const responseCreated = ( (new DeferredPromise()));
@@ -342,6 +436,8 @@ let ChatService = class ChatService extends Disposable {
                 model.acceptResponseProgress(request, progress);
                 completeResponseCreated();
             };
+            let detectedAgent;
+            let detectedCommand;
             const stopWatch = ( (new StopWatch(false)));
             const listener = token.onCancellationRequested(() => {
                 this.trace('sendRequest', `Request for session ${model.sessionId} was cancelled`);
@@ -355,41 +451,64 @@ let ChatService = class ChatService extends Disposable {
                     slashCommand: agentSlashCommandPart ? agentSlashCommandPart.command.name : commandPart?.slashCommand.command,
                     chatSessionId: model.sessionId,
                     location,
-                    citations: request?.response?.codeCitations.length ?? 0
+                    citations: request?.response?.codeCitations.length ?? 0,
+                    numCodeBlocks: getCodeBlocks(request.response?.response.toString() ?? '').length,
+                    isParticipantDetected: !!detectedAgent
                 });
                 model.cancelRequest(request);
             });
             try {
                 let rawResult;
                 let agentOrCommandFollowups = undefined;
+                let chatTitlePromise;
                 if (agentPart || (defaultAgent && !commandPart)) {
-                    const agent = (agentPart?.agent ?? defaultAgent);
+                    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);
+                        const variableData = await this.chatVariablesService.resolveVariables(parsedRequest, request.attachedContext, model, progressCallback, token);
+                        model.updateRequest(request, variableData);
+                        const promptTextResult = getPromptText(request.message);
+                        const updatedVariableData = updateRanges(variableData, promptTextResult.diff);
+                        return {
+                            sessionId,
+                            requestId: request.id,
+                            agentId: agent.id,
+                            message: promptTextResult.message,
+                            command: command?.name,
+                            variables: updatedVariableData,
+                            enableCommandDetection,
+                            isParticipantDetected,
+                            attempt,
+                            location,
+                            locationData: request.locationData,
+                            acceptedConfirmationData: options?.acceptedConfirmationData,
+                            rejectedConfirmationData: options?.rejectedConfirmationData,
+                        };
+                    };
+                    if (this.configurationService.getValue('chat.experimental.detectParticipant.enabled') !== false && this.chatAgentService.hasChatParticipantDetectionProviders() && !agentPart && !commandPart && enableCommandDetection) {
+                        const defaultAgentHistory = this.getHistoryEntriesFromModel(requests, model.sessionId, location, defaultAgent.id);
+                        const chatAgentRequest = await prepareChatAgentRequest(defaultAgent, agentSlashCommandPart?.command, enableCommandDetection, undefined, false);
+                        const result = await this.chatAgentService.detectAgentOrCommand(chatAgentRequest, defaultAgentHistory, { location }, token);
+                        if (result && this.chatAgentService.getAgent(result.agent.id)?.locations?.includes(location)) {
+                            request.response?.setAgent(result.agent, result.command);
+                            detectedAgent = result.agent;
+                            detectedCommand = result.command;
+                        }
+                    }
+                    const agent = (detectedAgent ?? agentPart?.agent ?? defaultAgent);
+                    const command = detectedCommand ?? agentSlashCommandPart?.command;
                     await this.extensionService.activateByEvent(`onChatParticipant:${agent.id}`);
-                    const history = getHistoryEntriesFromModel(model, agentPart?.agent.id);
-                    const initVariableData = { variables: [] };
-                    request = model.addRequest(parsedRequest, initVariableData, attempt, agent, agentSlashCommandPart?.command, options?.locationData);
+                    const history = this.getHistoryEntriesFromModel(requests, model.sessionId, location, agent.id);
+                    const requestProps = await prepareChatAgentRequest(agent, command, enableCommandDetection, request , !!detectedAgent);
+                    const pendingRequest = this._pendingRequests.get(sessionId);
+                    if (pendingRequest && !pendingRequest.requestId) {
+                        pendingRequest.requestId = requestProps.requestId;
+                    }
                     completeResponseCreated();
-                    const variableData = await this.chatVariablesService.resolveVariables(parsedRequest, options?.attachedContext, model, progressCallback, token);
-                    model.updateRequest(request, variableData);
-                    const promptTextResult = getPromptText(request.message);
-                    const updatedVariableData = updateRanges(variableData, promptTextResult.diff);
-                    const requestProps = {
-                        sessionId,
-                        requestId: request.id,
-                        agentId: agent.id,
-                        message: promptTextResult.message,
-                        command: agentSlashCommandPart?.command.name,
-                        variables: updatedVariableData,
-                        enableCommandDetection,
-                        attempt,
-                        location,
-                        locationData: request.locationData,
-                        acceptedConfirmationData: options?.acceptedConfirmationData,
-                        rejectedConfirmationData: options?.rejectedConfirmationData,
-                    };
                     const agentResult = await this.chatAgentService.invokeAgent(agent.id, requestProps, progressCallback, history, token);
                     rawResult = agentResult;
                     agentOrCommandFollowups = this.chatAgentService.getFollowups(agent.id, requestProps, agentResult, history, followupsCancelToken);
+                    chatTitlePromise = model.getRequests().length === 1 && !model.customTitle ? this.chatAgentService.getChatTitle(defaultAgent.id, this.getHistoryEntriesFromModel(model.getRequests(), model.sessionId, location, agent.id), CancellationToken.None) : undefined;
                 }
                 else if (commandPart && this.chatSlashCommandService.hasCommand(commandPart.slashCommand.command)) {
                     request = model.addRequest(parsedRequest, { variables: [] }, attempt);
@@ -399,8 +518,8 @@ let ChatService = class ChatService extends Disposable {
                         if (!request.response) {
                             continue;
                         }
-                        history.push({ role: ChatMessageRole.User, content: { type: 'text', value: request.message.text } });
-                        history.push({ role: ChatMessageRole.Assistant, content: { type: 'text', value: ( (request.response.response.toString())) } });
+                        history.push({ role: ChatMessageRole.User, content: [{ type: 'text', value: request.message.text }] });
+                        history.push({ role: ChatMessageRole.Assistant, content: [{ type: 'text', value: ( (request.response.response.toString())) }] });
                     }
                     const message = parsedRequest.text;
                     const commandResult = await this.chatSlashCommandService.executeCommand(commandPart.slashCommand.command, message.substring(commandPart.slashCommand.command.length + 1).trimStart(), ( (new Progress(p => {
@@ -418,12 +537,13 @@ let ChatService = class ChatService extends Disposable {
                 else {
                     if (!rawResult) {
                         this.trace('sendRequest', `Provider returned no response for session ${model.sessionId}`);
-                        rawResult = { errorDetails: { message: ( localize(3048, "Provider returned null response")) } };
+                        rawResult = { errorDetails: { message: ( localize(2569, "Provider returned null response")) } };
                     }
                     const result = rawResult.errorDetails?.responseIsFiltered ? 'filtered' :
                         rawResult.errorDetails && gotProgress ? 'errorWithOutput' :
                             rawResult.errorDetails ? 'error' :
                                 'success';
+                    const commandForTelemetry = agentSlashCommandPart ? agentSlashCommandPart.command.name : commandPart?.slashCommand.command;
                     this.telemetryService.publicLog2('interactiveSessionProviderInvoked', {
                         timeToFirstProgress: rawResult.timings?.firstProgress,
                         totalTime: rawResult.timings?.totalElapsed,
@@ -431,10 +551,12 @@ let ChatService = class ChatService extends Disposable {
                         requestType,
                         agent: agentPart?.agent.id ?? '',
                         agentExtensionId: agentPart?.agent.extensionId.value ?? '',
-                        slashCommand: agentSlashCommandPart ? agentSlashCommandPart.command.name : commandPart?.slashCommand.command,
+                        slashCommand: commandForTelemetry,
                         chatSessionId: model.sessionId,
+                        isParticipantDetected: !!detectedAgent,
                         location,
-                        citations: request.response?.codeCitations.length ?? 0
+                        citations: request.response?.codeCitations.length ?? 0,
+                        numCodeBlocks: getCodeBlocks(request.response?.response.toString() ?? '').length
                     });
                     model.setResponse(request, rawResult);
                     completeResponseCreated();
@@ -443,8 +565,14 @@ let ChatService = class ChatService extends Disposable {
                     if (agentOrCommandFollowups) {
                         agentOrCommandFollowups.then(followups => {
                             model.setFollowups(request, followups);
+                            this._chatServiceTelemetry.retrievedFollowups(agentPart?.agent.id ?? '', commandForTelemetry, followups?.length ?? 0);
                         });
                     }
+                    chatTitlePromise?.then(title => {
+                        if (title) {
+                            model.setCustomTitle(title);
+                        }
+                    });
                 }
             }
             catch (err) {
@@ -459,7 +587,9 @@ let ChatService = class ChatService extends Disposable {
                     slashCommand: agentSlashCommandPart ? agentSlashCommandPart.command.name : commandPart?.slashCommand.command,
                     chatSessionId: model.sessionId,
                     location,
-                    citations: 0
+                    citations: 0,
+                    numCodeBlocks: 0,
+                    isParticipantDetected: !!detectedAgent
                 });
                 this.logService.error(`Error while handling chat request: ${toErrorMessage(err, true)}`);
                 if (request) {
@@ -474,7 +604,7 @@ let ChatService = class ChatService extends Disposable {
             }
         };
         const rawResponsePromise = sendRequestInternal();
-        this._pendingRequests.set(model.sessionId, source);
+        this._pendingRequests.set(model.sessionId, ( (new CancellableRequest(source))));
         rawResponsePromise.finally(() => {
             this._pendingRequests.deleteAndDispose(model.sessionId);
         });
@@ -483,12 +613,41 @@ let ChatService = class ChatService extends Disposable {
             responseCompletePromise: rawResponsePromise,
         };
     }
+    getHistoryEntriesFromModel(requests, sessionId, location, forAgentId) {
+        const history = [];
+        for (const request of requests) {
+            if (!request.response) {
+                continue;
+            }
+            const defaultAgentId = this.chatAgentService.getDefaultAgent(location)?.id;
+            if (forAgentId !== request.response.agent?.id && forAgentId !== defaultAgentId) {
+                continue;
+            }
+            const promptTextResult = getPromptText(request.message);
+            const historyRequest = {
+                sessionId: sessionId,
+                requestId: request.id,
+                agentId: request.response.agent?.id ?? '',
+                message: promptTextResult.message,
+                command: request.response.slashCommand?.name,
+                variables: updateRanges(request.variableData, promptTextResult.diff),
+                location: ChatAgentLocation.Panel
+            };
+            history.push({ request: historyRequest, response: request.response.response.value, result: request.response.result ?? {} });
+        }
+        return history;
+    }
     async removeRequest(sessionId, requestId) {
         const model = this._sessionModels.get(sessionId);
         if (!model) {
             throw ( (new Error(`Unknown session: ${sessionId}`)));
         }
         await model.waitForInitialization();
+        const pendingRequest = this._pendingRequests.get(sessionId);
+        if (pendingRequest?.requestId === requestId) {
+            pendingRequest.cancel();
+            this._pendingRequests.deleteAndDispose(sessionId);
+        }
         model.removeRequest(requestId);
     }
     async adoptRequest(sessionId, request) {
@@ -505,6 +664,7 @@ let ChatService = class ChatService extends Disposable {
         if (request.response && !request.response.isComplete) {
             const cts = this._pendingRequests.deleteAndLeak(oldOwner.sessionId);
             if (cts) {
+                cts.requestId = request.id;
                 this._pendingRequests.set(target.sessionId, cts);
             }
         }
@@ -546,7 +706,9 @@ let ChatService = class ChatService extends Disposable {
             throw ( (new Error(`Unknown session: ${sessionId}`)));
         }
         if (model.initialLocation === ChatAgentLocation.Panel) {
-            this._persistedSessions[sessionId] = JSON.parse(JSON.stringify(model));
+            const sessionData = JSON.parse(JSON.stringify(model));
+            sessionData.isNew = true;
+            this._persistedSessions[sessionId] = sessionData;
         }
         this._sessionModels.deleteAndDispose(sessionId);
         this._pendingRequests.get(sessionId)?.cancel();
@@ -583,7 +745,31 @@ ChatService = ( (__decorate([
     ( (__param(5, IWorkspaceContextService))),
     ( (__param(6, IChatSlashCommandService))),
     ( (__param(7, IChatVariablesService))),
-    ( (__param(8, IChatAgentService)))
+    ( (__param(8, IChatAgentService))),
+    ( (__param(9, IWorkbenchAssignmentService))),
+    ( (__param(10, IContextKeyService))),
+    ( (__param(11, IConfigurationService)))
 ], ChatService)));
+function getCodeBlocks(text) {
+    const lines = text.split('\n');
+    const codeBlockLanguages = [];
+    let codeBlockState;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (codeBlockState) {
+            if (( (new RegExp(`^\\s*${codeBlockState.delimiter}\\s*$`))).test(line)) {
+                codeBlockLanguages.push(codeBlockState.languageId);
+                codeBlockState = undefined;
+            }
+        }
+        else {
+            const match = line.match(/^(\s*)(`{3,}|~{3,})(\w*)/);
+            if (match) {
+                codeBlockState = { delimiter: match[2], languageId: match[3] };
+            }
+        }
+    }
+    return codeBlockLanguages;
+}
 
 export { ChatService };

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

@@ -13,6 +13,7 @@ let ChatServiceTelemetry = class ChatServiceTelemetry {
                 direction: action.action.direction === ChatAgentVoteDirection.Up ? 'up' : 'down',
                 agentId: action.agentId ?? '',
                 command: action.command,
+                reason: action.action.reason,
             });
         }
         else if (action.action.kind === 'copy') {
@@ -25,6 +26,8 @@ let ChatServiceTelemetry = class ChatServiceTelemetry {
         else if (action.action.kind === 'insert') {
             this.telemetryService.publicLog2('interactiveSessionInsert', {
                 newFile: !!action.action.newFile,
+                userAction: action.action.userAction,
+                codeMapper: action.action.codeMapper,
                 agentId: action.agentId ?? '',
                 command: action.command,
             });
@@ -45,6 +48,19 @@ let ChatServiceTelemetry = class ChatServiceTelemetry {
                 command: action.command,
             });
         }
+        else if (action.action.kind === 'followUp') {
+            this.telemetryService.publicLog2('chatFollowupClicked', {
+                agentId: action.agentId ?? '',
+                command: action.command,
+            });
+        }
+    }
+    retrievedFollowups(agentId, command, numFollowups) {
+        this.telemetryService.publicLog2('chatFollowupsRetrieved', {
+            agentId,
+            command,
+            numFollowups,
+        });
     }
 };
 ChatServiceTelemetry = ( __decorate([

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

@@ -121,8 +121,8 @@ LanguageModelStatsService = LanguageModelStatsService_1 = ( (__decorate([
 ], LanguageModelStatsService)));
 ( (Registry.as(Extensions.ExtensionFeaturesRegistry))).registerExtensionFeature({
     id: 'languageModels',
-    label: ( localize(3057, "Language Models")),
-    description: ( localize(3058, "Language models usage statistics of this extension.")),
+    label: ( localize(2578, "Language Models")),
+    description: ( localize(2579, "Language models usage statistics of this extension.")),
     access: {
         canToggle: false
     },