@codingame/monaco-vscode-chat-service-override 4.5.1 → 5.0.0

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

@@ -5,14 +5,13 @@ 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';
 import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
-import { Disposable, DisposableMap, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Disposable, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
 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 { 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 { 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 'vscode/vscode/vs/platform/notification/common/notification';
@@ -23,8 +22,7 @@ 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 { CONTEXT_PROVIDER_EXISTS } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
-import { ChatModel, ChatWelcomeMessageModel, getHistoryEntriesFromModel, updateRanges, ChatModelInitState } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatModel';
+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 { ChatRequestParser } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatRequestParser';
 import { InteractiveSessionVoteDirection, ChatCopyKind } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService';
@@ -33,6 +31,7 @@ import { IChatVariablesService } from 'vscode/vscode/vs/workbench/contrib/chat/c
 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';
 const globalChatKey = 'chat.workspaceTransfer';
 const SESSION_TRANSFER_EXPIRATION_IN_MILLISECONDS = 1000 * 60;
@@ -41,37 +40,30 @@ let ChatService = class ChatService extends Disposable {
     get transferredSessionData() {
         return this._transferredSessionData;
     }
-    constructor(storageService, logService, extensionService, instantiationService, telemetryService, contextKeyService, workspaceContextService, chatSlashCommandService, chatVariablesService, chatAgentService, notificationService, commandService) {
+    constructor(storageService, logService, extensionService, instantiationService, telemetryService, workspaceContextService, chatSlashCommandService, chatVariablesService, chatAgentService, notificationService, commandService) {
         super();
         this.storageService = storageService;
         this.logService = logService;
         this.extensionService = extensionService;
         this.instantiationService = instantiationService;
         this.telemetryService = telemetryService;
-        this.contextKeyService = contextKeyService;
         this.workspaceContextService = workspaceContextService;
         this.chatSlashCommandService = chatSlashCommandService;
         this.chatVariablesService = chatVariablesService;
         this.chatAgentService = chatAgentService;
         this.notificationService = notificationService;
         this.commandService = commandService;
-        this._providers = ( new Map());
-        this._sessionModels = this._register(( new DisposableMap()));
-        this._pendingRequests = this._register(( new DisposableMap()));
-        this._onDidPerformUserAction = this._register(( new Emitter()));
+        this._sessionModels = this._register(( (new DisposableMap())));
+        this._pendingRequests = this._register(( (new DisposableMap())));
+        this._onDidPerformUserAction = this._register(( (new Emitter())));
         this.onDidPerformUserAction = this._onDidPerformUserAction.event;
-        this._onDidDisposeSession = this._register(( new Emitter()));
+        this._onDidDisposeSession = this._register(( (new Emitter())));
         this.onDidDisposeSession = this._onDidDisposeSession.event;
-        this._onDidRegisterProvider = this._register(( new Emitter()));
-        this.onDidRegisterProvider = this._onDidRegisterProvider.event;
-        this._onDidUnregisterProvider = this._register(( new Emitter()));
-        this.onDidUnregisterProvider = this._onDidUnregisterProvider.event;
-        this._sessionFollowupCancelTokens = this._register(( new DisposableMap()));
-        this._hasProvider = CONTEXT_PROVIDER_EXISTS.bindTo(this.contextKeyService);
+        this._sessionFollowupCancelTokens = this._register(( (new DisposableMap())));
         const sessionData = storageService.get(serializedChatKey, 1 , '');
         if (sessionData) {
             this._persistedSessions = this.deserializeChats(sessionData);
-            const countsForLog = ( Object.keys(this._persistedSessions)).length;
+            const countsForLog = ( (Object.keys(this._persistedSessions))).length;
             if (countsForLog > 0) {
                 this.trace('constructor', `Restored ${countsForLog} persisted sessions`);
             }
@@ -88,12 +80,15 @@ let ChatService = class ChatService extends Disposable {
         }
         this._register(storageService.onWillSaveState(() => this.saveState()));
     }
+    isEnabled(location) {
+        return this.chatAgentService.getContributedDefaultAgent(location) !== undefined;
+    }
     saveState() {
-        let allSessions = Array.from(( this._sessionModels.values()))
-            .filter(session => !session.providerId.startsWith('inlinechat:'))
+        let allSessions = 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)))
+        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);
@@ -109,19 +104,16 @@ let ChatService = class ChatService extends Disposable {
     notifyUserAction(action) {
         if (action.action.kind === 'vote') {
             this.telemetryService.publicLog2('interactiveSessionVote', {
-                providerId: action.providerId,
                 direction: action.action.direction === InteractiveSessionVoteDirection.Up ? 'up' : 'down'
             });
         }
         else if (action.action.kind === 'copy') {
             this.telemetryService.publicLog2('interactiveSessionCopy', {
-                providerId: action.providerId,
                 copyKind: action.action.copyKind === ChatCopyKind.Action ? 'action' : 'toolbar'
             });
         }
         else if (action.action.kind === 'insert') {
             this.telemetryService.publicLog2('interactiveSessionInsert', {
-                providerId: action.providerId,
                 newFile: !!action.action.newFile
             });
         }
@@ -129,20 +121,23 @@ let ChatService = class ChatService extends Disposable {
             const command = CommandsRegistry.getCommand(action.action.commandButton.command.id);
             const commandId = command ? action.action.commandButton.command.id : 'INVALID';
             this.telemetryService.publicLog2('interactiveSessionCommand', {
-                providerId: action.providerId,
                 commandId
             });
         }
         else if (action.action.kind === 'runInTerminal') {
             this.telemetryService.publicLog2('interactiveSessionRunInTerminal', {
-                providerId: action.providerId,
                 languageId: action.action.languageId ?? ''
             });
         }
         this._onDidPerformUserAction.fire(action);
     }
     trace(method, message) {
-        this.logService.trace(`ChatService#${method}: ${message}`);
+        if (message) {
+            this.logService.trace(`ChatService#${method}: ${message}`);
+        }
+        else {
+            this.logService.trace(`ChatService#${method}`);
+        }
     }
     error(method, message) {
         this.logService.error(`ChatService#${method} ${message}`);
@@ -151,20 +146,22 @@ 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) => {
+                        request.response = ( (request.response.map((response) => {
                             if (typeof response === 'string') {
-                                return ( new MarkdownString(response));
+                                return (
+                                     (new MarkdownString(response))
+                                );
                             }
                             return response;
-                        }));
+                        })));
                     }
                     else if (typeof request.response === 'string') {
-                        request.response = [( new MarkdownString(request.response))];
+                        request.response = [( (new MarkdownString(request.response)))];
                     }
                 }
                 acc[session.sessionId] = session;
