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

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

@@ -44,10 +44,11 @@ import { LocalChatSessionUri } from '@codingame/monaco-vscode-api/vscode/vs/work
 import { ChatConfiguration, ChatAgentLocation, ChatModeKind } 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/tools/languageModelToolsService.service';
+import { ChatSessionOperationLog } from '../model/chatSessionOperationLog.js';
 import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 
-const serializedChatKey = 'interactive.sessions';
+const serializedChatKey = "interactive.sessions";
 let CancellableRequest = class CancellableRequest {
     constructor(cancellationTokenSource, requestId, toolsService) {
         this.cancellationTokenSource = cancellationTokenSource;
@@ -64,13 +65,14 @@ let CancellableRequest = class CancellableRequest {
         this.cancellationTokenSource.cancel();
     }
 };
-CancellableRequest = ( __decorate([
-    ( __param(2, ILanguageModelToolsService))
-], CancellableRequest));
+CancellableRequest = ( __decorate([( __param(2, ILanguageModelToolsService))], CancellableRequest));
 let ChatService = class ChatService extends Disposable {
     get transferredSessionResource() {
         return this._transferredSessionResource;
     }
+    get onDidCreateModel() {
+        return this._sessionModels.onDidCreateModel;
+    }
     setSaveModelsEnabled(enabled) {
         this._saveModelsEnabled = enabled;
     }
@@ -84,7 +86,19 @@ let ChatService = class ChatService extends Disposable {
         const workspace = this.workspaceContextService.getWorkspace();
         return !workspace.configuration && workspace.folders.length === 0;
     }
-    constructor(storageService, logService, extensionService, instantiationService, workspaceContextService, chatSlashCommandService, chatAgentService, configurationService, chatTransferService, chatSessionService, mcpService) {
+    constructor(
+        storageService,
+        logService,
+        extensionService,
+        instantiationService,
+        workspaceContextService,
+        chatSlashCommandService,
+        chatAgentService,
+        configurationService,
+        chatTransferService,
+        chatSessionService,
+        mcpService
+    ) {
         super();
         this.storageService = storageService;
         this.logService = logService;
@@ -103,35 +117,38 @@ let ChatService = class ChatService extends Disposable {
         this.onDidSubmitRequest = this._onDidSubmitRequest.event;
         this._onDidPerformUserAction = this._register(( new Emitter()));
         this.onDidPerformUserAction = this._onDidPerformUserAction.event;
+        this._onDidReceiveQuestionCarouselAnswer = this._register(( new Emitter()));
+        this.onDidReceiveQuestionCarouselAnswer = this._onDidReceiveQuestionCarouselAnswer.event;
         this._onDidDisposeSession = this._register(( new Emitter()));
         this.onDidDisposeSession = this._onDidDisposeSession.event;
         this._sessionFollowupCancelTokens = this._register(( new DisposableResourceMap()));
         this._sessionModels = this._register(instantiationService.createInstance(ChatModelStore, {
-            createModel: (props) => this._startSession(props),
-            willDisposeModel: async (model) => {
+            createModel: props => this._startSession(props),
+            willDisposeModel: async model => {
                 const localSessionId = LocalChatSessionUri.parseLocalSessionId(model.sessionResource);
                 if (localSessionId && this.shouldStoreSession(model)) {
                     if (model.getRequests().length === 0 && !model.customTitle) {
                         await this._chatSessionStore.deleteSession(localSessionId);
-                    }
-                    else if (this._saveModelsEnabled) {
+                    } else if (this._saveModelsEnabled) {
                         await this._chatSessionStore.storeSessions([model]);
                     }
-                }
-                else if (!localSessionId && model.getRequests().length > 0) {
+                } else if (!localSessionId && model.getRequests().length > 0) {
                     await this._chatSessionStore.storeSessionsMetadataOnly([model]);
                 }
             }
         }));
         this._register(this._sessionModels.onDidDisposeModel(model => {
-            this._onDidDisposeSession.fire({ sessionResource: [model.sessionResource], reason: 'cleared' });
+            this._onDidDisposeSession.fire({
+                sessionResource: [model.sessionResource],
+                reason: "cleared"
+            });
         }));
         this._chatServiceTelemetry = this.instantiationService.createInstance(ChatServiceTelemetry);
         this._chatSessionStore = this._register(this.instantiationService.createInstance(ChatSessionStore));
         this._chatSessionStore.migrateDataIfNeeded(() => this.migrateData());
         const transferredData = this._chatSessionStore.getTransferredSessionData();
         if (transferredData) {
-            this.trace('constructor', `Transferred session ${transferredData}`);
+            this.trace("constructor", `Transferred session ${transferredData}`);
             this._transferredSessionResource = transferredData;
         }
         this.reviveSessionsWithEdits();
@@ -149,12 +166,16 @@ let ChatService = class ChatService extends Disposable {
         return this.chatAgentService.getContributedDefaultAgent(location) !== undefined;
     }
     migrateData() {
-        const sessionData = this.storageService.get(serializedChatKey, this.isEmptyWindow ? StorageScope.APPLICATION : StorageScope.WORKSPACE, '');
+        const sessionData = this.storageService.get(
+            serializedChatKey,
+            this.isEmptyWindow ? StorageScope.APPLICATION : StorageScope.WORKSPACE,
+            ""
+        );
         if (sessionData) {
             const persistedSessions = this.deserializeChats(sessionData);
             const countsForLog = ( Object.keys(persistedSessions)).length;
             if (countsForLog > 0) {
-                this.info('migrateData', `Restored ${countsForLog} persisted sessions`);
+                this.info("migrateData", `Restored ${countsForLog} persisted sessions`);
             }
             return persistedSessions;
         }
@@ -164,11 +185,11 @@ let ChatService = class ChatService extends Disposable {
         if (!this._saveModelsEnabled) {
             return;
         }
-        const liveLocalChats = Array.from(( this._sessionModels.values()))
-            .filter(session => this.shouldStoreSession(session));
+        const liveLocalChats = Array.from(( this._sessionModels.values())).filter(session => this.shouldStoreSession(session));
         this._chatSessionStore.storeSessions(liveLocalChats);
-        const liveNonLocalChats = Array.from(( this._sessionModels.values()))
-            .filter(session => !LocalChatSessionUri.parseLocalSessionId(session.sessionResource));
+        const liveNonLocalChats = Array.from(( this._sessionModels.values())).filter(
+            session => !LocalChatSessionUri.parseLocalSessionId(session.sessionResource)
+        );
         this._chatSessionStore.storeSessionsMetadataOnly(liveNonLocalChats);
     }
     shouldStoreSession(session) {
@@ -180,13 +201,20 @@ let ChatService = class ChatService extends Disposable {
     notifyUserAction(action) {
         this._chatServiceTelemetry.notifyUserAction(action);
         this._onDidPerformUserAction.fire(action);
-        if (action.action.kind === 'chatEditingSessionAction') {
+        if (action.action.kind === "chatEditingSessionAction") {
             const model = this._sessionModels.get(action.sessionResource);
             if (model) {
                 model.notifyEditingAction(action.action);
             }
         }
     }
+    notifyQuestionCarouselAnswer(requestId, resolveId, answers) {
+        this._onDidReceiveQuestionCarouselAnswer.fire({
+            requestId,
+            resolveId,
+            answers
+        });
+    }
     async setChatSessionTitle(sessionResource, title) {
         const model = this._sessionModels.get(sessionResource);
         if (model) {
@@ -201,16 +229,14 @@ let ChatService = class ChatService extends Disposable {
     trace(method, message) {
         if (message) {
             this.logService.trace(`ChatService#${method}: ${message}`);
-        }
-        else {
+        } else {
             this.logService.trace(`ChatService#${method}`);
         }
     }
     info(method, message) {
         if (message) {
             this.logService.info(`ChatService#${method}: ${message}`);
-        }
-        else {
+        } else {
             this.logService.info(`ChatService#${method}`);
         }
     }
@@ -221,19 +247,18 @@ let ChatService = class ChatService extends Disposable {
         try {
             const arrayOfSessions = revive(JSON.parse(sessionData));
             if (!Array.isArray(arrayOfSessions)) {
-                throw ( new Error('Expected array'));
+                throw ( new Error("Expected array"));
             }
             const sessions = arrayOfSessions.reduce((acc, session) => {
                 for (const request of session.requests) {
                     if (Array.isArray(request.response)) {
-                        request.response = ( request.response.map((response) => {
-                            if (typeof response === 'string') {
+                        request.response = ( request.response.map(response => {
+                            if (typeof response === "string") {
                                 return ( new MarkdownString(response));
                             }
                             return response;
                         }));
-                    }
-                    else if (typeof request.response === 'string') {
+                    } else if (typeof request.response === "string") {
                         request.response = [( new MarkdownString(request.response))];
                     }
                 }
@@ -241,15 +266,17 @@ let ChatService = class ChatService extends Disposable {
                 return acc;
             }, {});
             return sessions;
-        }
-        catch (err) {
-            this.error('deserializeChats', `Malformed session data: ${err}. [${sessionData.substring(0, 20)}${sessionData.length > 20 ? '...' : ''}]`);
+        } catch (err) {
+            this.error(
+                "deserializeChats",
+                `Malformed session data: ${err}. [${sessionData.substring(0, 20)}${sessionData.length > 20 ? "..." : ""}]`
+            );
             return {};
         }
     }
     async reviveSessionsWithEdits() {
         const idx = await this._chatSessionStore.getIndex();
-        await Promise.all(( ( Object.values(idx)).map(async (session) => {
+        await Promise.all(( ( Object.values(idx)).map(async session => {
             if (!session.hasPendingEdits) {
                 return;
             }
@@ -267,10 +294,8 @@ let ChatService = class ChatService extends Disposable {
         return [...liveSessionItems, ...historySessionItems];
     }
     async getLiveSessionItems() {
-        return await Promise.all(( Array.from(( this._sessionModels.values()))
-            .filter(session => this.shouldBeInHistory(session))
-            .map(async (session) => {
-            const title = session.title || ( localize(5944, "New Chat"));
+        return await Promise.all(( Array.from(( this._sessionModels.values())).filter(session => this.shouldBeInHistory(session)).map(async session => {
+            const title = session.title || ( localize(6219, "New Chat"));
             return {
                 sessionResource: session.sessionResource,
                 title,
@@ -278,23 +303,25 @@ let ChatService = class ChatService extends Disposable {
                 timing: session.timing,
                 isActive: true,
                 stats: await awaitStatsForSession(session),
-                lastResponseState: session.lastRequest?.response?.state ?? ResponseModelState.Pending,
+                lastResponseState: session.lastRequest?.response?.state ?? ResponseModelState.Pending
             };
         })));
     }
     async getHistorySessionItems() {
         const index = await this._chatSessionStore.getIndex();
-        return ( ( Object.values(index))
-            .filter(entry => !entry.isExternal)
-            .filter(entry => !( this._sessionModels.has(LocalChatSessionUri.forSession(entry.sessionId))) && entry.initialLocation === ChatAgentLocation.Chat && !entry.isEmpty)
-            .map((entry) => {
+        return ( ( Object.values(index)).filter(entry => !entry.isExternal).filter(entry => !( this._sessionModels.has(LocalChatSessionUri.forSession(entry.sessionId))) && entry.initialLocation === ChatAgentLocation.Chat && !entry.isEmpty).map(entry => {
             const sessionResource = LocalChatSessionUri.forSession(entry.sessionId);
+            const lastResponseState = entry.lastResponseState ?? ResponseModelState.Complete;
             return ({
                 ...entry,
                 sessionResource,
-                timing: entry.timing ?? { startTime: entry.lastMessageDate },
+                timing: entry.timing ?? {
+                    created: entry.lastMessageDate,
+                    lastRequestStarted: undefined,
+                    lastRequestEnded: entry.lastMessageDate
+                },
                 isActive: ( this._sessionModels.has(sessionResource)),
-                lastResponseState: entry.lastResponseState ?? ResponseModelState.Complete
+                lastResponseState: lastResponseState === ResponseModelState.Pending || lastResponseState === ResponseModelState.NeedsInput ? ResponseModelState.Complete : lastResponseState
             });
         }));
     }
@@ -305,9 +332,13 @@ let ChatService = class ChatService extends Disposable {
             return {
                 ...metadata,
                 sessionResource,
-                timing: metadata.timing ?? { startTime: metadata.lastMessageDate },
+                timing: metadata.timing ?? {
+                    created: metadata.lastMessageDate,
+                    lastRequestStarted: undefined,
+                    lastRequestEnded: metadata.lastMessageDate
+                },
                 isActive: ( this._sessionModels.has(sessionResource)),
-                lastResponseState: metadata.lastResponseState ?? ResponseModelState.Complete,
+                lastResponseState: metadata.lastResponseState ?? ResponseModelState.Complete
             };
         }
         return undefined;
@@ -317,13 +348,16 @@ let ChatService = class ChatService extends Disposable {
     }
     async removeHistoryEntry(sessionResource) {
         await this._chatSessionStore.deleteSession(this.toLocalSessionId(sessionResource));
-        this._onDidDisposeSession.fire({ sessionResource: [sessionResource], reason: 'cleared' });
+        this._onDidDisposeSession.fire({
+            sessionResource: [sessionResource],
+            reason: "cleared"
+        });
     }
     async clearAllHistoryEntries() {
         await this._chatSessionStore.clearAllSessions();
     }
     startSession(location, options) {
-        this.trace('startSession');
+        this.trace("startSession");
         const sessionId = generateUuid();
         const sessionResource = LocalChatSessionUri.forSession(sessionId);
         return this._sessionModels.acquireOrCreate({
@@ -336,8 +370,24 @@ let ChatService = class ChatService extends Disposable {
         });
     }
     _startSession(props) {
-        const { initialData, location, sessionResource, sessionId, canUseTools, transferEditingSession, disableBackgroundKeepAlive, inputState } = props;
-        const model = this.instantiationService.createInstance(ChatModel, initialData, { initialLocation: location, canUseTools, resource: sessionResource, sessionId, disableBackgroundKeepAlive, inputState });
+        const {
+            initialData,
+            location,
+            sessionResource,
+            sessionId,
+            canUseTools,
+            transferEditingSession,
+            disableBackgroundKeepAlive,
+            inputState
+        } = props;
+        const model = this.instantiationService.createInstance(ChatModel, initialData, {
+            initialLocation: location,
+            canUseTools,
+            resource: sessionResource,
+            sessionId,
+            disableBackgroundKeepAlive,
+            inputState
+        });
         if (location === ChatAgentLocation.Chat) {
             model.startEditingSession(true, transferEditingSession);
         }
@@ -345,14 +395,14 @@ let ChatService = class ChatService extends Disposable {
         return model;
     }
     initializeSession(model) {
-        this.trace('initializeSession', `Initialize session ${model.sessionResource}`);
+        this.trace("initializeSession", `Initialize session ${model.sessionResource}`);
         this.activateDefaultAgent(model.initialLocation).catch(e => this.logService.error(e));
     }
     async activateDefaultAgent(location) {
         await this.extensionService.whenInstalledExtensionsRegistered();
         const defaultAgentData = this.chatAgentService.getContributedDefaultAgent(location) ?? this.chatAgentService.getContributedDefaultAgent(ChatAgentLocation.Chat);
         if (!defaultAgentData) {
-            throw ( new ErrorNoTelemetry('No default agent contributed'));
+            throw ( new ErrorNoTelemetry("No default agent contributed"));
         }
         if (!defaultAgentData.isCore) {
             await this.extensionService.activateById(defaultAgentData.extensionId, {
@@ -363,7 +413,7 @@ let ChatService = class ChatService extends Disposable {
         }
         const defaultAgent = this.chatAgentService.getActivatedAgents().find(agent => agent.id === defaultAgentData.id);
         if (!defaultAgent) {
-            throw ( new ErrorNoTelemetry('No default agent registered'));
+            throw ( new ErrorNoTelemetry("No default agent registered"));
         }
     }
     getSession(sessionResource) {
@@ -373,7 +423,7 @@ let ChatService = class ChatService extends Disposable {
         return this._sessionModels.acquireExisting(sessionResource);
     }
     async getOrRestoreSession(sessionResource) {
-        this.trace('getOrRestoreSession', `${sessionResource}`);
+        this.trace("getOrRestoreSession", `${sessionResource}`);
         const existingRef = this._sessionModels.acquireExisting(sessionResource);
         if (existingRef) {
             return existingRef;
@@ -385,20 +435,19 @@ let ChatService = class ChatService extends Disposable {
         let sessionData;
         if (isEqual(this.transferredSessionResource, sessionResource)) {
             this._transferredSessionResource = undefined;
-            sessionData = revive(await this._chatSessionStore.readTransferredSession(sessionResource));
-        }
-        else {
-            sessionData = revive(await this._chatSessionStore.readSession(sessionId));
+            sessionData = await this._chatSessionStore.readTransferredSession(sessionResource);
+        } else {
+            sessionData = await this._chatSessionStore.readSession(sessionId);
         }
         if (!sessionData) {
             return undefined;
         }
         const sessionRef = this._sessionModels.acquireOrCreate({
             initialData: sessionData,
-            location: sessionData.initialLocation ?? ChatAgentLocation.Chat,
+            location: sessionData.value.initialLocation ?? ChatAgentLocation.Chat,
             sessionResource,
             sessionId,
-            canUseTools: true,
+            canUseTools: true
         });
         return sessionRef;
     }
@@ -407,18 +456,20 @@ let ChatService = class ChatService extends Disposable {
         if (!sessionId) {
             return undefined;
         }
-        return this._sessionModels.get(sessionResource)?.title ??
-            this._chatSessionStore.getMetadataForSessionSync(sessionResource)?.title;
+        return this._sessionModels.get(sessionResource)?.title ?? this._chatSessionStore.getMetadataForSessionSync(sessionResource)?.title;
     }
     loadSessionFromContent(data) {
         const sessionId = data.sessionId ?? generateUuid();
         const sessionResource = LocalChatSessionUri.forSession(sessionId);
         return this._sessionModels.acquireOrCreate({
-            initialData: data,
+            initialData: {
+                value: data,
+                serializer: ( new ChatSessionOperationLog())
+            },
             location: data.initialLocation ?? ChatAgentLocation.Chat,
             sessionResource,
             sessionId,
-            canUseTools: true,
+            canUseTools: true
         });
     }
     async loadSessionForResource(chatSessionResource, location, token) {
@@ -437,12 +488,12 @@ let ChatService = class ChatService extends Disposable {
             sessionResource: chatSessionResource,
             canUseTools: false,
             transferEditingSession: providedSession.transferredState?.editingSession,
-            inputState: providedSession.transferredState?.inputState,
+            inputState: providedSession.transferredState?.inputState
         });
         modelRef.object.setContributedChatSession({
             chatSessionResource,
             chatSessionType,
-            isUntitled: chatSessionResource.path.startsWith('/untitled-')
+            isUntitled: chatSessionResource.path.startsWith("/untitled-")
         });
         const model = modelRef.object;
         const disposables = ( new DisposableStore());
@@ -452,27 +503,32 @@ let ChatService = class ChatService extends Disposable {
         }));
         let lastRequest;
         for (const message of providedSession.history) {
-            if (message.type === 'request') {
+            if (message.type === "request") {
                 if (lastRequest) {
                     lastRequest.response?.complete();
                 }
                 const requestText = message.prompt;
                 const parsedRequest = {
                     text: requestText,
-                    parts: [( new ChatRequestTextPart(( new OffsetRange(0, requestText.length)), { startLineNumber: 1, startColumn: 1, endLineNumber: 1, endColumn: requestText.length + 1 }, requestText))]
+                    parts: [( new ChatRequestTextPart(( new OffsetRange(0, requestText.length)), {
+                        startLineNumber: 1,
+                        startColumn: 1,
+                        endLineNumber: 1,
+                        endColumn: requestText.length + 1
+                    }, requestText))]
                 };
-                const agent = message.participant
-                    ? this.chatAgentService.getAgent(message.participant)
-                    : this.chatAgentService.getAgent(chatSessionType);
-                lastRequest = model.addRequest(parsedRequest, message.variableData ?? { variables: [] }, 0,
+                const agent = message.participant ?
+                this.chatAgentService.getAgent(message.participant) : this.chatAgentService.getAgent(chatSessionType);
+                lastRequest = model.addRequest(parsedRequest, message.variableData ?? {
+                    variables: []
+                }, 0,
                 undefined, agent, undefined,
                 undefined,
                 undefined,
                 undefined,
                 false,
                 undefined, undefined, message.id);
-            }
-            else {
+            } else {
                 if (lastRequest) {
                     for (const part of message.parts) {
                         model.acceptResponseProgress(lastRequest, part);
@@ -487,7 +543,7 @@ let ChatService = class ChatService extends Disposable {
             const initialCancellationRequest = this.instantiationService.createInstance(CancellableRequest, ( new CancellationTokenSource()), undefined);
             this._pendingRequests.set(model.sessionResource, initialCancellationRequest);
             const cancellationListener = disposables.add(( new MutableDisposable()));
-            const createCancellationListener = (token) => {
+            const createCancellationListener = token => {
                 return token.onCancellationRequested(() => {
                     providedSession.interruptActiveResponseCallback?.().then(userConfirmedInterruption => {
                         if (!userConfirmedInterruption) {
@@ -515,8 +571,7 @@ let ChatService = class ChatService extends Disposable {
                     cancellationListener.clear();
                 }
             }));
-        }
-        else {
+        } else {
             if (lastRequest && model.editingSession) {
                 await chatEditingSessionIsReady(model.editingSession);
                 lastRequest.response?.complete();
@@ -529,7 +584,9 @@ let ChatService = class ChatService extends Disposable {
         if (!model) {
             return;
         }
-        const { contributedChatSession } = model;
+        const {
+            contributedChatSession
+        } = model;
         return contributedChatSession;
     }
     async resendRequest(request, options) {
@@ -539,7 +596,10 @@ let ChatService = class ChatService extends Disposable {
         }
         const cts = this._pendingRequests.get(request.session.sessionResource);
         if (cts) {
-            this.trace('resendRequest', `Session ${request.session.sessionResource} already has a pending request, cancelling...`);
+            this.trace(
+                "resendRequest",
+                `Session ${request.session.sessionResource} already has a pending request, cancelling...`
+            );
             cts.cancel();
         }
         const location = options?.location ?? model.initialLocation;
@@ -550,14 +610,23 @@ let ChatService = class ChatService extends Disposable {
         const resendOptions = {
             ...options,
             locationData: request.locationData,
-            attachedContext: request.attachedContext,
+            attachedContext: request.attachedContext
         };
-        await this._sendRequestAsync(model, model.sessionResource, request.message, attempt, enableCommandDetection, defaultAgent, location, resendOptions).responseCompletePromise;
+        await this._sendRequestAsync(
+            model,
+            model.sessionResource,
+            request.message,
+            attempt,
+            enableCommandDetection,
+            defaultAgent,
+            location,
+            resendOptions
+        ).responseCompletePromise;
     }
     async sendRequest(sessionResource, request, options) {
-        this.trace('sendRequest', `sessionResource: ${( sessionResource.toString())}, message: ${request.substring(0, 20)}${request.length > 20 ? '[...]' : ''}}`);
+        this.trace("sendRequest", `sessionResource: ${( sessionResource.toString())}, message: ${request.substring(0, 20)}${request.length > 20 ? "[...]" : ""}}`);
         if (!request.trim() && !options?.slashCommand && !options?.agentId && !options?.agentIdSilent) {
-            this.trace('sendRequest', 'Rejected empty message');
+            this.trace("sendRequest", "Rejected empty message");
             return;
         }
         const model = this._sessionModels.get(sessionResource);
@@ -565,7 +634,7 @@ let ChatService = class ChatService extends Disposable {
             throw ( new Error(`Unknown session: ${sessionResource}`));
         }
         if (( this._pendingRequests.has(sessionResource))) {
-            this.trace('sendRequest', `Session ${sessionResource} already has a pending request`);
+            this.trace("sendRequest", `Session ${sessionResource} already has a pending request`);
             return;
         }
         const requests = model.getRequests();
@@ -574,8 +643,7 @@ let ChatService = class ChatService extends Disposable {
             if (request.shouldBeRemovedOnSend) {
                 if (request.shouldBeRemovedOnSend.afterUndoStop) {
                     request.response?.finalizeUndoState();
-                }
-                else {
+                } else {
                     await this.removeRequest(sessionResource, request.id);
                 }
             }
@@ -585,12 +653,21 @@ let ChatService = class ChatService extends Disposable {
         const defaultAgent = this.chatAgentService.getDefaultAgent(location, options?.modeInfo?.kind);
         const parsedRequest = this.parseChatRequest(sessionResource, request, location, options);
         const silentAgent = options?.agentIdSilent ? this.chatAgentService.getAgent(options.agentIdSilent) : undefined;
-        const agent = silentAgent ?? parsedRequest.parts.find((r) => r instanceof ChatRequestAgentPart)?.agent ?? defaultAgent;
-        const agentSlashCommandPart = parsedRequest.parts.find((r) => r instanceof ChatRequestAgentSubcommandPart);
+        const agent = silentAgent ?? parsedRequest.parts.find(r => r instanceof ChatRequestAgentPart)?.agent ?? defaultAgent;
+        const agentSlashCommandPart = parsedRequest.parts.find(r => r instanceof ChatRequestAgentSubcommandPart);
         return {
-            ...this._sendRequestAsync(model, sessionResource, parsedRequest, attempt, !options?.noCommandDetection, silentAgent ?? defaultAgent, location, options),
+            ...this._sendRequestAsync(
+                model,
+                sessionResource,
+                parsedRequest,
+                attempt,
+                !options?.noCommandDetection,
+                silentAgent ?? defaultAgent,
+                location,
+                options
+            ),
             agent,
-            slashCommand: agentSlashCommandPart?.command,
+            slashCommand: agentSlashCommandPart?.command
         };
     }
     parseChatRequest(sessionResource, request, location, options) {
@@ -600,8 +677,11 @@ let ChatService = class ChatService extends Disposable {
             if (!agent) {
                 throw ( new Error(`Unknown agent: ${options.agentId}`));
             }
-            parserContext = { selectedAgent: agent, mode: options.modeInfo?.kind };
-            const commandPart = options.slashCommand ? ` ${chatSubcommandLeader}${options.slashCommand}` : '';
+            parserContext = {
+                selectedAgent: agent,
+                mode: options.modeInfo?.kind
+            };
+            const commandPart = options.slashCommand ? ` ${chatSubcommandLeader}${options.slashCommand}` : "";
             request = `${chatAgentLeader}${agent.name}${commandPart} ${request}`;
         }
         const parsedRequest = this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(sessionResource, request, location, parserContext);
@@ -613,12 +693,21 @@ let ChatService = class ChatService extends Disposable {
         this._sessionFollowupCancelTokens.set(sessionResource, newTokenSource);
         return newTokenSource.token;
     }
-    _sendRequestAsync(model, sessionResource, parsedRequest, attempt, enableCommandDetection, defaultAgent, location, options) {
+    _sendRequestAsync(
+        model,
+        sessionResource,
+        parsedRequest,
+        attempt,
+        enableCommandDetection,
+        defaultAgent,
+        location,
+        options
+    ) {
         const followupsCancelToken = this.refreshFollowupsCancellationToken(sessionResource);
         let request;
-        const agentPart = parsedRequest.parts.find((r) => r instanceof ChatRequestAgentPart);
-        const agentSlashCommandPart = parsedRequest.parts.find((r) => r instanceof ChatRequestAgentSubcommandPart);
-        const commandPart = parsedRequest.parts.find((r) => r instanceof ChatRequestSlashCommandPart);
+        const agentPart = parsedRequest.parts.find(r => r instanceof ChatRequestAgentPart);
+        const agentSlashCommandPart = parsedRequest.parts.find(r => r instanceof ChatRequestAgentSubcommandPart);
+        const commandPart = parsedRequest.parts.find(r => r instanceof ChatRequestSlashCommandPart);
         const requests = [...model.getRequests()];
         const requestTelemetry = this.instantiationService.createInstance(ChatRequestTelemetry, {
             agent: agentPart?.agent ?? defaultAgent,
@@ -630,7 +719,7 @@ let ChatService = class ChatService extends Disposable {
             enableCommandDetection
         });
         let gotProgress = false;
-        const requestType = commandPart ? 'slashCommand' : 'string';
+        const requestType = commandPart ? "slashCommand" : "string";
         const responseCreated = ( new DeferredPromise());
         let responseCreatedComplete = false;
         function completeResponseCreated() {
@@ -643,7 +732,7 @@ let ChatService = class ChatService extends Disposable {
         const source = store.add(( new CancellationTokenSource()));
         const token = source.token;
         const sendRequestInternal = async () => {
-            const progressCallback = (progress) => {
+            const progressCallback = progress => {
                 if (token.isCancellationRequested) {
                     return;
                 }
@@ -651,11 +740,16 @@ let ChatService = class ChatService extends Disposable {
                 for (let i = 0; i < progress.length; i++) {
                     const isLast = i === progress.length - 1;
                     const progressItem = progress[i];
-                    if (progressItem.kind === 'markdownContent') {
-                        this.trace('sendRequest', `Provider returned progress for session ${model.sessionResource}, ${progressItem.content.value.length} chars`);
-                    }
-                    else {
-                        this.trace('sendRequest', `Provider returned progress: ${JSON.stringify(progressItem)}`);
+                    if (progressItem.kind === "markdownContent") {
+                        this.trace(
+                            "sendRequest",
+                            `Provider returned progress for session ${model.sessionResource}, ${progressItem.content.value.length} chars`
+                        );
+                    } else {
+                        this.trace(
+                            "sendRequest",
+                            `Provider returned progress: ${JSON.stringify(progressItem)}`
+                        );
                     }
                     model.acceptResponseProgress(request, progressItem, !isLast);
                 }
@@ -665,17 +759,20 @@ let ChatService = class ChatService extends Disposable {
             let detectedCommand;
             const stopWatch = ( new StopWatch(false));
             store.add(token.onCancellationRequested(() => {
-                this.trace('sendRequest', `Request for session ${model.sessionResource} was cancelled`);
+                this.trace(
+                    "sendRequest",
+                    `Request for session ${model.sessionResource} was cancelled`
+                );
                 if (!request) {
                     return;
                 }
                 requestTelemetry.complete({
                     timeToFirstProgress: undefined,
-                    result: 'cancelled',
+                    result: "cancelled",
                     totalTime: stopWatch.elapsed(),
                     requestType,
                     detectedAgent,
-                    request,
+                    request
                 });
                 model.cancelRequest(request);
             }));
@@ -684,16 +781,32 @@ let ChatService = class ChatService extends Disposable {
                 let agentOrCommandFollowups = undefined;
                 if (agentPart || (defaultAgent && !commandPart)) {
                     const prepareChatAgentRequest = (agent, command, enableCommandDetection, chatRequest, isParticipantDetected) => {
-                        const initVariableData = { variables: [] };
-                        request = chatRequest ?? model.addRequest(parsedRequest, initVariableData, attempt, options?.modeInfo, agent, command, options?.confirmation, options?.locationData, options?.attachedContext, undefined, options?.userSelectedModelId, options?.userSelectedTools?.get());
+                        const initVariableData = {
+                            variables: []
+                        };
+                        request = chatRequest ?? model.addRequest(
+                            parsedRequest,
+                            initVariableData,
+                            attempt,
+                            options?.modeInfo,
+                            agent,
+                            command,
+                            options?.confirmation,
+                            options?.locationData,
+                            options?.attachedContext,
+                            undefined,
+                            options?.userSelectedModelId,
+                            options?.userSelectedTools?.get()
+                        );
                         let variableData;
                         let message;
                         if (chatRequest) {
                             variableData = chatRequest.variableData;
                             message = getPromptText(request.message).message;
-                        }
-                        else {
-                            variableData = { variables: this.prepareContext(request.attachedContext) };
+                        } else {
+                            variableData = {
+                                variables: this.prepareContext(request.attachedContext)
+                            };
                             model.updateRequest(request, variableData);
                             const promptTextResult = getPromptText(request.message);
                             variableData = updateRanges(variableData, promptTextResult.diff);
@@ -716,7 +829,7 @@ let ChatService = class ChatService extends Disposable {
                             userSelectedModelId: options?.userSelectedModelId,
                             userSelectedTools: options?.userSelectedTools?.get(),
                             modeInstructions: options?.modeInfo?.modeInstructions,
-                            editedFileEvents: request.editedFileEvents,
+                            editedFileEvents: request.editedFileEvents
                         };
                         let isInitialTools = true;
                         store.add(autorun(reader => {
@@ -732,19 +845,12 @@ let ChatService = class ChatService extends Disposable {
                         }));
                         return agentRequest;
                     };
-                    if (this.configurationService.getValue('chat.detectParticipant.enabled') !== false &&
-                        this.chatAgentService.hasChatParticipantDetectionProviders() &&
-                        !agentPart &&
-                        !commandPart &&
-                        !agentSlashCommandPart &&
-                        enableCommandDetection &&
-                        (location !== ChatAgentLocation.EditorInline || !this.configurationService.getValue(InlineChatConfigKeys.EnableV2)) &&
-                        options?.modeInfo?.kind !== ChatModeKind.Agent &&
-                        options?.modeInfo?.kind !== ChatModeKind.Edit &&
-                        !options?.agentIdSilent) {
+                    if (this.configurationService.getValue("chat.detectParticipant.enabled") !== false && this.chatAgentService.hasChatParticipantDetectionProviders() && !agentPart && !commandPart && !agentSlashCommandPart && enableCommandDetection && (location !== ChatAgentLocation.EditorInline || !this.configurationService.getValue(InlineChatConfigKeys.EnableV2)) && options?.modeInfo?.kind !== ChatModeKind.Agent && options?.modeInfo?.kind !== ChatModeKind.Edit && !options?.agentIdSilent) {
                         const defaultAgentHistory = this.getHistoryEntriesFromModel(requests, location, defaultAgent.id);
                         const chatAgentRequest = prepareChatAgentRequest(defaultAgent, undefined, enableCommandDetection, undefined, false);
-                        const result = await this.chatAgentService.detectAgentOrCommand(chatAgentRequest, defaultAgentHistory, { location }, token);
+                        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;
@@ -755,7 +861,13 @@ let ChatService = class ChatService extends Disposable {
                     const command = detectedCommand ?? agentSlashCommandPart?.command;
                     await this.extensionService.activateByEvent(`onChatParticipant:${agent.id}`);
                     const history = this.getHistoryEntriesFromModel(requests, location, agent.id);
-                    const requestProps = prepareChatAgentRequest(agent, command, enableCommandDetection, request , !!detectedAgent);
+                    const requestProps = prepareChatAgentRequest(
+                        agent,
+                        command,
+                        enableCommandDetection,
+                        request,
+                        !!detectedAgent
+                    );
                     this.generateInitialChatTitleIfNeeded(model, requestProps, defaultAgent, token);
                     const pendingRequest = this._pendingRequests.get(sessionResource);
                     if (pendingRequest && !pendingRequest.requestId) {
@@ -772,10 +884,11 @@ let ChatService = class ChatService extends Disposable {
                     const agentResult = await this.chatAgentService.invokeAgent(agent.id, requestProps, progressCallback, history, token);
                     rawResult = agentResult;
                     agentOrCommandFollowups = this.chatAgentService.getFollowups(agent.id, requestProps, agentResult, history, followupsCancelToken);
-                }
-                else if (commandPart && this.chatSlashCommandService.hasCommand(commandPart.slashCommand.command)) {
+                } else if (commandPart && this.chatSlashCommandService.hasCommand(commandPart.slashCommand.command)) {
                     if (commandPart.slashCommand.silent !== true) {
-                        request = model.addRequest(parsedRequest, { variables: [] }, attempt, options?.modeInfo);
+                        request = model.addRequest(parsedRequest, {
+                            variables: []
+                        }, attempt, options?.modeInfo);
                         completeResponseCreated();
                     }
                     const history = [];
@@ -783,82 +896,114 @@ let ChatService = class ChatService extends Disposable {
                         if (!modelRequest.response) {
                             continue;
                         }
-                        history.push({ role: ChatMessageRole.User, content: [{ type: 'text', value: modelRequest.message.text }] });
-                        history.push({ role: ChatMessageRole.Assistant, content: [{ type: 'text', value: ( modelRequest.response.response.toString()) }] });
+                        history.push({
+                            role: ChatMessageRole.User,
+                            content: [{
+                                type: "text",
+                                value: modelRequest.message.text
+                            }]
+                        });
+                        history.push({
+                            role: ChatMessageRole.Assistant,
+                            content: [{
+                                type: "text",
+                                value: ( modelRequest.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 => {
-                        progressCallback([p]);
-                    })), history, location, model.sessionResource, token);
+                    const commandResult = await this.chatSlashCommandService.executeCommand(
+                        commandPart.slashCommand.command,
+                        message.substring(commandPart.slashCommand.command.length + 1).trimStart(),
+                        ( new Progress(p => {
+                            progressCallback([p]);
+                        })),
+                        history,
+                        location,
+                        model.sessionResource,
+                        token
+                    );
                     agentOrCommandFollowups = Promise.resolve(commandResult?.followUp);
                     rawResult = {};
-                }
-                else {
+                } else {
                     throw ( new Error(`Cannot handle request`));
                 }
                 if (token.isCancellationRequested && !rawResult) {
                     return;
-                }
-                else {
+                } else {
                     if (!rawResult) {
-                        this.trace('sendRequest', `Provider returned no response for session ${model.sessionResource}`);
-                        rawResult = { errorDetails: { message: ( localize(5945, "Provider returned null response")) } };
+                        this.trace(
+                            "sendRequest",
+                            `Provider returned no response for session ${model.sessionResource}`
+                        );
+                        rawResult = {
+                            errorDetails: {
+                                message: ( localize(6220, "Provider returned null response"))
+                            }
+                        };
                     }
-                    const result = rawResult.errorDetails?.responseIsFiltered ? 'filtered' :
-                        rawResult.errorDetails && gotProgress ? 'errorWithOutput' :
-                            rawResult.errorDetails ? 'error' :
-                                'success';
+                    const result = rawResult.errorDetails?.responseIsFiltered ? "filtered" : rawResult.errorDetails && gotProgress ? "errorWithOutput" : rawResult.errorDetails ? "error" : "success";
                     requestTelemetry.complete({
                         timeToFirstProgress: rawResult.timings?.firstProgress,
                         totalTime: rawResult.timings?.totalElapsed,
                         result,
                         requestType,
                         detectedAgent,
-                        request,
+                        request
                     });
                     model.setResponse(request, rawResult);
                     completeResponseCreated();
-                    this.trace('sendRequest', `Provider returned response for session ${model.sessionResource}`);
+                    this.trace(
+                        "sendRequest",
+                        `Provider returned response for session ${model.sessionResource}`
+                    );
                     request.response?.complete();
                     if (agentOrCommandFollowups) {
                         agentOrCommandFollowups.then(followups => {
                             model.setFollowups(request, followups);
                             const commandForTelemetry = agentSlashCommandPart ? agentSlashCommandPart.command.name : commandPart?.slashCommand.command;
-                            this._chatServiceTelemetry.retrievedFollowups(agentPart?.agent.id ?? '', commandForTelemetry, followups?.length ?? 0);
+                            this._chatServiceTelemetry.retrievedFollowups(agentPart?.agent.id ?? "", commandForTelemetry, followups?.length ?? 0);
                         });
                     }
                 }
-            }
-            catch (err) {
+            } catch (err) {
                 this.logService.error(`Error while handling chat request: ${toErrorMessage(err, true)}`);
                 requestTelemetry.complete({
                     timeToFirstProgress: undefined,
                     totalTime: undefined,
-                    result: 'error',
+                    result: "error",
                     requestType,
                     detectedAgent,
-                    request,
+                    request
                 });
                 if (request) {
-                    const rawResult = { errorDetails: { message: err.message } };
+                    const rawResult = {
+                        errorDetails: {
+                            message: err.message
+                        }
+                    };
                     model.setResponse(request, rawResult);
                     completeResponseCreated();
                     request.response?.complete();
                 }
-            }
-            finally {
+            } finally {
                 store.dispose();
             }
         };
         const rawResponsePromise = sendRequestInternal();
-        this._pendingRequests.set(model.sessionResource, this.instantiationService.createInstance(CancellableRequest, source, undefined));
+        this._pendingRequests.set(
+            model.sessionResource,
+            this.instantiationService.createInstance(CancellableRequest, source, undefined)
+        );
         rawResponsePromise.finally(() => {
             this._pendingRequests.deleteAndDispose(model.sessionResource);
         });
-        this._onDidSubmitRequest.fire({ chatSessionResource: model.sessionResource });
+        this._onDidSubmitRequest.fire({
+            chatSessionResource: model.sessionResource
+        });
         return {
             responseCreatedPromise: responseCreated.p,
-            responseCompletePromise: rawResponsePromise,
+            responseCompletePromise: rawResponsePromise
         };
     }
     generateInitialChatTitleIfNeeded(model, request, defaultAgent, token) {
@@ -866,10 +1011,10 @@ let ChatService = class ChatService extends Disposable {
             return;
         }
         const singleEntryHistory = [{
-                request,
-                response: [],
-                result: {}
-            }];
+            request,
+            response: [],
+            result: {}
+        }];
         const generate = async () => {
             const title = await this.chatAgentService.getChatTitle(defaultAgent.id, singleEntryHistory, token);
             if (title && !model.customTitle) {
@@ -911,14 +1056,18 @@ let ChatService = class ChatService extends Disposable {
             const historyRequest = {
                 sessionResource: request.session.sessionResource,
                 requestId: request.id,
-                agentId: request.response.agent?.id ?? '',
+                agentId: request.response.agent?.id ?? "",
                 message: promptTextResult.message,
                 command: request.response.slashCommand?.name,
                 variables: updateRanges(request.variableData, promptTextResult.diff),
                 location: ChatAgentLocation.Chat,
-                editedFileEvents: request.editedFileEvents,
+                editedFileEvents: request.editedFileEvents
             };
-            history.push({ request: historyRequest, response: toChatHistoryContent(request.response.response.value), result: request.response.result ?? {} });
+            history.push({
+                request: historyRequest,
+                response: toChatHistoryContent(request.response.response.value),
+                result: request.response.result ?? {}
+            });
         }
         return history;
     }
@@ -936,7 +1085,7 @@ let ChatService = class ChatService extends Disposable {
     }
     async adoptRequest(sessionResource, request) {
         if (!(request instanceof ChatRequestModel)) {
-            throw ( new TypeError('Can only adopt requests of type ChatRequestModel'));
+            throw ( new TypeError("Can only adopt requests of type ChatRequestModel"));
         }
         const target = this._sessionModels.get(sessionResource);
         if (!target) {
@@ -953,19 +1102,21 @@ let ChatService = class ChatService extends Disposable {
         }
     }
     async addCompleteRequest(sessionResource, message, variableData, attempt, response) {
-        this.trace('addCompleteRequest', `message: ${message}`);
+        this.trace("addCompleteRequest", `message: ${message}`);
         const model = this._sessionModels.get(sessionResource);
         if (!model) {
             throw ( new Error(`Unknown session: ${sessionResource}`));
         }
-        const parsedRequest = typeof message === 'string' ?
-            this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(sessionResource, message) :
-            message;
-        const request = model.addRequest(parsedRequest, variableData || { variables: [] }, attempt ?? 0, undefined, undefined, undefined, undefined, undefined, undefined, true);
-        if (typeof response.message === 'string') {
-            model.acceptResponseProgress(request, { content: ( new MarkdownString(response.message)), kind: 'markdownContent' });
-        }
-        else {
+        const parsedRequest = typeof message === "string" ? this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(sessionResource, message) : message;
+        const request = model.addRequest(parsedRequest, variableData || {
+            variables: []
+        }, attempt ?? 0, undefined, undefined, undefined, undefined, undefined, undefined, true);
+        if (typeof response.message === "string") {
+            model.acceptResponseProgress(request, {
+                content: ( new MarkdownString(response.message)),
+                kind: "markdownContent"
+            });
+        } else {
             for (const part of response.message) {
                 model.acceptResponseProgress(request, part, true);
             }
@@ -977,7 +1128,7 @@ let ChatService = class ChatService extends Disposable {
         request.response?.complete();
     }
     cancelCurrentRequestForSession(sessionResource) {
-        this.trace('cancelCurrentRequestForSession', `session: ${sessionResource}`);
+        this.trace("cancelCurrentRequestForSession", `session: ${sessionResource}`);
         this._pendingRequests.get(sessionResource)?.cancel();
         this._pendingRequests.deleteAndDispose(sessionResource);
     }
@@ -1004,10 +1155,13 @@ let ChatService = class ChatService extends Disposable {
         await this._chatSessionStore.storeTransferSession({
             sessionResource: model.sessionResource,
             timestampInMilliseconds: Date.now(),
-            toWorkspace: toWorkspace,
+            toWorkspace: toWorkspace
         }, model);
         this.chatTransferService.addWorkspaceToTransferred(toWorkspace);
-        this.trace('transferChatSession', `Transferred session ${model.sessionResource} to workspace ${( toWorkspace.toString())}`);
+        this.trace(
+            "transferChatSession",
+            `Transferred session ${model.sessionResource} to workspace ${( toWorkspace.toString())}`
+        );
     }
     getChatStorageFolder() {
         return this._chatSessionStore.getChatStorageFolder();
@@ -1021,7 +1175,7 @@ let ChatService = class ChatService extends Disposable {
     appendProgress(request, progress) {
         const model = this._sessionModels.get(request.session.sessionResource);
         if (!(request instanceof ChatRequestModel)) {
-            throw ( new BugIndicatingError('Can only append progress to requests of type ChatRequestModel'));
+            throw ( new BugIndicatingError("Can only append progress to requests of type ChatRequestModel"));
         }
         model?.acceptResponseProgress(request, progress);
     }
@@ -1033,18 +1187,6 @@ let ChatService = class ChatService extends Disposable {
         return localSessionId;
     }
 };
-ChatService = ( __decorate([
-    ( __param(0, IStorageService)),
-    ( __param(1, ILogService)),
-    ( __param(2, IExtensionService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IWorkspaceContextService)),
-    ( __param(5, IChatSlashCommandService)),
-    ( __param(6, IChatAgentService)),
-    ( __param(7, IConfigurationService)),
-    ( __param(8, IChatTransferService)),
-    ( __param(9, IChatSessionsService)),
-    ( __param(10, IMcpService))
-], ChatService));
+ChatService = ( __decorate([( __param(0, IStorageService)), ( __param(1, ILogService)), ( __param(2, IExtensionService)), ( __param(3, IInstantiationService)), ( __param(4, IWorkspaceContextService)), ( __param(5, IChatSlashCommandService)), ( __param(6, IChatAgentService)), ( __param(7, IConfigurationService)), ( __param(8, IChatTransferService)), ( __param(9, IChatSessionsService)), ( __param(10, IMcpService))], ChatService));
 
 export { ChatService };