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

package/vscode/src/vs/workbench/contrib/chat/browser/chatViewPane.js

@@ -4,6 +4,7 @@ import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
 import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView.service';
+import { IHoverService } from 'vscode/vscode/vs/platform/hover/browser/hover.service';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { ServiceCollection } from 'vscode/vscode/vs/platform/instantiation/common/serviceCollection';
 import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding.service';
@@ -29,54 +30,58 @@ import { SIDE_BAR_FOREGROUND } from 'vscode/vscode/vs/workbench/common/theme';
 import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views.service';
 import { ChatWidget } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatWidget';
 import { ChatAgentLocation } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
+import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
+import { CHAT_PROVIDER_ID } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParticipantContribTypes';
+import { ChatModelInitState } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatModel';
 import { IChatService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService.service';
 
 const CHAT_SIDEBAR_PANEL_ID = 'workbench.panel.chatSidebar';
 let ChatViewPane = class ChatViewPane extends ViewPane {
-    static { this.ID = 'workbench.panel.chat.view'; }
     get widget() { return this._widget; }
-    constructor(chatViewOptions, options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, storageService, chatService, logService) {
-        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
-        this.chatViewOptions = chatViewOptions;
+    constructor(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, hoverService, storageService, chatService, chatAgentService, logService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, hoverService);
         this.storageService = storageService;
         this.chatService = chatService;
+        this.chatAgentService = chatAgentService;
         this.logService = logService;
         this.modelDisposables = this._register(( new DisposableStore()));
         this.didProviderRegistrationFail = false;
         this.didUnregisterProvider = false;
-        this.memento = ( new Memento(
-            'interactive-session-view-' + this.chatViewOptions.providerId,
-            this.storageService
-        ));
+        this.memento = ( new Memento('interactive-session-view-' + CHAT_PROVIDER_ID, this.storageService));
         this.viewState = this.memento.getMemento(1 , 1 );
-        this._register(this.chatService.onDidRegisterProvider(({ providerId }) => {
-            if (providerId === this.chatViewOptions.providerId && !this._widget?.viewModel) {
-                const sessionId = this.getSessionId();
-                const model = sessionId ? this.chatService.getOrRestoreSession(sessionId) : undefined;
-                try {
-                    this._widget.setVisible(false);
-                    this.updateModel(model);
-                    this.didProviderRegistrationFail = false;
-                    this.didUnregisterProvider = false;
-                    this._onDidChangeViewWelcomeState.fire();
-                }
-                finally {
-                    this.widget.setVisible(true);
+        this._register(this.chatAgentService.onDidChangeAgents(() => {
+            if (this.chatAgentService.getDefaultAgent(ChatAgentLocation.Panel)) {
+                if (!this._widget?.viewModel) {
+                    const sessionId = this.getSessionId();
+                    const model = sessionId ? this.chatService.getOrRestoreSession(sessionId) : undefined;
+                    try {
+                        this._widget.setVisible(false);
+                        this.updateModel(model);
+                        this.didProviderRegistrationFail = false;
+                        this.didUnregisterProvider = false;
+                        this._onDidChangeViewWelcomeState.fire();
+                    }
+                    finally {
+                        this.widget.setVisible(true);
+                    }
                 }
             }
-        }));
-        this._register(this.chatService.onDidUnregisterProvider(({ providerId }) => {
-            if (providerId === this.chatViewOptions.providerId) {
+            else if (this._widget?.viewModel?.initState === ChatModelInitState.Initialized) {
                 this.didUnregisterProvider = true;
                 this._onDidChangeViewWelcomeState.fire();
             }
         }));
     }
+    getActionsContext() {
+        return {
+            chatView: this
+        };
+    }
     updateModel(model, viewState) {
         this.modelDisposables.clear();
         model = model ?? (this.chatService.transferredSessionData?.sessionId
             ? this.chatService.getOrRestoreSession(this.chatService.transferredSessionData.sessionId)
-            : this.chatService.startSession(this.chatViewOptions.providerId, CancellationToken.None));
+            : this.chatService.startSession(ChatAgentLocation.Panel, CancellationToken.None));
         if (!model) {
             throw ( new Error('Could not start chat session'));
         }
@@ -84,7 +89,7 @@ let ChatViewPane = class ChatViewPane extends ViewPane {
         this.viewState.sessionId = model.sessionId;
     }
     shouldShowWelcome() {
-        const noPersistedSessions = !this.chatService.hasSessions(this.chatViewOptions.providerId);
+        const noPersistedSessions = !this.chatService.hasSessions();
         return this.didUnregisterProvider || !this._widget?.viewModel && (noPersistedSessions || this.didProviderRegistrationFail);
     }
     getSessionId() {
@@ -102,10 +107,11 @@ let ChatViewPane = class ChatViewPane extends ViewPane {
         try {
             super.renderBody(parent);
             const scopedInstantiationService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.scopedContextKeyService])));
+            const locationBasedColors = this.getLocationBasedColors();
             this._widget = this._register(scopedInstantiationService.createInstance(ChatWidget, ChatAgentLocation.Panel, { viewId: this.id }, { supportsFileReferences: true }, {
                 listForeground: SIDE_BAR_FOREGROUND,
-                listBackground: this.getBackgroundColor(),
-                inputEditorBackground: this.getBackgroundColor(),
+                listBackground: locationBasedColors.background,
+                inputEditorBackground: locationBasedColors.background,
                 resultEditorBackground: editorBackground
             }));
             this._register(this.onDidChangeBodyVisibility(visible => {
@@ -115,7 +121,7 @@ let ChatViewPane = class ChatViewPane extends ViewPane {
             this._widget.render(parent);
             const sessionId = this.getSessionId();
             const disposeListener = sessionId ? this._register(this.chatService.onDidDisposeSession((e) => {
-                if (e.reason === 'initializationFailed' && e.providerId === this.chatViewOptions.providerId) {
+                if (e.reason === 'initializationFailed') {
                     this.didProviderRegistrationFail = true;
                     disposeListener?.dispose();
                     this._onDidChangeViewWelcomeState.fire();
@@ -132,7 +138,7 @@ let ChatViewPane = class ChatViewPane extends ViewPane {
     acceptInput(query) {
         this._widget.acceptInput(query);
     }
-    async clear() {
+    clear() {
         if (this.widget.viewModel) {
             this.chatService.clearSession(this.widget.viewModel.sessionId);
         }
@@ -168,18 +174,20 @@ let ChatViewPane = class ChatViewPane extends ViewPane {
     }
 };
 ChatViewPane = ( __decorate([
-    ( __param(2, IKeybindingService)),
-    ( __param(3, IContextMenuService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IContextKeyService)),
-    ( __param(6, IViewDescriptorService)),
-    ( __param(7, IInstantiationService)),
-    ( __param(8, IOpenerService)),
-    ( __param(9, IThemeService)),
-    ( __param(10, ITelemetryService)),
+    ( __param(1, IKeybindingService)),
+    ( __param(2, IContextMenuService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IViewDescriptorService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, IOpenerService)),
+    ( __param(8, IThemeService)),
+    ( __param(9, ITelemetryService)),
+    ( __param(10, IHoverService)),
     ( __param(11, IStorageService)),
     ( __param(12, IChatService)),
-    ( __param(13, ILogService))
+    ( __param(13, IChatAgentService)),
+    ( __param(14, ILogService))
 ], ChatViewPane));
 
 export { CHAT_SIDEBAR_PANEL_ID, ChatViewPane };

package/vscode/src/vs/workbench/contrib/chat/browser/contrib/chatInputEditorContrib.js

@@ -123,7 +123,7 @@ let InputEditorDecorations = class InputEditorDecorations extends Disposable {
                     },
                     renderOptions: {
                         after: {
-                            contentText: viewModel.inputPlaceholder ?? defaultAgent?.description ?? '',
+                            contentText: viewModel.inputPlaceholder || (defaultAgent?.description ?? ''),
                             color: this.getPlaceholderColor()
                         }
                     }
@@ -187,8 +187,8 @@ let InputEditorDecorations = class InputEditorDecorations extends Disposable {
         const textDecorations = [];
         if (agentPart) {
             const isDupe = !!this.chatAgentService.getAgents().find(other => other.name === agentPart.agent.name && other.id !== agentPart.agent.id);
-            const id = isDupe ? `(${agentPart.agent.id}) ` : '';
-            const agentHover = `${id}${agentPart.agent.description}`;
+            const publisher = isDupe ? `(${agentPart.agent.extensionPublisherDisplayName}) ` : '';
+            const agentHover = `${publisher}${agentPart.agent.description}`;
             textDecorations.push({ range: agentPart.editorRange, hoverMessage: ( (new MarkdownString(agentHover))) });
             if (agentSubcommandPart) {
                 textDecorations.push({ range: agentSubcommandPart.editorRange, hoverMessage: ( (new MarkdownString(agentSubcommandPart.command.description))) });
@@ -318,7 +318,7 @@ let AgentCompletions = class AgentCompletions extends Disposable {
                         const isDupe = !!agents.find(other => other.name === a.name && other.id !== a.id);
                         return {
                             label: isDupe ?
-                                { label: withAt, description: a.description, detail: ` (${a.id})` } :
+                                { label: withAt, description: a.description, detail: ` (${a.extensionPublisherDisplayName})` } :
                                 withAt,
                             insertText: `${withAt} `,
                             detail: a.description,
@@ -394,7 +394,7 @@ let AgentCompletions = class AgentCompletions extends Disposable {
                     const agentLabel = `${chatAgentLeader}${agent.name}`;
                     return {
                         label: isDupe ?
-                            { label: agentLabel, description: agent.description, detail: ` (${agent.id})` } :
+                            { label: agentLabel, description: agent.description, detail: ` (${agent.extensionPublisherDisplayName})` } :
                             agentLabel,
                         detail,
                         filterText: `${chatSubcommandLeader}${agent.name}`,

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';
@@ -42,33 +40,26 @@ 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.onDidPerformUserAction = this._onDidPerformUserAction.event;
         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);
         const sessionData = storageService.get(serializedChatKey, 1 , '');
         if (sessionData) {
             this._persistedSessions = this.deserializeChats(sessionData);
@@ -89,9 +80,12 @@ 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:'))
+            .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))))
@@ -110,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
             });
         }
@@ -130,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}`);
@@ -218,42 +212,27 @@ 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}`)));
-            }
-            let session;
-            try {
-                session = (await provider.prepareSession(token)) ?? undefined;
+            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')));
             }
-            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,
@@ -270,27 +249,24 @@ let ChatService = class ChatService extends Disposable {
                         ]
                     }
                 });
-                throw ( (new ErrorNoTelemetry('No default agent')));
+                throw ( (new ErrorNoTelemetry('No default agent registered')));
             }
-            const welcomeMessage = model.welcomeMessage ? undefined : (await defaultAgent.provideWelcomeMessage?.(token)) ?? undefined;
+            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?.(token)) ?? []);
-            model.initialize(session, welcomeModel);
+            ))), (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);
@@ -304,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 sendRequest(sessionId, request, implicitVariablesEnabled, location = ChatAgentLocation.Panel, parserContext) {
+    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, options) {
         this.trace('sendRequest', `sessionId: ${sessionId}, message: ${request.substring(0, 20)}${request.length > 20 ? '[...]' : ''}}`);
         if (!request.trim()) {
             this.trace('sendRequest', 'Rejected empty message');
@@ -320,20 +314,19 @@ let ChatService = class ChatService extends Disposable {
             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)))) {
             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,
         };
@@ -344,7 +337,7 @@ let ChatService = class ChatService extends Disposable {
         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);
@@ -360,8 +353,8 @@ 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)}`);
@@ -372,7 +365,6 @@ let ChatService = class ChatService extends Disposable {
             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',
@@ -389,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);
@@ -412,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);
@@ -419,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) {
@@ -451,7 +445,6 @@ let ChatService = class ChatService extends Disposable {
                             rawResult.errorDetails ? 'error' :
                                 'success';
                     this.telemetryService.publicLog2('interactiveSessionProviderInvoked', {
-                        providerId: provider.id,
                         timeToFirstProgress: rawResult.timings?.firstProgress,
                         totalTime: rawResult.timings?.totalElapsed,
                         result,
@@ -487,16 +480,9 @@ let ChatService = class ChatService extends Disposable {
             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) {
@@ -506,9 +492,9 @@ let ChatService = class ChatService extends Disposable {
         const parsedRequest = typeof message === 'string' ?
             this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(sessionId, message) :
             message;
-        const request = model.addRequest(parsedRequest, variableData || { variables: [] });
+        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) {
@@ -532,47 +518,16 @@ let ChatService = class ChatService extends Disposable {
         if (!model) {
             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 });
-        });
+        this._onDidDisposeSession.fire({ sessionId, reason: 'cleared' });
     }
-    hasSessions(providerId) {
-        return !!( (Object.values(this._persistedSessions))).find((session) => session.providerId === providerId);
-    }
-    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);
@@ -598,13 +553,12 @@ ChatService = ( (__decorate([
     ( (__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)))
+    ( (__param(5, IWorkspaceContextService))),
+    ( (__param(6, IChatSlashCommandService))),
+    ( (__param(7, IChatVariablesService))),
+    ( (__param(8, IChatAgentService))),
+    ( (__param(9, INotificationService))),
+    ( (__param(10, ICommandService)))
 ], ChatService)));
 
 export { ChatService };