@codingame/monaco-vscode-chat-service-override 5.3.0 → 6.0.1

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

@@ -1,6 +1,8 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { Action } from 'vscode/vscode/vs/base/common/actions';
+import { coalesce } from 'vscode/vscode/vs/base/common/arrays';
+import { DeferredPromise } from 'vscode/vscode/vs/base/common/async';
 import { CancellationToken, CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import { toErrorMessage } from 'vscode/vscode/vs/base/common/errorMessage';
 import { ErrorNoTelemetry } from 'vscode/vscode/vs/base/common/errors';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
@@ -11,25 +13,23 @@ import { StopWatch } from 'vscode/vscode/vs/base/common/stopwatch';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
-import 'vscode/vscode/vs/platform/notification/common/notification';
-import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
 import { Progress } from 'vscode/vscode/vs/platform/progress/common/progress';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
 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, getHistoryEntriesFromModel, updateRanges } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatModel';
-import { ChatRequestAgentPart, ChatRequestAgentSubcommandPart, ChatRequestSlashCommandPart, getPromptText } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+import { ChatModel, ChatWelcomeMessageModel, ChatRequestRemovalReason, getHistoryEntriesFromModel, 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 { InteractiveSessionVoteDirection, ChatCopyKind } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService';
+import { ChatAgentVoteDirection, ChatCopyKind } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService';
 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 { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
-import Severity$1 from 'vscode/vscode/vs/base/common/severity';
 
 const _moduleId = "vs/workbench/contrib/chat/common/chatServiceImpl";
 const serializedChatKey = 'interactive.sessions';
@@ -40,7 +40,7 @@ let ChatService = class ChatService extends Disposable {
     get transferredSessionData() {
         return this._transferredSessionData;
     }
-    constructor(storageService, logService, extensionService, instantiationService, telemetryService, workspaceContextService, chatSlashCommandService, chatVariablesService, chatAgentService, notificationService, commandService) {
+    constructor(storageService, logService, extensionService, instantiationService, telemetryService, workspaceContextService, chatSlashCommandService, chatVariablesService, chatAgentService) {
         super();
         this.storageService = storageService;
         this.logService = logService;
@@ -51,8 +51,6 @@ let ChatService = class ChatService extends Disposable {
         this.chatSlashCommandService = chatSlashCommandService;
         this.chatVariablesService = chatVariablesService;
         this.chatAgentService = chatAgentService;
-        this.notificationService = notificationService;
-        this.commandService = commandService;
         this._sessionModels = this._register(( (new DisposableMap())));
         this._pendingRequests = this._register(( (new DisposableMap())));
         this._onDidPerformUserAction = this._register(( (new Emitter())));
@@ -60,7 +58,7 @@ let ChatService = class ChatService extends Disposable {
         this._onDidDisposeSession = this._register(( (new Emitter())));
         this.onDidDisposeSession = this._onDidDisposeSession.event;
         this._sessionFollowupCancelTokens = this._register(( (new DisposableMap())));
-        const sessionData = storageService.get(serializedChatKey, 1 , '');
+        const sessionData = storageService.get(serializedChatKey, StorageScope.WORKSPACE, '');
         if (sessionData) {
             this._persistedSessions = this.deserializeChats(sessionData);
             const countsForLog = ( (Object.keys(this._persistedSessions))).length;
@@ -99,29 +97,33 @@ let ChatService = class ChatService extends Disposable {
         if (allSessions.length) {
             this.trace('onWillSaveState', `Persisting ${serialized.length} chars`);
         }
-        this.storageService.store(serializedChatKey, serialized, 1 , 1 );
+        this.storageService.store(serializedChatKey, serialized, StorageScope.WORKSPACE, StorageTarget.MACHINE);
     }
     notifyUserAction(action) {
         if (action.action.kind === 'vote') {
             this.telemetryService.publicLog2('interactiveSessionVote', {
-                direction: action.action.direction === InteractiveSessionVoteDirection.Up ? 'up' : 'down'
+                direction: action.action.direction === ChatAgentVoteDirection.Up ? 'up' : 'down',
+                agentId: action.agentId ?? ''
             });
         }
         else if (action.action.kind === 'copy') {
             this.telemetryService.publicLog2('interactiveSessionCopy', {
-                copyKind: action.action.copyKind === ChatCopyKind.Action ? 'action' : 'toolbar'
+                copyKind: action.action.copyKind === ChatCopyKind.Action ? 'action' : 'toolbar',
+                agentId: action.agentId ?? ''
             });
         }
         else if (action.action.kind === 'insert') {
             this.telemetryService.publicLog2('interactiveSessionInsert', {
-                newFile: !!action.action.newFile
+                newFile: !!action.action.newFile,
+                agentId: action.agentId ?? ''
             });
         }
         else if (action.action.kind === 'command') {
             const command = CommandsRegistry.getCommand(action.action.commandButton.command.id);
             const commandId = command ? action.action.commandButton.command.id : 'INVALID';
             this.telemetryService.publicLog2('interactiveSessionCommand', {
-                commandId
+                commandId,
+                agentId: action.agentId ?? ''
             });
         }
         else if (action.action.kind === 'runInTerminal') {
@@ -175,7 +177,7 @@ let ChatService = class ChatService extends Disposable {
         }
     }
     getTransferredSessionData() {
-        const data = this.storageService.getObject(globalChatKey, 0 , []);
+        const data = this.storageService.getObject(globalChatKey, StorageScope.PROFILE, []);
         const workspaceUri = this.workspaceContextService.getWorkspace().folders[0]?.uri;
         if (!workspaceUri) {
             return;
@@ -184,7 +186,7 @@ let ChatService = class ChatService extends Disposable {
         const currentTime = Date.now();
         const transferred = data.find(item => ( (URI.revive(item.toWorkspace).toString())) === thisWorkspace && (currentTime - item.timestampInMilliseconds < SESSION_TRANSFER_EXPIRATION_IN_MILLISECONDS));
         const filtered = data.filter(item => ( (URI.revive(item.toWorkspace).toString())) !== thisWorkspace && (currentTime - item.timestampInMilliseconds < SESSION_TRANSFER_EXPIRATION_IN_MILLISECONDS));
-        this.storageService.store(globalChatKey, JSON.stringify(filtered), 0 , 1 );
+        this.storageService.store(globalChatKey, JSON.stringify(filtered), StorageScope.PROFILE, StorageTarget.MACHINE);
         return transferred;
     }
     getHistory() {
@@ -234,21 +236,6 @@ let ChatService = class ChatService extends Disposable {
             await this.extensionService.activateByEvent(`onChatParticipant:${defaultAgentData.id}`);
             const defaultAgent = this.chatAgentService.getActivatedAgents().find(agent => agent.id === defaultAgentData.id);
             if (!defaultAgent) {
-                this.notificationService.notify({
-                    severity: Severity$1.Error,
-                    message: ( localizeWithPath(
-                        _moduleId,
-                        0,
-                        "Chat failed to load. Please ensure that the GitHub Copilot Chat extension is up to date."
-                    )),
-                    actions: {
-                        primary: [
-                            ( (new Action('showExtension', ( localizeWithPath(_moduleId, 1, "Show Extension")), undefined, true, () => {
-                            return this.commandService.executeCommand('workbench.extensions.action.showExtensionsWithIds', ['GitHub.copilot-chat']);
-                        })))
-                        ]
-                    }
-                });
                 throw ( (new ErrorNoTelemetry('No default agent registered')));
             }
             const welcomeMessage = model.welcomeMessage ? undefined : (await defaultAgent.provideWelcomeMessage?.(model.initialLocation, token)) ?? undefined;
@@ -273,7 +260,7 @@ let ChatService = class ChatService extends Disposable {
         if (model) {
             return model;
         }
-        const sessionData = this._persistedSessions[sessionId];
+        const sessionData = revive(this._persistedSessions[sessionId]);
         if (!sessionData) {
             return undefined;
         }
@@ -291,17 +278,17 @@ let ChatService = class ChatService extends Disposable {
             throw ( (new Error(`Unknown session: ${request.session.sessionId}`)));
         }
         await model.waitForInitialization();
-        if (( (this._pendingRequests.has(request.session.sessionId)))) {
-            this.trace('sendRequest', `Session ${request.session.sessionId} already has a pending request`);
-            return;
+        const cts = this._pendingRequests.get(request.session.sessionId);
+        if (cts) {
+            this.trace('resendRequest', `Session ${request.session.sessionId} already has a pending request, cancelling...`);
+            cts.cancel();
         }
         const location = options?.location ?? model.initialLocation;
         const attempt = options?.attempt ?? 0;
         const enableCommandDetection = !options?.noCommandDetection;
-        const implicitVariablesEnabled = options?.implicitVariablesEnabled ?? false;
         const defaultAgent = this.chatAgentService.getDefaultAgent(location);
-        this.removeRequest(model.sessionId, request.id);
-        await this._sendRequestAsync(model, model.sessionId, request.message, attempt, enableCommandDetection, implicitVariablesEnabled, defaultAgent, location);
+        model.removeRequest(request.id, ChatRequestRemovalReason.Resend);
+        await this._sendRequestAsync(model, model.sessionId, request.message, attempt, enableCommandDetection, defaultAgent, location, options).responseCompletePromise;
     }
     async sendRequest(sessionId, request, options) {
         this.trace('sendRequest', `sessionId: ${sessionId}, message: ${request.substring(0, 20)}${request.length > 20 ? '[...]' : ''}}`);
@@ -320,24 +307,37 @@ let ChatService = class ChatService extends Disposable {
         }
         const location = options?.location ?? model.initialLocation;
         const attempt = options?.attempt ?? 0;
-        const implicitVariablesEnabled = options?.implicitVariablesEnabled ?? false;
         const defaultAgent = this.chatAgentService.getDefaultAgent(location);
-        const parsedRequest = this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(sessionId, request, location, options?.parserContext);
+        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);
         return {
-            responseCompletePromise: this._sendRequestAsync(model, sessionId, parsedRequest, attempt, !options?.noCommandDetection, implicitVariablesEnabled, defaultAgent, location),
+            ...this._sendRequestAsync(model, sessionId, parsedRequest, attempt, !options?.noCommandDetection, defaultAgent, location, options),
             agent,
             slashCommand: agentSlashCommandPart?.command,
         };
     }
+    parseChatRequest(sessionId, request, location, options) {
+        let parserContext = options?.parserContext;
+        if (options?.agentId) {
+            const agent = this.chatAgentService.getAgent(options.agentId);
+            if (!agent) {
+                throw ( (new Error(`Unknown agent: ${options.agentId}`)));
+            }
+            parserContext = { selectedAgent: agent };
+            const commandPart = options.slashCommand ? ` ${chatSubcommandLeader}${options.slashCommand}` : '';
+            request = `${chatAgentLeader}${agent.name}${commandPart} ${request}`;
+        }
+        const parsedRequest = this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(sessionId, request, location, parserContext);
+        return parsedRequest;
+    }
     refreshFollowupsCancellationToken(sessionId) {
         this._sessionFollowupCancelTokens.get(sessionId)?.cancel();
         const newTokenSource = ( (new CancellationTokenSource()));
         this._sessionFollowupCancelTokens.set(sessionId, newTokenSource);
         return newTokenSource.token;
     }
-    async _sendRequestAsync(model, sessionId, parsedRequest, attempt, enableCommandDetection, implicitVariablesEnabled, defaultAgent, location) {
+    _sendRequestAsync(model, sessionId, parsedRequest, attempt, enableCommandDetection, defaultAgent, location, options) {
         const followupsCancelToken = this.refreshFollowupsCancellationToken(sessionId);
         let request;
         const agentPart = 'kind' in parsedRequest ? undefined : parsedRequest.parts.find((r) => r instanceof ChatRequestAgentPart);
@@ -345,6 +345,14 @@ let ChatService = class ChatService extends Disposable {
         const commandPart = 'kind' in parsedRequest ? undefined : parsedRequest.parts.find((r) => r instanceof ChatRequestSlashCommandPart);
         let gotProgress = false;
         const requestType = commandPart ? 'slashCommand' : 'string';
+        const responseCreated = ( (new DeferredPromise()));
+        let responseCreatedComplete = false;
+        function completeResponseCreated() {
+            if (!responseCreatedComplete && request?.response) {
+                responseCreated.complete(request.response);
+                responseCreatedComplete = true;
+            }
+        }
         const source = ( (new CancellationTokenSource()));
         const token = source.token;
         const sendRequestInternal = async () => {
@@ -360,6 +368,7 @@ let ChatService = class ChatService extends Disposable {
                     this.trace('sendRequest', `Provider returned progress: ${JSON.stringify(progress)}`);
                 }
                 model.acceptResponseProgress(request, progress);
+                completeResponseCreated();
             };
             const stopWatch = ( (new StopWatch(false)));
             const listener = token.onCancellationRequested(() => {
@@ -371,7 +380,8 @@ let ChatService = class ChatService extends Disposable {
                     requestType,
                     agent: agentPart?.agent.id ?? '',
                     slashCommand: agentSlashCommandPart ? agentSlashCommandPart.command.name : commandPart?.slashCommand.command,
-                    chatSessionId: model.sessionId
+                    chatSessionId: model.sessionId,
+                    location,
                 });
                 model.cancelRequest(request);
             });
@@ -384,17 +394,22 @@ let ChatService = class ChatService extends Disposable {
                     const history = getHistoryEntriesFromModel(model, agentPart?.agent.id);
                     const initVariableData = { variables: [] };
                     request = model.addRequest(parsedRequest, initVariableData, attempt, agent, agentSlashCommandPart?.command);
-                    const variableData = await this.chatVariablesService.resolveVariables(parsedRequest, model, progressCallback, token);
+                    completeResponseCreated();
+                    const variableData = await this.chatVariablesService.resolveVariables(parsedRequest, options?.attachedContext, model, progressCallback, token);
                     request.variableData = variableData;
                     const promptTextResult = getPromptText(request.message);
                     const updatedVariableData = updateRanges(variableData, promptTextResult.diff);
+                    const implicitVariablesEnabled = (location === ChatAgentLocation.Editor || location === ChatAgentLocation.Notebook);
                     if (implicitVariablesEnabled) {
                         const implicitVariables = agent.defaultImplicitVariables;
                         if (implicitVariables) {
-                            const resolvedImplicitVariables = await Promise.all(( (implicitVariables.map(
-                                async (v) => ({ name: v, values: await this.chatVariablesService.resolveVariable(v, parsedRequest.text, model, progressCallback, token) })
-                            ))));
-                            updatedVariableData.variables.push(...resolvedImplicitVariables);
+                            const resolvedImplicitVariables = await Promise.all(( (implicitVariables.map(async (v) => {
+                                const id = this.chatVariablesService.getVariable(v)?.id ?? '';
+                                const value = await this.chatVariablesService.resolveVariable(v, parsedRequest.text, model, progressCallback, token);
+                                return value ? { id, name: v, value } :
+                                    undefined;
+                            }))));
+                            updatedVariableData.variables.push(...coalesce(resolvedImplicitVariables));
                         }
                     }
                     const requestProps = {
@@ -406,7 +421,9 @@ let ChatService = class ChatService extends Disposable {
                         variables: updatedVariableData,
                         enableCommandDetection,
                         attempt,
-                        location
+                        location,
+                        acceptedConfirmationData: options?.acceptedConfirmationData,
+                        rejectedConfirmationData: options?.rejectedConfirmationData,
                     };
                     const agentResult = await this.chatAgentService.invokeAgent(agent.id, requestProps, progressCallback, history, token);
                     rawResult = agentResult;
@@ -414,13 +431,14 @@ let ChatService = class ChatService extends Disposable {
                 }
                 else if (commandPart && this.chatSlashCommandService.hasCommand(commandPart.slashCommand.command)) {
                     request = model.addRequest(parsedRequest, { variables: [] }, attempt);
+                    completeResponseCreated();
                     const history = [];
                     for (const request of model.getRequests()) {
                         if (!request.response) {
                             continue;
                         }
-                        history.push({ role: 1 , content: request.message.text });
-                        history.push({ role: 2 , content: request.response.response.asString() });
+                        history.push({ role: ChatMessageRole.User, content: request.message.text });
+                        history.push({ role: ChatMessageRole.Assistant, content: request.response.response.asString() });
                     }
                     const message = parsedRequest.text;
                     const commandResult = await this.chatSlashCommandService.executeCommand(commandPart.slashCommand.command, message.substring(commandPart.slashCommand.command.length + 1).trimStart(), ( (new Progress(p => {
@@ -438,7 +456,7 @@ let ChatService = class ChatService extends Disposable {
                 else {
                     if (!rawResult) {
                         this.trace('sendRequest', `Provider returned no response for session ${model.sessionId}`);
-                        rawResult = { errorDetails: { message: ( localizeWithPath(_moduleId, 2, "Provider returned null response")) } };
+                        rawResult = { errorDetails: { message: ( localizeWithPath(_moduleId, 0, "Provider returned null response")) } };
                     }
                     const result = rawResult.errorDetails?.responseIsFiltered ? 'filtered' :
                         rawResult.errorDetails && gotProgress ? 'errorWithOutput' :
@@ -451,9 +469,11 @@ let ChatService = class ChatService extends Disposable {
                         requestType,
                         agent: agentPart?.agent.id ?? '',
                         slashCommand: agentSlashCommandPart ? agentSlashCommandPart.command.name : commandPart?.slashCommand.command,
-                        chatSessionId: model.sessionId
+                        chatSessionId: model.sessionId,
+                        location
                     });
                     model.setResponse(request, rawResult);
+                    completeResponseCreated();
                     this.trace('sendRequest', `Provider returned response for session ${model.sessionId}`);
                     model.completeResponse(request);
                     if (agentOrCommandFollowups) {
@@ -463,6 +483,26 @@ let ChatService = class ChatService extends Disposable {
                     }
                 }
             }
+            catch (err) {
+                const result = 'error';
+                this.telemetryService.publicLog2('interactiveSessionProviderInvoked', {
+                    timeToFirstProgress: undefined,
+                    totalTime: undefined,
+                    result,
+                    requestType,
+                    agent: agentPart?.agent.id ?? '',
+                    slashCommand: agentSlashCommandPart ? agentSlashCommandPart.command.name : commandPart?.slashCommand.command,
+                    chatSessionId: model.sessionId,
+                    location
+                });
+                const rawResult = { errorDetails: { message: err.message } };
+                if (request) {
+                    model.setResponse(request, rawResult);
+                }
+                completeResponseCreated();
+                this.logService.error(`Error while handling chat request: ${toErrorMessage(err)}`);
+                model.completeResponse(request);
+            }
             finally {
                 listener.dispose();
             }
@@ -472,7 +512,10 @@ let ChatService = class ChatService extends Disposable {
         rawResponsePromise.finally(() => {
             this._pendingRequests.deleteAndDispose(model.sessionId);
         });
-        return rawResponsePromise;
+        return {
+            responseCreatedPromise: responseCreated.p,
+            responseCompletePromise: rawResponsePromise,
+        };
     }
     async removeRequest(sessionId, requestId) {
         const model = this._sessionModels.get(sessionId);
@@ -482,6 +525,24 @@ let ChatService = class ChatService extends Disposable {
         await model.waitForInitialization();
         model.removeRequest(requestId);
     }
+    async adoptRequest(sessionId, request) {
+        if (!(request instanceof ChatRequestModel)) {
+            throw ( (new TypeError('Can only adopt requests of type ChatRequestModel')));
+        }
+        const target = this._sessionModels.get(sessionId);
+        if (!target) {
+            throw ( (new Error(`Unknown session: ${sessionId}`)));
+        }
+        await target.waitForInitialization();
+        const oldOwner = request.session;
+        target.adoptRequest(request);
+        if (request.response && !request.response.isComplete) {
+            const cts = this._pendingRequests.deleteAndLeak(oldOwner.sessionId);
+            if (cts) {
+                this._pendingRequests.set(target.sessionId, cts);
+            }
+        }
+    }
     async addCompleteRequest(sessionId, message, variableData, attempt, response) {
         this.trace('addCompleteRequest', `message: ${message}`);
         const model = this._sessionModels.get(sessionId);
@@ -519,7 +580,7 @@ let ChatService = class ChatService extends Disposable {
             throw ( (new Error(`Unknown session: ${sessionId}`)));
         }
         if (model.initialLocation === ChatAgentLocation.Panel) {
-            this._persistedSessions[sessionId] = model.toJSON();
+            this._persistedSessions[sessionId] = JSON.parse(JSON.stringify(model));
         }
         this._sessionModels.deleteAndDispose(sessionId);
         this._pendingRequests.get(sessionId)?.cancel();
@@ -536,14 +597,14 @@ let ChatService = class ChatService extends Disposable {
                 `Failed to transfer session. Unknown session ID: ${transferredSessionData.sessionId}`
             )));
         }
-        const existingRaw = this.storageService.getObject(globalChatKey, 0 , []);
+        const existingRaw = this.storageService.getObject(globalChatKey, StorageScope.PROFILE, []);
         existingRaw.push({
             chat: model.toJSON(),
             timestampInMilliseconds: Date.now(),
             toWorkspace: toWorkspace,
             inputValue: transferredSessionData.inputValue,
         });
-        this.storageService.store(globalChatKey, JSON.stringify(existingRaw), 0 , 1 );
+        this.storageService.store(globalChatKey, JSON.stringify(existingRaw), StorageScope.PROFILE, StorageTarget.MACHINE);
         this.trace('transferChatSession', `Transferred session ${model.sessionId} to workspace ${( (toWorkspace.toString()))}`);
     }
 };
@@ -556,9 +617,7 @@ ChatService = ( (__decorate([
     ( (__param(5, IWorkspaceContextService))),
     ( (__param(6, IChatSlashCommandService))),
     ( (__param(7, IChatVariablesService))),
-    ( (__param(8, IChatAgentService))),
-    ( (__param(9, INotificationService))),
-    ( (__param(10, ICommandService)))
+    ( (__param(8, IChatAgentService)))
 ], ChatService)));
 
 export { ChatService };

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

@@ -1,7 +1,9 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
+import { ChatAgentLocation } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
 import { CHAT_PROVIDER_ID } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParticipantContribTypes';
 
 let ChatWidgetHistoryService = class ChatWidgetHistoryService {
@@ -9,20 +11,25 @@ let ChatWidgetHistoryService = class ChatWidgetHistoryService {
         this._onDidClearHistory = ( new Emitter());
         this.onDidClearHistory = this._onDidClearHistory.event;
         this.memento = ( new Memento('interactive-session', storageService));
-        const loadedState = this.memento.getMemento(1 , 1 );
+        const loadedState = this.memento.getMemento(StorageScope.WORKSPACE, StorageTarget.MACHINE);
         for (const provider in loadedState.history) {
             loadedState.history[provider] = ( loadedState.history[provider].map(entry => typeof entry === 'string' ? { text: entry } : entry));
         }
         this.viewState = loadedState;
     }
-    getHistory() {
-        return this.viewState.history?.[CHAT_PROVIDER_ID] ?? [];
+    getHistory(location) {
+        const key = this.getKey(location);
+        return this.viewState.history?.[key] ?? [];
     }
-    saveHistory(history) {
+    getKey(location) {
+        return location === ChatAgentLocation.Panel ? CHAT_PROVIDER_ID : location;
+    }
+    saveHistory(location, history) {
         if (!this.viewState.history) {
             this.viewState.history = {};
         }
-        this.viewState.history[CHAT_PROVIDER_ID] = history;
+        const key = this.getKey(location);
+        this.viewState.history[key] = history;
         this.memento.saveMemento();
     }
     clearHistory() {

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

@@ -1,6 +1,7 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { ExtensionIdentifier } from 'vscode/vscode/vs/platform/extensions/common/extensions';
 import { Extensions } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionFeatures';
@@ -21,7 +22,7 @@ let LanguageModelStatsService = class LanguageModelStatsService extends Disposab
         this._onDidChangeStats = this._register(( (new Emitter())));
         this.onDidChangeLanguageMoelStats = this._onDidChangeStats.event;
         this.sessionStats = ( (new Map()));
-        this._register(_storageService.onDidChangeValue(-1 , undefined, this._store)(e => {
+        this._register(_storageService.onDidChangeValue(StorageScope.APPLICATION, undefined, this._store)(e => {
             const model = this.getModel(e.key);
             if (model) {
                 this._onDidChangeStats.fire(model);
@@ -48,12 +49,12 @@ let LanguageModelStatsService = class LanguageModelStatsService extends Disposab
         const extensions = this.getAccessExtensions(model);
         if (!extensions.includes(extensionId)) {
             extensions.push(extensionId);
-            this._storageService.store(this.getAccessKey(model), JSON.stringify(extensions), -1 , 0 );
+            this._storageService.store(this.getAccessKey(model), JSON.stringify(extensions), StorageScope.APPLICATION, StorageTarget.USER);
         }
     }
     getAccessExtensions(model) {
         const key = this.getAccessKey(model);
-        const data = this._storageService.get(key, -1 );
+        const data = this._storageService.get(key, StorageScope.APPLICATION);
         try {
             if (data) {
                 const parsed = JSON.parse(data);
@@ -69,7 +70,7 @@ let LanguageModelStatsService = class LanguageModelStatsService extends Disposab
     async write(model, extensionId, participant, tokenCount) {
         const modelStats = await this.read(model);
         this.add(modelStats, extensionId, participant, tokenCount);
-        this._storageService.store(this.getKey(model), JSON.stringify(modelStats), -1 , 0 );
+        this._storageService.store(this.getKey(model), JSON.stringify(modelStats), StorageScope.APPLICATION, StorageTarget.USER);
     }
     add(modelStats, extensionId, participant, tokenCount) {
         let extensionStats = modelStats.extensions.find(e => ExtensionIdentifier.equals(e.extensionId, extensionId));
@@ -93,7 +94,7 @@ let LanguageModelStatsService = class LanguageModelStatsService extends Disposab
     }
     async read(model) {
         try {
-            const value = this._storageService.get(this.getKey(model), -1 );
+            const value = this._storageService.get(this.getKey(model), StorageScope.APPLICATION);
             if (value) {
                 return JSON.parse(value);
             }