@codingame/monaco-vscode-chat-service-override 22.1.9 → 23.0.0

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

@@ -9,6 +9,7 @@ import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/comm
 import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
 import { Disposable, DisposableMap, DisposableStore, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { StopWatch } from '@codingame/monaco-vscode-api/vscode/vs/base/common/stopwatch';
 import { isDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
@@ -25,21 +26,22 @@ import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs
 import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { IMcpService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
 import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
-import { normalizeSerializableChatData, ChatModel, ChatRequestRemovalReason, updateRanges, toChatHistoryContent, ChatRequestModel } from '@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatModel';
-import { ChatRequestTextPart, ChatRequestAgentPart, ChatRequestAgentSubcommandPart, chatSubcommandLeader, chatAgentLeader, ChatRequestSlashCommandPart, getPromptText } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
-import { ChatRequestParser } from '@codingame/monaco-vscode-5084de40-f866-5cb5-9d9b-33a10f6f235d-common/vscode/vs/workbench/contrib/chat/common/chatRequestParser';
+import { normalizeSerializableChatData, ChatModel, ChatRequestRemovalReason, updateRanges, toChatHistoryContent, ChatRequestModel } from '@codingame/monaco-vscode-2339d6ac-d6bb-53cd-95ee-81911735d1c7-common/vscode/vs/workbench/contrib/chat/common/chatModel';
+import { ChatRequestTextPart, ChatRequestAgentPart, ChatRequestAgentSubcommandPart, chatSubcommandLeader, chatAgentLeader, ChatRequestSlashCommandPart, getPromptText } from '@codingame/monaco-vscode-aac7027b-326c-513a-95a9-e4eedd151b38-common/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+import { ChatRequestParser } from '@codingame/monaco-vscode-bc6f260d-ec63-5c95-9446-1ca7d0872719-common/vscode/vs/workbench/contrib/chat/common/chatRequestParser';
+import { ChatMcpServersStarting } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService';
 import { ChatServiceTelemetry, ChatRequestTelemetry } from './chatServiceTelemetry.js';
 import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
 import { ChatSessionStore } from './chatSessionStore.js';
 import { IChatSlashCommandService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSlashCommands.service';
 import { IChatTransferService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatTransferService.service';
-import { ChatSessionUri } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/common/chatUri';
+import { LocalChatSessionUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatUri';
 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/languageModelToolsService.service';
-import { ObservableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/map';
 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';
+import { ObservableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/map';
 
 const serializedChatKey = 'interactive.sessions';
 const TransferredGlobalChatKey = 'chat.workspaceTransfer';
@@ -63,6 +65,56 @@ let CancellableRequest = class CancellableRequest {
 CancellableRequest = ( __decorate([
     ( __param(2, ILanguageModelToolsService))
 ], CancellableRequest));
+class ChatModelStore {
+    constructor() {
+        this._models = ( new ObservableMap());
+    }
+    get observable() {
+        return this._models.observable;
+    }
+    values() {
+        return ( this._models.values());
+    }
+    get(uri) {
+        return this._models.get(this.toKey(uri));
+    }
+    has(uri) {
+        return ( this._models.has(this.toKey(uri)));
+    }
+    set(uri, value) {
+        this._models.set(this.toKey(uri), value);
+    }
+    delete(uri) {
+        return this._models.delete(this.toKey(uri));
+    }
+    toKey(uri) {
+        return ( uri.toString());
+    }
+}
+class DisposableResourceMap extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._map = this._register(( new DisposableMap()));
+    }
+    get(sessionResource) {
+        return this._map.get(this.toKey(sessionResource));
+    }
+    set(sessionResource, value) {
+        this._map.set(this.toKey(sessionResource), value);
+    }
+    has(sessionResource) {
+        return ( this._map.has(this.toKey(sessionResource)));
+    }
+    deleteAndLeak(sessionResource) {
+        return this._map.deleteAndLeak(this.toKey(sessionResource));
+    }
+    deleteAndDispose(sessionResource) {
+        this._map.deleteAndDispose(this.toKey(sessionResource));
+    }
+    toKey(uri) {
+        return ( uri.toString());
+    }
+}
 let ChatService = class ChatService extends Disposable {
     get transferredSessionData() {
         return this._transferredSessionData;
@@ -87,18 +139,16 @@ let ChatService = class ChatService extends Disposable {
         this.chatTransferService = chatTransferService;
         this.chatSessionService = chatSessionService;
         this.mcpService = mcpService;
-        this._sessionModels = ( new ObservableMap());
-        this._contentProviderSessionModels = ( new Map());
-        this._modelToExternalSession = ( new Map());
-        this._pendingRequests = this._register(( new DisposableMap()));
+        this._sessionModels = ( new ChatModelStore());
+        this._contentProviderSessionModels = this._register(( new DisposableResourceMap()));
+        this._pendingRequests = this._register(( new DisposableResourceMap()));
         this._onDidSubmitRequest = this._register(( new Emitter()));
         this.onDidSubmitRequest = this._onDidSubmitRequest.event;
         this._onDidPerformUserAction = this._register(( new Emitter()));
         this.onDidPerformUserAction = this._onDidPerformUserAction.event;
         this._onDidDisposeSession = this._register(( new Emitter()));
         this.onDidDisposeSession = this._onDidDisposeSession.event;
-        this._sessionFollowupCancelTokens = this._register(( new DisposableMap()));
-        this._mcpServersInteractionMessageShown = ( new WeakSet());
+        this._sessionFollowupCancelTokens = this._register(( new DisposableResourceMap()));
         this._chatServiceTelemetry = this.instantiationService.createInstance(ChatServiceTelemetry);
         const sessionData = storageService.get(serializedChatKey, this.isEmptyWindow ? StorageScope.APPLICATION : StorageScope.WORKSPACE, '');
         if (sessionData) {
@@ -140,21 +190,27 @@ let ChatService = class ChatService extends Disposable {
     }
     saveState() {
         const liveChats = Array.from(( this._sessionModels.values()))
-            .filter(session => !session.inputType && (session.initialLocation === ChatAgentLocation.Chat || session.initialLocation === ChatAgentLocation.EditorInline));
+            .filter(session => {
+            if (!LocalChatSessionUri.parseLocalSessionId(session.sessionResource)) {
+                return false;
+            }
+            return session.initialLocation === ChatAgentLocation.Chat;
+        });
         this._chatSessionStore.storeSessions(liveChats);
     }
     notifyUserAction(action) {
         this._chatServiceTelemetry.notifyUserAction(action);
         this._onDidPerformUserAction.fire(action);
         if (action.action.kind === 'chatEditingSessionAction') {
-            const model = this._sessionModels.get(action.sessionId);
+            const model = this._sessionModels.get(action.sessionResource);
             if (model) {
                 model.notifyEditingAction(action.action);
             }
         }
     }
-    async setChatSessionTitle(sessionId, title) {
-        const model = this._sessionModels.get(sessionId);
+    async setChatSessionTitle(sessionResource, title) {
+        const sessionId = this.toLocalSessionId(sessionResource);
+        const model = this._sessionModels.get(sessionResource);
         if (model) {
             model.setCustomTitle(title);
         }
@@ -239,13 +295,13 @@ let ChatService = class ChatService extends Disposable {
             }
         }
     }
-    async getHistory() {
+    async getLocalSessionHistory() {
         const liveSessionItems = ( Array.from(( this._sessionModels.values()))
-            .filter(session => !session.isImported && !session.inputType)
-            .map(session => {
-            const title = session.title || ( localize(5599, "New Chat"));
+            .filter(session => this.shouldBeInHistory(session))
+            .map((session) => {
+            const title = session.title || ( localize(5803, "New Chat"));
             return {
-                sessionId: session.sessionId,
+                sessionResource: session.sessionResource,
                 title,
                 lastMessageDate: session.lastMessageDate,
                 isActive: true,
@@ -253,29 +309,39 @@ let ChatService = class ChatService extends Disposable {
         }));
         const index = await this._chatSessionStore.getIndex();
         const entries = ( ( Object.values(index))
-            .filter(entry => !( this._sessionModels.has(entry.sessionId)) && !entry.isImported && !entry.isEmpty)
-            .map((entry) => ({
-            ...entry,
-            isActive: ( this._sessionModels.has(entry.sessionId)),
-        })));
+            .filter(entry => !( this._sessionModels.has(LocalChatSessionUri.forSession(entry.sessionId))) && this.shouldBeInHistory(entry) && !entry.isEmpty)
+            .map((entry) => {
+            const sessionResource = LocalChatSessionUri.forSession(entry.sessionId);
+            return ({
+                ...entry,
+                sessionResource,
+                isActive: ( this._sessionModels.has(sessionResource))
+            });
+        }));
         return [...liveSessionItems, ...entries];
     }
-    async removeHistoryEntry(sessionId) {
-        await this._chatSessionStore.deleteSession(sessionId);
+    shouldBeInHistory(entry) {
+        if (entry.sessionResource) {
+            return !entry.isImported && LocalChatSessionUri.parseLocalSessionId(entry.sessionResource) && entry.initialLocation !== ChatAgentLocation.EditorInline;
+        }
+        return !entry.isImported && entry.initialLocation !== ChatAgentLocation.EditorInline;
+    }
+    async removeHistoryEntry(sessionResource) {
+        await this._chatSessionStore.deleteSession(this.toLocalSessionId(sessionResource));
     }
     async clearAllHistoryEntries() {
         await this._chatSessionStore.clearAllSessions();
     }
-    startSession(location, token, isGlobalEditingSession = true, inputType) {
+    startSession(location, token, isGlobalEditingSession = true, options) {
         this.trace('startSession');
-        return this._startSession(undefined, location, isGlobalEditingSession, token, inputType);
+        return this._startSession(undefined, location, isGlobalEditingSession, token, options);
     }
-    _startSession(someSessionHistory, location, isGlobalEditingSession, token, inputType) {
-        const model = this.instantiationService.createInstance(ChatModel, someSessionHistory, { initialLocation: location, inputType });
+    _startSession(someSessionHistory, location, isGlobalEditingSession, token, options, transferEditingSession) {
+        const model = this.instantiationService.createInstance(ChatModel, someSessionHistory, { initialLocation: location, canUseTools: options?.canUseTools ?? true, resource: options?.sessionResource });
         if (location === ChatAgentLocation.Chat) {
-            model.startEditingSession(isGlobalEditingSession);
+            model.startEditingSession(isGlobalEditingSession, transferEditingSession);
         }
-        this._sessionModels.set(model.sessionId, model);
+        this._sessionModels.set(model.sessionResource, model);
         this.initializeSession(model, token);
         return model;
     }
@@ -301,15 +367,22 @@ let ChatService = class ChatService extends Disposable {
             throw ( new ErrorNoTelemetry('No default agent registered'));
         }
     }
-    getSession(sessionId) {
-        return this._sessionModels.get(sessionId);
+    getSession(sessionResource) {
+        return this._sessionModels.get(sessionResource);
     }
-    async getOrRestoreSession(sessionId) {
-        this.trace('getOrRestoreSession', `sessionId: ${sessionId}`);
-        const model = this._sessionModels.get(sessionId);
+    getSessionByLegacyId(sessionId) {
+        return Array.from(( this._sessionModels.values())).find(session => session.sessionId === sessionId);
+    }
+    async getOrRestoreSession(sessionResource) {
+        this.trace('getOrRestoreSession', `${sessionResource}`);
+        const model = this._sessionModels.get(sessionResource);
         if (model) {
             return model;
         }
+        const sessionId = LocalChatSessionUri.parseLocalSessionId(sessionResource);
+        if (!sessionId) {
+            throw ( new Error(`Cannot restore non-local session ${sessionResource}`));
+        }
         let sessionData;
         if (this.transferredSessionData?.sessionId === sessionId) {
             sessionData = revive(this._persistedSessions[sessionId]);
@@ -320,21 +393,29 @@ let ChatService = class ChatService extends Disposable {
         if (!sessionData) {
             return undefined;
         }
-        const session = this._startSession(sessionData, sessionData.initialLocation ?? ChatAgentLocation.Chat, true, CancellationToken.None);
+        const session = this._startSession(sessionData, sessionData.initialLocation ?? ChatAgentLocation.Chat, true, CancellationToken.None, { canUseTools: true, sessionResource });
         const isTransferred = this.transferredSessionData?.sessionId === sessionId;
         if (isTransferred) {
             this._transferredSessionData = undefined;
         }
         return session;
     }
-    isPersistedSessionEmpty(sessionId) {
+    isPersistedSessionEmpty(sessionResource) {
+        const sessionId = LocalChatSessionUri.parseLocalSessionId(sessionResource);
+        if (!sessionId) {
+            throw ( new Error(`Cannot restore non-local session ${sessionResource}`));
+        }
         const session = this._persistedSessions[sessionId];
         if (session) {
             return session.requests.length === 0;
         }
         return this._chatSessionStore.isSessionEmpty(sessionId);
     }
-    getPersistedSessionTitle(sessionId) {
+    getPersistedSessionTitle(sessionResource) {
+        const sessionId = LocalChatSessionUri.parseLocalSessionId(sessionResource);
+        if (!sessionId) {
+            return undefined;
+        }
         const session = this._persistedSessions[sessionId];
         if (session) {
             const title = session.customTitle || ChatModel.getDefaultTitle(session.requests);
@@ -353,34 +434,30 @@ let ChatService = class ChatService extends Disposable {
     loadSessionFromContent(data) {
         return this._startSession(data, data.initialLocation ?? ChatAgentLocation.Chat, true, CancellationToken.None);
     }
-    async loadSessionForResource(resource, location, token) {
-        const parsed = ChatSessionUri.parse(resource);
-        if (!parsed) {
-            throw ( new Error('Invalid chat session URI'));
+    async loadSessionForResource(chatSessionResource, location, token) {
+        if (chatSessionResource.scheme === Schemas.vscodeLocalChatSession) {
+            return this.getOrRestoreSession(chatSessionResource);
         }
-        const existing = this._contentProviderSessionModels.get(parsed.chatSessionType)?.get(parsed.sessionId);
+        const existing = this._contentProviderSessionModels.get(chatSessionResource);
         if (existing) {
             return existing.model;
         }
-        if (parsed.chatSessionType === 'local') {
-            return this.getOrRestoreSession(parsed.sessionId);
-        }
-        const chatSessionType = parsed.chatSessionType;
-        const content = await this.chatSessionService.provideChatSessionContent(chatSessionType, parsed.sessionId, CancellationToken.None);
-        const model = this._startSession(undefined, location, true, CancellationToken.None, chatSessionType);
-        this._modelToExternalSession.set(model.sessionId, { chatSessionType, chatSessionId: parsed.sessionId });
-        if (!( this._contentProviderSessionModels.has(chatSessionType))) {
-            this._contentProviderSessionModels.set(chatSessionType, ( new Map()));
-        }
+        const providedSession = await this.chatSessionService.getOrCreateChatSession(chatSessionResource, CancellationToken.None);
+        const chatSessionType = chatSessionResource.scheme;
+        const model = this._startSession(undefined, location, true, CancellationToken.None, { sessionResource: chatSessionResource, canUseTools: false }, providedSession.initialEditingSession);
+        model.setContributedChatSession({
+            chatSessionResource,
+            chatSessionType,
+            isUntitled: chatSessionResource.path.startsWith('/untitled-')
+        });
         const disposables = ( new DisposableStore());
-        this._contentProviderSessionModels.get(chatSessionType).set(parsed.sessionId, { model, disposables });
+        this._contentProviderSessionModels.set(chatSessionResource, { model, dispose: () => disposables.dispose() });
         disposables.add(model.onDidDispose(() => {
-            this._contentProviderSessionModels?.get(chatSessionType)?.delete(parsed.sessionId);
-            this._modelToExternalSession.delete(model.sessionId);
-            content.dispose();
+            this._contentProviderSessionModels.deleteAndDispose(chatSessionResource);
+            providedSession.dispose();
         }));
         let lastRequest;
-        for (const message of content.history) {
+        for (const message of providedSession.history) {
             if (message.type === 'request') {
                 if (lastRequest) {
                     model.completeResponse(lastRequest);
@@ -393,8 +470,7 @@ let ChatService = class ChatService extends Disposable {
                 const agent = message.participant
                     ? this.chatAgentService.getAgent(message.participant)
                     : this.chatAgentService.getAgent(chatSessionType);
-                lastRequest = model.addRequest(parsedRequest, { variables: [] },
-                0,
+                lastRequest = model.addRequest(parsedRequest, message.variableData ?? { variables: [] }, 0,
                 undefined, agent, undefined,
                 undefined,
                 undefined,
@@ -410,27 +486,26 @@ let ChatService = class ChatService extends Disposable {
                 }
             }
         }
-        if (content.progressObs && lastRequest && content.interruptActiveResponseCallback) {
+        if (providedSession.progressObs && lastRequest && providedSession.interruptActiveResponseCallback) {
             const initialCancellationRequest = this.instantiationService.createInstance(CancellableRequest, ( new CancellationTokenSource()), undefined);
-            this._pendingRequests.set(model.sessionId, initialCancellationRequest);
-            const cancellationListener = ( new MutableDisposable());
+            this._pendingRequests.set(model.sessionResource, initialCancellationRequest);
+            const cancellationListener = disposables.add(( new MutableDisposable()));
             const createCancellationListener = (token) => {
                 return token.onCancellationRequested(() => {
-                    content.interruptActiveResponseCallback?.().then(userConfirmedInterruption => {
+                    providedSession.interruptActiveResponseCallback?.().then(userConfirmedInterruption => {
                         if (!userConfirmedInterruption) {
                             const newCancellationRequest = this.instantiationService.createInstance(CancellableRequest, ( new CancellationTokenSource()), undefined);
-                            this._pendingRequests.set(model.sessionId, newCancellationRequest);
+                            this._pendingRequests.set(model.sessionResource, newCancellationRequest);
                             cancellationListener.value = createCancellationListener(newCancellationRequest.cancellationTokenSource.token);
                         }
                     });
                 });
             };
             cancellationListener.value = createCancellationListener(initialCancellationRequest.cancellationTokenSource.token);
-            disposables.add(cancellationListener);
             let lastProgressLength = 0;
             disposables.add(autorun(reader => {
-                const progressArray = content.progressObs?.read(reader) ?? [];
-                const isComplete = content.isCompleteObs?.read(reader) ?? false;
+                const progressArray = providedSession.progressObs?.read(reader) ?? [];
+                const isComplete = providedSession.isCompleteObs?.read(reader) ?? false;
                 if (progressArray.length > lastProgressLength) {
                     const newProgress = progressArray.slice(lastProgressLength);
                     for (const progress of newProgress) {
@@ -451,24 +526,22 @@ let ChatService = class ChatService extends Disposable {
         }
         return model;
     }
-    getChatSessionFromInternalId(modelSessionId) {
-        const data = this._modelToExternalSession.get(modelSessionId);
-        if (!data) {
+    getChatSessionFromInternalUri(sessionResource) {
+        const model = this._sessionModels.get(sessionResource);
+        if (!model) {
             return;
         }
-        return {
-            ...data,
-            isUntitled: data.chatSessionId.startsWith('untitled-'),
-        };
+        const { contributedChatSession } = model;
+        return contributedChatSession;
     }
     async resendRequest(request, options) {
-        const model = this._sessionModels.get(request.session.sessionId);
+        const model = this._sessionModels.get(request.session.sessionResource);
         if (!model && model !== request.session) {
-            throw ( new Error(`Unknown session: ${request.session.sessionId}`));
+            throw ( new Error(`Unknown session: ${request.session.sessionResource}`));
         }
-        const cts = this._pendingRequests.get(request.session.sessionId);
+        const cts = this._pendingRequests.get(request.session.sessionResource);
         if (cts) {
-            this.trace('resendRequest', `Session ${request.session.sessionId} 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;
@@ -481,20 +554,20 @@ let ChatService = class ChatService extends Disposable {
             locationData: request.locationData,
             attachedContext: request.attachedContext,
         };
-        await this._sendRequestAsync(model, model.sessionId, request.message, attempt, enableCommandDetection, defaultAgent, location, resendOptions).responseCompletePromise;
+        await this._sendRequestAsync(model, model.sessionResource, request.message, attempt, enableCommandDetection, defaultAgent, location, resendOptions).responseCompletePromise;
     }
-    async sendRequest(sessionId, request, options) {
-        this.trace('sendRequest', `sessionId: ${sessionId}, message: ${request.substring(0, 20)}${request.length > 20 ? '[...]' : ''}}`);
+    async sendRequest(sessionResource, request, options) {
+        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');
             return;
         }
-        const model = this._sessionModels.get(sessionId);
+        const model = this._sessionModels.get(sessionResource);
         if (!model) {
-            throw ( new Error(`Unknown session: ${sessionId}`));
+            throw ( new Error(`Unknown session: ${sessionResource}`));
         }
-        if (( this._pendingRequests.has(sessionId))) {
-            this.trace('sendRequest', `Session ${sessionId} already has a pending request`);
+        if (( this._pendingRequests.has(sessionResource))) {
+            this.trace('sendRequest', `Session ${sessionResource} already has a pending request`);
             return;
         }
         const requests = model.getRequests();
@@ -505,24 +578,24 @@ let ChatService = class ChatService extends Disposable {
                     request.response?.finalizeUndoState();
                 }
                 else {
-                    await this.removeRequest(sessionId, request.id);
+                    await this.removeRequest(sessionResource, request.id);
                 }
             }
         }
         const location = options?.location ?? model.initialLocation;
         const attempt = options?.attempt ?? 0;
         const defaultAgent = this.chatAgentService.getDefaultAgent(location, options?.modeInfo?.kind);
-        const parsedRequest = this.parseChatRequest(sessionId, request, location, options);
+        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);
         return {
-            ...this._sendRequestAsync(model, sessionId, parsedRequest, attempt, !options?.noCommandDetection, silentAgent ?? defaultAgent, location, options),
+            ...this._sendRequestAsync(model, sessionResource, parsedRequest, attempt, !options?.noCommandDetection, silentAgent ?? defaultAgent, location, options),
             agent,
             slashCommand: agentSlashCommandPart?.command,
         };
     }
-    parseChatRequest(sessionId, request, location, options) {
+    parseChatRequest(sessionResource, request, location, options) {
         let parserContext = options?.parserContext;
         if (options?.agentId) {
             const agent = this.chatAgentService.getAgent(options.agentId);
@@ -533,24 +606,24 @@ let ChatService = class ChatService extends Disposable {
             const commandPart = options.slashCommand ? ` ${chatSubcommandLeader}${options.slashCommand}` : '';
             request = `${chatAgentLeader}${agent.name}${commandPart} ${request}`;
         }
-        const parsedRequest = this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(sessionId, request, location, parserContext);
+        const parsedRequest = this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(sessionResource, request, location, parserContext);
         return parsedRequest;
     }
-    refreshFollowupsCancellationToken(sessionId) {
-        this._sessionFollowupCancelTokens.get(sessionId)?.cancel();
+    refreshFollowupsCancellationToken(sessionResource) {
+        this._sessionFollowupCancelTokens.get(sessionResource)?.cancel();
         const newTokenSource = ( new CancellationTokenSource());
-        this._sessionFollowupCancelTokens.set(sessionId, newTokenSource);
+        this._sessionFollowupCancelTokens.set(sessionResource, newTokenSource);
         return newTokenSource.token;
     }
-    _sendRequestAsync(model, sessionId, parsedRequest, attempt, enableCommandDetection, defaultAgent, location, options) {
-        const followupsCancelToken = this.refreshFollowupsCancellationToken(sessionId);
+    _sendRequestAsync(model, sessionResource, parsedRequest, attempt, enableCommandDetection, defaultAgent, location, options) {
+        const followupsCancelToken = this.refreshFollowupsCancellationToken(sessionResource);
         let request;
         const agentPart = 'kind' in parsedRequest ? undefined : parsedRequest.parts.find((r) => r instanceof ChatRequestAgentPart);
         const agentSlashCommandPart = 'kind' in parsedRequest ? undefined : parsedRequest.parts.find((r) => r instanceof ChatRequestAgentSubcommandPart);
         const commandPart = 'kind' in parsedRequest ? undefined : parsedRequest.parts.find((r) => r instanceof ChatRequestSlashCommandPart);
         const requests = [...model.getRequests()];
         const requestTelemetry = this.instantiationService.createInstance(ChatRequestTelemetry, {
-            agentPart,
+            agent: agentPart?.agent ?? defaultAgent,
             agentSlashCommandPart,
             commandPart,
             sessionId: model.sessionId,
@@ -615,7 +688,7 @@ let ChatService = class ChatService extends Disposable {
                 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);
+                        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) {
@@ -629,19 +702,8 @@ let ChatService = class ChatService extends Disposable {
                             variableData = updateRanges(variableData, promptTextResult.diff);
                             message = promptTextResult.message;
                         }
-                        let isInitialTools = true;
-                        store.add(autorun(reader => {
-                            const tools = options?.userSelectedTools?.read(reader);
-                            if (isInitialTools) {
-                                isInitialTools = false;
-                                return;
-                            }
-                            if (tools) {
-                                this.chatAgentService.setRequestTools(agent.id, request.id, tools);
-                            }
-                        }));
-                        return {
-                            sessionId,
+                        const agentRequest = {
+                            sessionId: model.sessionId,
                             requestId: request.id,
                             agentId: agent.id,
                             message,
@@ -657,8 +719,22 @@ let ChatService = class ChatService extends Disposable {
                             userSelectedModelId: options?.userSelectedModelId,
                             userSelectedTools: options?.userSelectedTools?.get(),
                             modeInstructions: options?.modeInfo?.modeInstructions,
-                            editedFileEvents: request.editedFileEvents
+                            editedFileEvents: request.editedFileEvents,
+                            chatSummary: options?.chatSummary
                         };
+                        let isInitialTools = true;
+                        store.add(autorun(reader => {
+                            const tools = options?.userSelectedTools?.read(reader);
+                            if (isInitialTools) {
+                                isInitialTools = false;
+                                return;
+                            }
+                            if (tools) {
+                                this.chatAgentService.setRequestTools(agent.id, request.id, tools);
+                                agentRequest.userSelectedTools = tools;
+                            }
+                        }));
+                        return agentRequest;
                     };
                     if (this.configurationService.getValue('chat.detectParticipant.enabled') !== false &&
                         this.chatAgentService.hasChatParticipantDetectionProviders() &&
@@ -680,33 +756,36 @@ let ChatService = class ChatService extends Disposable {
                     }
                     const agent = (detectedAgent ?? agentPart?.agent ?? defaultAgent);
                     const command = detectedCommand ?? agentSlashCommandPart?.command;
-                    const [, autostartResult] = await Promise.all([
-                        this.extensionService.activateByEvent(`onChatParticipant:${agent.id}`),
-                        this.mcpService.autostart(token),
-                    ]);
+                    await this.extensionService.activateByEvent(`onChatParticipant:${agent.id}`);
                     const history = this.getHistoryEntriesFromModel(requests, model.sessionId, location, agent.id);
                     const requestProps = prepareChatAgentRequest(agent, command, enableCommandDetection, request , !!detectedAgent);
-                    const pendingRequest = this._pendingRequests.get(sessionId);
+                    const pendingRequest = this._pendingRequests.get(sessionResource);
                     if (pendingRequest && !pendingRequest.requestId) {
                         pendingRequest.requestId = requestProps.requestId;
                     }
                     completeResponseCreated();
-                    if (!( this._mcpServersInteractionMessageShown.has(model)) && autostartResult.serversRequiringInteraction.length > 0) {
-                        this._mcpServersInteractionMessageShown.add(model);
-                        progressCallback([{
-                                kind: 'mcpServersInteractionRequired',
-                                servers: autostartResult.serversRequiringInteraction,
-                                startCommand: {
-                                    id: 'mcp.startServersWithInteraction',
-                                    title: ( localize(5600, 'Start MCP Servers')),
-                                    arguments: []
-                                }
-                            }]);
+                    if (model.canUseTools) {
+                        const autostartResult = ( new ChatMcpServersStarting(this.mcpService.autostart(token)));
+                        if (!autostartResult.isEmpty) {
+                            progressCallback([autostartResult]);
+                            await autostartResult.wait();
+                        }
                     }
                     const agentResult = await this.chatAgentService.invokeAgent(agent.id, requestProps, progressCallback, history, token);
                     rawResult = agentResult;
                     agentOrCommandFollowups = this.chatAgentService.getFollowups(agent.id, requestProps, agentResult, history, followupsCancelToken);
-                    chatTitlePromise = model.getRequests().length === 1 && !model.customTitle ? this.chatAgentService.getChatTitle(defaultAgent.id, this.getHistoryEntriesFromModel(model.getRequests(), model.sessionId, location, agent.id), CancellationToken.None) : undefined;
+                    if (model.getRequests().length === 1 && !model.customTitle) {
+                        const chatHistory = this.getHistoryEntriesFromModel(model.getRequests(), model.sessionId, location, agent.id);
+                        chatTitlePromise = this.chatAgentService.getChatTitle(agent.id, chatHistory, CancellationToken.None).then((title) => {
+                            if (title === undefined) {
+                                const defaultAgentForTitle = this.chatAgentService.getDefaultAgent(location);
+                                if (defaultAgentForTitle) {
+                                    return this.chatAgentService.getChatTitle(defaultAgentForTitle.id, chatHistory, CancellationToken.None);
+                                }
+                            }
+                            return title;
+                        });
+                    }
                 }
                 else if (commandPart && this.chatSlashCommandService.hasCommand(commandPart.slashCommand.command)) {
                     if (commandPart.slashCommand.silent !== true) {
@@ -737,7 +816,7 @@ let ChatService = class ChatService extends Disposable {
                 else {
                     if (!rawResult) {
                         this.trace('sendRequest', `Provider returned no response for session ${model.sessionId}`);
-                        rawResult = { errorDetails: { message: ( localize(5601, "Provider returned null response")) } };
+                        rawResult = { errorDetails: { message: ( localize(5804, "Provider returned null response")) } };
                     }
                     const result = rawResult.errorDetails?.responseIsFiltered ? 'filtered' :
                         rawResult.errorDetails && gotProgress ? 'errorWithOutput' :
@@ -791,11 +870,11 @@ let ChatService = class ChatService extends Disposable {
             }
         };
         const rawResponsePromise = sendRequestInternal();
-        this._pendingRequests.set(model.sessionId, this.instantiationService.createInstance(CancellableRequest, source, undefined));
+        this._pendingRequests.set(model.sessionResource, this.instantiationService.createInstance(CancellableRequest, source, undefined));
         rawResponsePromise.finally(() => {
-            this._pendingRequests.deleteAndDispose(model.sessionId);
+            this._pendingRequests.deleteAndDispose(model.sessionResource);
         });
-        this._onDidSubmitRequest.fire({ chatSessionId: model.sessionId });
+        this._onDidSubmitRequest.fire({ chatSessionResource: model.sessionResource });
         return {
             responseCreatedPromise: responseCreated.p,
             responseCompletePromise: rawResponsePromise,
@@ -827,6 +906,9 @@ let ChatService = class ChatService extends Disposable {
             if (forAgentId !== request.response.agent?.id && !agent?.isDefault) {
                 continue;
             }
+            if (location === ChatAgentLocation.EditorInline) {
+                continue;
+            }
             const promptTextResult = getPromptText(request.message);
             const historyRequest = {
                 sessionId: sessionId,
@@ -842,44 +924,44 @@ let ChatService = class ChatService extends Disposable {
         }
         return history;
     }
-    async removeRequest(sessionId, requestId) {
-        const model = this._sessionModels.get(sessionId);
+    async removeRequest(sessionResource, requestId) {
+        const model = this._sessionModels.get(sessionResource);
         if (!model) {
-            throw ( new Error(`Unknown session: ${sessionId}`));
+            throw ( new Error(`Unknown session: ${sessionResource}`));
         }
-        const pendingRequest = this._pendingRequests.get(sessionId);
+        const pendingRequest = this._pendingRequests.get(sessionResource);
         if (pendingRequest?.requestId === requestId) {
             pendingRequest.cancel();
-            this._pendingRequests.deleteAndDispose(sessionId);
+            this._pendingRequests.deleteAndDispose(sessionResource);
         }
         model.removeRequest(requestId);
     }
-    async adoptRequest(sessionId, request) {
+    async adoptRequest(sessionResource, request) {
         if (!(request instanceof ChatRequestModel)) {
             throw ( new TypeError('Can only adopt requests of type ChatRequestModel'));
         }
-        const target = this._sessionModels.get(sessionId);
+        const target = this._sessionModels.get(sessionResource);
         if (!target) {
-            throw ( new Error(`Unknown session: ${sessionId}`));
+            throw ( new Error(`Unknown session: ${sessionResource}`));
         }
         const oldOwner = request.session;
         target.adoptRequest(request);
         if (request.response && !request.response.isComplete) {
-            const cts = this._pendingRequests.deleteAndLeak(oldOwner.sessionId);
+            const cts = this._pendingRequests.deleteAndLeak(oldOwner.sessionResource);
             if (cts) {
                 cts.requestId = request.id;
-                this._pendingRequests.set(target.sessionId, cts);
+                this._pendingRequests.set(target.sessionResource, cts);
             }
         }
     }
-    async addCompleteRequest(sessionId, message, variableData, attempt, response) {
+    async addCompleteRequest(sessionResource, message, variableData, attempt, response) {
         this.trace('addCompleteRequest', `message: ${message}`);
-        const model = this._sessionModels.get(sessionId);
+        const model = this._sessionModels.get(sessionResource);
         if (!model) {
-            throw ( new Error(`Unknown session: ${sessionId}`));
+            throw ( new Error(`Unknown session: ${sessionResource}`));
         }
         const parsedRequest = typeof message === 'string' ?
-            this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(sessionId, message) :
+            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') {
@@ -896,31 +978,31 @@ let ChatService = class ChatService extends Disposable {
         }
         model.completeResponse(request);
     }
-    cancelCurrentRequestForSession(sessionId) {
-        this.trace('cancelCurrentRequestForSession', `sessionId: ${sessionId}`);
-        this._pendingRequests.get(sessionId)?.cancel();
-        this._pendingRequests.deleteAndDispose(sessionId);
+    cancelCurrentRequestForSession(sessionResource) {
+        this.trace('cancelCurrentRequestForSession', `session: ${sessionResource}`);
+        this._pendingRequests.get(sessionResource)?.cancel();
+        this._pendingRequests.deleteAndDispose(sessionResource);
     }
-    async clearSession(sessionId) {
-        this.trace('clearSession', `sessionId: ${sessionId}`);
-        const model = this._sessionModels.get(sessionId);
+    async clearSession(sessionResource) {
+        this.trace('clearSession', `session: ${sessionResource}`);
+        const model = this._sessionModels.get(sessionResource);
         if (!model) {
-            throw ( new Error(`Unknown session: ${sessionId}`));
+            throw ( new Error(`Unknown session: ${sessionResource}`));
         }
-        this.trace(`Model input type: ${model.inputType}`);
-        if (!model.inputType && (model.initialLocation === ChatAgentLocation.Chat || model.initialLocation === ChatAgentLocation.EditorInline)) {
+        const localSessionId = LocalChatSessionUri.parseLocalSessionId(sessionResource);
+        if (localSessionId && (model.initialLocation === ChatAgentLocation.Chat)) {
             if (model.getRequests().length === 0 && !model.customTitle) {
-                await this._chatSessionStore.deleteSession(sessionId);
+                await this._chatSessionStore.deleteSession(localSessionId);
             }
             else {
                 await this._chatSessionStore.storeSessions([model]);
             }
         }
-        this._sessionModels.delete(sessionId);
+        this._sessionModels.delete(sessionResource);
         model.dispose();
-        this._pendingRequests.get(sessionId)?.cancel();
-        this._pendingRequests.deleteAndDispose(sessionId);
-        this._onDidDisposeSession.fire({ sessionId, reason: 'cleared' });
+        this._pendingRequests.get(sessionResource)?.cancel();
+        this._pendingRequests.deleteAndDispose(sessionResource);
+        this._onDidDisposeSession.fire({ sessionResource, reason: 'cleared' });
     }
     hasSessions() {
         return this._chatSessionStore.hasSessions();
@@ -951,6 +1033,13 @@ let ChatService = class ChatService extends Disposable {
     logChatIndex() {
         this._chatSessionStore.logIndex();
     }
+    toLocalSessionId(sessionResource) {
+        const localSessionId = LocalChatSessionUri.parseLocalSessionId(sessionResource);
+        if (!localSessionId) {
+            throw ( new Error(`Invalid local chat session resource: ${sessionResource}`));
+        }
+        return localSessionId;
+    }
 };
 ChatService = ( __decorate([
     ( __param(0, IStorageService)),