@@ -183,27 +180,29 @@ let ChatService = class ChatService extends Disposable {
         if (!workspaceUri) {
             return;
         }
-        const thisWorkspace = ( workspaceUri.toString());
+        const thisWorkspace = ( (workspaceUri.toString()));
         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));
+        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 );
         return transferred;
     }
     getHistory() {
-        const sessions = ( Object.values(this._persistedSessions))
+        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
-            };
-        }));
+        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
+                };
+            }))
+        );
     }
     removeHistoryEntry(sessionId) {
         delete this._persistedSessions[sessionId];
@@ -213,81 +212,61 @@ let ChatService = class ChatService extends Disposable {
         this._persistedSessions = {};
         this.saveState();
     }
-    startSession(providerId, token) {
-        this.trace('startSession', `providerId=${providerId}`);
-        return this._startSession(providerId, undefined, token);
+    startSession(location, token) {
+        this.trace('startSession');
+        return this._startSession(undefined, location, token);
     }
-    _startSession(providerId, someSessionHistory, token) {
-        this.trace('_startSession', `providerId=${providerId}`);
-        const model = this.instantiationService.createInstance(ChatModel, providerId, someSessionHistory);
+    _startSession(someSessionHistory, location, token) {
+        const model = this.instantiationService.createInstance(ChatModel, someSessionHistory, location);
         this._sessionModels.set(model.sessionId, model);
         this.initializeSession(model, token);
         return model;
     }
-    reinitializeModel(model) {
-        this.trace('reinitializeModel', `Start reinit`);
-        this.initializeSession(model, CancellationToken.None);
-    }
     async initializeSession(model, token) {
         try {
             this.trace('initializeSession', `Initialize session ${model.sessionId}`);
             model.startInitialize();
-            await this.extensionService.activateByEvent(`onInteractiveSession:${model.providerId}`);
-            const provider = this._providers.get(model.providerId);
-            if (!provider) {
-                throw new ErrorNoTelemetry(`Unknown provider: ${model.providerId}`);
+            await this.extensionService.whenInstalledExtensionsRegistered();
+            const defaultAgentData = this.chatAgentService.getContributedDefaultAgent(model.initialLocation) ?? this.chatAgentService.getContributedDefaultAgent(ChatAgentLocation.Panel);
+            if (!defaultAgentData) {
+                throw ( (new ErrorNoTelemetry('No default agent contributed')));
             }
-            let session;
-            try {
-                session = (await provider.prepareSession(token)) ?? undefined;
-            }
-            catch (err) {
-                this.trace('initializeSession', `Provider initializeSession threw: ${err}`);
-            }
-            if (!session) {
-                throw new Error('Provider returned no session');
-            }
-            this.trace('startSession', `Provider returned session`);
-            const defaultAgent = this.chatAgentService.getDefaultAgent(ChatAgentLocation.Panel);
+            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(
-                        'vs/workbench/contrib/chat/common/chatServiceImpl',
-                        'chatFailErrorMessage',
+                        _moduleId,
+                        0,
                         "Chat failed to load. Please ensure that the GitHub Copilot Chat extension is up to date."
                     )),
                     actions: {
                         primary: [
-                            ( new Action('showExtension', ( localizeWithPath(
-                                'vs/workbench/contrib/chat/common/chatServiceImpl',
-                                'action.showExtension',
-                                "Show Extension"
-                            )), undefined, true, () => {
-                                return this.commandService.executeCommand('workbench.extensions.action.showExtensionsWithIds', ['GitHub.copilot-chat']);
-                            }))
+                            ( (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');
+                throw ( (new ErrorNoTelemetry('No default agent registered')));
             }
-            const welcomeMessage = model.welcomeMessage ? undefined : (await defaultAgent.provideWelcomeMessage?.(token)) ?? undefined;
-            const welcomeModel = welcomeMessage && this.instantiationService.createInstance(ChatWelcomeMessageModel, ( welcomeMessage.map(item => typeof item === 'string' ? ( new MarkdownString(item)) : item)), (await defaultAgent.provideSampleQuestions?.(token)) ?? []);
-            model.initialize(session, welcomeModel);
+            const welcomeMessage = model.welcomeMessage ? undefined : (await defaultAgent.provideWelcomeMessage?.(model.initialLocation, token)) ?? undefined;
+            const welcomeModel = welcomeMessage && this.instantiationService.createInstance(ChatWelcomeMessageModel, ( (welcomeMessage.map(
+                item => typeof item === 'string' ? ( (new MarkdownString(item))) : item
+            ))), (await defaultAgent.provideSampleQuestions?.(model.initialLocation, token)) ?? []);
+            model.initialize(welcomeModel);
         }
         catch (err) {
             this.trace('startSession', `initializeSession failed: ${err}`);
             model.setInitializationError(err);
             this._sessionModels.deleteAndDispose(model.sessionId);
-            this._onDidDisposeSession.fire({ sessionId: model.sessionId, providerId: model.providerId, reason: 'initializationFailed' });
+            this._onDidDisposeSession.fire({ sessionId: model.sessionId, reason: 'initializationFailed' });
         }
     }
     getSession(sessionId) {
         return this._sessionModels.get(sessionId);
     }
-    getSessionId(sessionProviderId) {
-        return Iterable.find(( this._sessionModels.values()), model => model.session?.id === sessionProviderId)?.sessionId;
-    }
     getOrRestoreSession(sessionId) {
         this.trace('getOrRestoreSession', `sessionId: ${sessionId}`);
         const model = this._sessionModels.get(sessionId);
@@ -301,12 +280,30 @@ let ChatService = class ChatService extends Disposable {
         if (sessionId === this.transferredSessionData?.sessionId) {
             this._transferredSessionData = undefined;
         }
-        return this._startSession(sessionData.providerId, sessionData, CancellationToken.None);
+        return this._startSession(sessionData, sessionData.initialLocation ?? ChatAgentLocation.Panel, CancellationToken.None);
     }
     loadSessionFromContent(data) {
-        return this._startSession(data.providerId, data, CancellationToken.None);
+        return this._startSession(data, data.initialLocation ?? ChatAgentLocation.Panel, CancellationToken.None);
+    }
+    async resendRequest(request, options) {
+        const model = this._sessionModels.get(request.session.sessionId);
+        if (!model && model !== request.session) {
+            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 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);
     }
-    async sendRequest(sessionId, request, implicitVariablesEnabled, location = ChatAgentLocation.Panel, parserContext) {
+    async sendRequest(sessionId, request, options) {
         this.trace('sendRequest', `sessionId: ${sessionId}, message: ${request.substring(0, 20)}${request.length > 20 ? '[...]' : ''}}`);
         if (!request.trim()) {
             this.trace('sendRequest', 'Rejected empty message');
@@ -314,34 +311,33 @@ let ChatService = class ChatService extends Disposable {
         }
         const model = this._sessionModels.get(sessionId);
         if (!model) {
-            throw new Error(`Unknown session: ${sessionId}`);
+            throw ( (new Error(`Unknown session: ${sessionId}`)));
         }
         await model.waitForInitialization();
-        const provider = this._providers.get(model.providerId);
-        if (!provider) {
-            throw new Error(`Unknown provider: ${model.providerId}`);
-        }
-        if (( this._pendingRequests.has(sessionId))) {
+        if (( (this._pendingRequests.has(sessionId)))) {
             this.trace('sendRequest', `Session ${sessionId} already has a pending request`);
             return;
         }
+        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, parserContext);
+        const parsedRequest = this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(sessionId, request, location, options?.parserContext);
         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, provider, parsedRequest, implicitVariablesEnabled ?? false, defaultAgent, location),
+            responseCompletePromise: this._sendRequestAsync(model, sessionId, parsedRequest, attempt, !options?.noCommandDetection, implicitVariablesEnabled, defaultAgent, location),
             agent,
             slashCommand: agentSlashCommandPart?.command,
         };
     }
     refreshFollowupsCancellationToken(sessionId) {
         this._sessionFollowupCancelTokens.get(sessionId)?.cancel();
-        const newTokenSource = ( new CancellationTokenSource());
+        const newTokenSource = ( (new CancellationTokenSource()));
         this._sessionFollowupCancelTokens.set(sessionId, newTokenSource);
         return newTokenSource.token;
     }
-    async _sendRequestAsync(model, sessionId, provider, parsedRequest, implicitVariablesEnabled, defaultAgent, location) {
+    async _sendRequestAsync(model, sessionId, parsedRequest, attempt, enableCommandDetection, implicitVariablesEnabled, defaultAgent, location) {
         const followupsCancelToken = this.refreshFollowupsCancellationToken(sessionId);
         let request;
         const agentPart = 'kind' in parsedRequest ? undefined : parsedRequest.parts.find((r) => r instanceof ChatRequestAgentPart);
@@ -349,7 +345,7 @@ 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 source = ( new CancellationTokenSource());
+        const source = ( (new CancellationTokenSource()));
         const token = source.token;
         const sendRequestInternal = async () => {
             const progressCallback = (progress) => {
@@ -357,19 +353,18 @@ let ChatService = class ChatService extends Disposable {
                     return;
                 }
                 gotProgress = true;
-                if (progress.kind === 'content' || progress.kind === 'markdownContent') {
-                    this.trace('sendRequest', `Provider returned progress for session ${model.sessionId}, ${typeof progress.content === 'string' ? progress.content.length : progress.content.value.length} chars`);
+                if (progress.kind === 'markdownContent') {
+                    this.trace('sendRequest', `Provider returned progress for session ${model.sessionId}, ${progress.content.value.length} chars`);
                 }
                 else {
                     this.trace('sendRequest', `Provider returned progress: ${JSON.stringify(progress)}`);
                 }
                 model.acceptResponseProgress(request, progress);
             };
-            const stopWatch = ( new StopWatch(false));
+            const stopWatch = ( (new StopWatch(false)));
             const listener = token.onCancellationRequested(() => {
                 this.trace('sendRequest', `Request for session ${model.sessionId} was cancelled`);
                 this.telemetryService.publicLog2('interactiveSessionProviderInvoked', {
-                    providerId: provider.id,
                     timeToFirstProgress: undefined,
                     totalTime: stopWatch.elapsed(),
                     result: 'cancelled',
@@ -386,9 +381,9 @@ let ChatService = class ChatService extends Disposable {
                 if (agentPart || (defaultAgent && !commandPart)) {
                     const agent = (agentPart?.agent ?? defaultAgent);
                     await this.extensionService.activateByEvent(`onChatParticipant:${agent.id}`);
-                    const history = getHistoryEntriesFromModel(model);
+                    const history = getHistoryEntriesFromModel(model, agentPart?.agent.id);
                     const initVariableData = { variables: [] };
-                    request = model.addRequest(parsedRequest, initVariableData, agent, agentSlashCommandPart?.command);
+                    request = model.addRequest(parsedRequest, initVariableData, attempt, agent, agentSlashCommandPart?.command);
                     const variableData = await this.chatVariablesService.resolveVariables(parsedRequest, model, progressCallback, token);
                     request.variableData = variableData;
                     const promptTextResult = getPromptText(request.message);
@@ -396,9 +391,9 @@ let ChatService = class ChatService extends Disposable {
                     if (implicitVariablesEnabled) {
                         const implicitVariables = agent.defaultImplicitVariables;
                         if (implicitVariables) {
-                            const resolvedImplicitVariables = await Promise.all(( implicitVariables.map(
+                            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);
                         }
                     }
@@ -409,6 +404,8 @@ let ChatService = class ChatService extends Disposable {
                         message: promptTextResult.message,
                         command: agentSlashCommandPart?.command.name,
                         variables: updatedVariableData,
+                        enableCommandDetection,
+                        attempt,
                         location
                     };
                     const agentResult = await this.chatAgentService.invokeAgent(agent.id, requestProps, progressCallback, history, token);
@@ -416,7 +413,7 @@ let ChatService = class ChatService extends Disposable {
                     agentOrCommandFollowups = this.chatAgentService.getFollowups(agent.id, requestProps, agentResult, history, followupsCancelToken);
                 }
                 else if (commandPart && this.chatSlashCommandService.hasCommand(commandPart.slashCommand.command)) {
-                    request = model.addRequest(parsedRequest, { variables: [] });
+                    request = model.addRequest(parsedRequest, { variables: [] }, attempt);
                     const history = [];
                     for (const request of model.getRequests()) {
                         if (!request.response) {
@@ -426,14 +423,14 @@ let ChatService = class ChatService extends Disposable {
                         history.push({ role: 2 , 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 => {
+                    const commandResult = await this.chatSlashCommandService.executeCommand(commandPart.slashCommand.command, message.substring(commandPart.slashCommand.command.length + 1).trimStart(), ( (new Progress(p => {
                         progressCallback(p);
-                    })), history, token);
+                    }))), history, token);
                     agentOrCommandFollowups = Promise.resolve(commandResult?.followUp);
                     rawResult = {};
                 }
                 else {
-                    throw new Error(`Cannot handle request`);
+                    throw ( (new Error(`Cannot handle request`)));
                 }
                 if (token.isCancellationRequested) {
                     return;
@@ -441,18 +438,13 @@ let ChatService = class ChatService extends Disposable {
                 else {
                     if (!rawResult) {
                         this.trace('sendRequest', `Provider returned no response for session ${model.sessionId}`);
-                        rawResult = { errorDetails: { message: ( localizeWithPath(
-                            'vs/workbench/contrib/chat/common/chatServiceImpl',
-                            'emptyResponse',
-                            "Provider returned null response"
-                        )) } };
+                        rawResult = { errorDetails: { message: ( localizeWithPath(_moduleId, 2, "Provider returned null response")) } };
                     }
                     const result = rawResult.errorDetails?.responseIsFiltered ? 'filtered' :
                         rawResult.errorDetails && gotProgress ? 'errorWithOutput' :
                             rawResult.errorDetails ? 'error' :
                                 'success';
                     this.telemetryService.publicLog2('interactiveSessionProviderInvoked', {
-                        providerId: provider.id,
                         timeToFirstProgress: rawResult.timings?.firstProgress,
                         totalTime: rawResult.timings?.totalElapsed,
                         result,
@@ -485,31 +477,24 @@ let ChatService = class ChatService extends Disposable {
     async removeRequest(sessionId, requestId) {
         const model = this._sessionModels.get(sessionId);
         if (!model) {
-            throw new Error(`Unknown session: ${sessionId}`);
+            throw ( (new Error(`Unknown session: ${sessionId}`)));
         }
         await model.waitForInitialization();
-        const provider = this._providers.get(model.providerId);
-        if (!provider) {
-            throw new Error(`Unknown provider: ${model.providerId}`);
-        }
         model.removeRequest(requestId);
     }
-    getProviders() {
-        return Array.from(( this._providers.keys()));
-    }
-    async addCompleteRequest(sessionId, message, variableData, response) {
+    async addCompleteRequest(sessionId, message, variableData, attempt, response) {
         this.trace('addCompleteRequest', `message: ${message}`);
         const model = this._sessionModels.get(sessionId);
         if (!model) {
-            throw new Error(`Unknown session: ${sessionId}`);
+            throw ( (new Error(`Unknown session: ${sessionId}`)));
         }
         await model.waitForInitialization();
         const parsedRequest = typeof message === 'string' ?
             this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(sessionId, message) :
             message;
-        const request = model.addRequest(parsedRequest, variableData || { variables: [] });
+        const request = model.addRequest(parsedRequest, variableData || { variables: [] }, attempt ?? 0);
         if (typeof response.message === 'string') {
-            model.acceptResponseProgress(request, { content: response.message, kind: 'content' });
+            model.acceptResponseProgress(request, { content: ( (new MarkdownString(response.message))), kind: 'markdownContent' });
         }
         else {
             for (const part of response.message) {
@@ -531,52 +516,25 @@ let ChatService = class ChatService extends Disposable {
         this.trace('clearSession', `sessionId: ${sessionId}`);
         const model = this._sessionModels.get(sessionId);
         if (!model) {
-            throw new Error(`Unknown session: ${sessionId}`);
+            throw ( (new Error(`Unknown session: ${sessionId}`)));
         }
-        if (!model.providerId.startsWith('inlinechat')) {
+        if (model.initialLocation === ChatAgentLocation.Panel) {
             this._persistedSessions[sessionId] = model.toJSON();
         }
         this._sessionModels.deleteAndDispose(sessionId);
         this._pendingRequests.get(sessionId)?.cancel();
         this._pendingRequests.deleteAndDispose(sessionId);
-        this._onDidDisposeSession.fire({ sessionId, providerId: model.providerId, reason: 'cleared' });
-    }
-    registerProvider(provider) {
-        this.trace('registerProvider', `Adding new chat provider`);
-        if (( this._providers.has(provider.id))) {
-            throw new Error(`Provider ${provider.id} already registered`);
-        }
-        this._providers.set(provider.id, provider);
-        this._hasProvider.set(true);
-        this._onDidRegisterProvider.fire({ providerId: provider.id });
-        Array.from(( this._sessionModels.values()))
-            .filter(model => model.providerId === provider.id)
-            .filter(model => model.initState === ChatModelInitState.Created)
-            .forEach(model => this.reinitializeModel(model));
-        return toDisposable(() => {
-            this.trace('registerProvider', `Disposing chat provider`);
-            this._providers.delete(provider.id);
-            this._hasProvider.set(this._providers.size > 0);
-            Array.from(( this._sessionModels.values()))
-                .filter(model => model.providerId === provider.id)
-                .forEach(model => model.deinitialize());
-            this._onDidUnregisterProvider.fire({ providerId: provider.id });
-        });
-    }
-    hasSessions(providerId) {
-        return !!( Object.values(this._persistedSessions)).find((session) => session.providerId === providerId);
+        this._onDidDisposeSession.fire({ sessionId, reason: 'cleared' });
     }
-    getProviderInfos() {
-        return ( Array.from(( this._providers.values())).map(provider => {
-            return {
-                id: provider.id,
-            };
-        }));
+    hasSessions() {
+        return !!( (Object.values(this._persistedSessions)));
     }
     transferChatSession(transferredSessionData, toWorkspace) {
-        const model = Iterable.find(( this._sessionModels.values()), model => model.sessionId === transferredSessionData.sessionId);
+        const model = Iterable.find(( (this._sessionModels.values())), model => model.sessionId === transferredSessionData.sessionId);
         if (!model) {
-            throw new Error(`Failed to transfer session. Unknown session ID: ${transferredSessionData.sessionId}`);
+            throw ( (new Error(
+                `Failed to transfer session. Unknown session ID: ${transferredSessionData.sessionId}`
+            )));
         }
         const existingRaw = this.storageService.getObject(globalChatKey, 0 , []);
         existingRaw.push({
@@ -586,22 +544,21 @@ let ChatService = class ChatService extends Disposable {
             inputValue: transferredSessionData.inputValue,
         });
         this.storageService.store(globalChatKey, JSON.stringify(existingRaw), 0 , 1 );
-        this.trace('transferChatSession', `Transferred session ${model.sessionId} to workspace ${( toWorkspace.toString())}`);
+        this.trace('transferChatSession', `Transferred session ${model.sessionId} to workspace ${( (toWorkspace.toString()))}`);
     }
 };
-ChatService = ( __decorate([
-    ( __param(0, IStorageService)),
-    ( __param(1, ILogService)),
-    ( __param(2, IExtensionService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, ITelemetryService)),
-    ( __param(5, IContextKeyService)),
-    ( __param(6, IWorkspaceContextService)),
-    ( __param(7, IChatSlashCommandService)),
-    ( __param(8, IChatVariablesService)),
-    ( __param(9, IChatAgentService)),
-    ( __param(10, INotificationService)),
-    ( __param(11, ICommandService))
-], ChatService));
+ChatService = ( (__decorate([
+    ( (__param(0, IStorageService))),
+    ( (__param(1, ILogService))),
+    ( (__param(2, IExtensionService))),
+    ( (__param(3, IInstantiationService))),
+    ( (__param(4, ITelemetryService))),
+    ( (__param(5, IWorkspaceContextService))),
+    ( (__param(6, IChatSlashCommandService))),
+    ( (__param(7, IChatVariablesService))),
+    ( (__param(8, IChatAgentService))),
+    ( (__param(9, INotificationService))),
+    ( (__param(10, ICommandService)))
+], ChatService)));
 
 export { ChatService };