@codingame/monaco-vscode-chat-service-override 26.2.2 → 27.0.0

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

@@ -14,6 +14,7 @@ import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/in
 import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { StopWatch } from '@codingame/monaco-vscode-api/vscode/vs/base/common/stopwatch';
 import { isDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
 import { OffsetRange } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/ranges/offsetRange';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
@@ -23,8 +24,11 @@ import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log
 import { Progress } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress';
 import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
 import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
 import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+import { IChatDebugService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service';
 import { InlineChatConfigKeys } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
 import { IMcpService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
 import { awaitStatsForSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chat';
@@ -34,7 +38,7 @@ import { normalizeSerializableChatData, ChatModel, ChatRequestRemovalReason, Cha
 import { ChatModelStore } from '../model/chatModelStore.js';
 import { ChatRequestTextPart, ChatRequestAgentPart, ChatRequestAgentSubcommandPart, chatSubcommandLeader, chatAgentLeader, ChatRequestSlashCommandPart, getPromptText } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatParserTypes';
 import { ChatRequestParser } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatRequestParser';
-import { ResponseModelState, ChatRequestQueueKind, ChatMcpServersStarting } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+import { ResponseModelState, ChatPendingRequestChangeEventName, ChatRequestQueueKind, ChatMcpServersStarting, ChatStopCancellationNoopEventName } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/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 '../model/chatSessionStore.js';
@@ -43,6 +47,7 @@ import { IChatTransferService } from '@codingame/monaco-vscode-api/vscode/vs/wor
 import { LocalChatSessionUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/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 { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
 import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
 import { ChatSessionOperationLog } from '../model/chatSessionOperationLog.js';
 import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
@@ -62,6 +67,9 @@ let CancellableRequest = class CancellableRequest {
         this._yieldRequested = observableValue(this, false);
     }
     dispose() {
+        if (this.requestId) {
+            this.toolsService.cancelToolCallsForRequest(this.requestId);
+        }
         this.cancellationTokenSource.dispose();
     }
     cancel() {
@@ -73,6 +81,9 @@ let CancellableRequest = class CancellableRequest {
     setYieldRequested() {
         this._yieldRequested.set(true, undefined);
     }
+    resetYieldRequested() {
+        this._yieldRequested.set(false, undefined);
+    }
 };
 CancellableRequest = ( __decorate([( __param(2, ILanguageModelToolsService))], CancellableRequest));
 let ChatService = class ChatService extends Disposable {
@@ -98,6 +109,7 @@ let ChatService = class ChatService extends Disposable {
     constructor(
         storageService,
         logService,
+        telemetryService,
         extensionService,
         instantiationService,
         workspaceContextService,
@@ -107,11 +119,15 @@ let ChatService = class ChatService extends Disposable {
         chatTransferService,
         chatSessionService,
         mcpService,
-        promptsService
+        promptsService,
+        chatEntitlementService,
+        languageModelsService,
+        chatDebugService
     ) {
         super();
         this.storageService = storageService;
         this.logService = logService;
+        this.telemetryService = telemetryService;
         this.extensionService = extensionService;
         this.instantiationService = instantiationService;
         this.workspaceContextService = workspaceContextService;
@@ -122,6 +138,9 @@ let ChatService = class ChatService extends Disposable {
         this.chatSessionService = chatSessionService;
         this.mcpService = mcpService;
         this.promptsService = promptsService;
+        this.chatEntitlementService = chatEntitlementService;
+        this.languageModelsService = languageModelsService;
+        this.chatDebugService = chatDebugService;
         this._pendingRequests = this._register(( new DisposableResourceMap()));
         this._queuedRequestDeferreds = ( new Map());
         this._saveModelsEnabled = true;
@@ -150,6 +169,7 @@ let ChatService = class ChatService extends Disposable {
             }
         }));
         this._register(this._sessionModels.onDidDisposeModel(model => {
+            this.chatDebugService.endSession(model.sessionResource);
             this._onDidDisposeSession.fire({
                 sessionResource: [model.sessionResource],
                 reason: "cleared"
@@ -292,8 +312,14 @@ let ChatService = class ChatService extends Disposable {
             if (!session.hasPendingEdits) {
                 return;
             }
-            const sessionResource = LocalChatSessionUri.forSession(session.sessionId);
-            const sessionRef = await this.getOrRestoreSession(sessionResource);
+            let sessionResource;
+            if (session.sessionId.includes(":")) {
+                try {
+                    sessionResource = ( URI.parse(session.sessionId, true));
+                } catch {}
+            }
+            sessionResource ??= LocalChatSessionUri.forSession(session.sessionId);
+            const sessionRef = await this.acquireOrLoadSession(sessionResource, ChatAgentLocation.Chat, CancellationToken.None);
             if (sessionRef?.object.editingSession) {
                 await chatEditingSessionIsReady(sessionRef.object.editingSession);
                 sessionRef.dispose();
@@ -307,7 +333,7 @@ let ChatService = class ChatService extends Disposable {
     }
     async getLiveSessionItems() {
         return await Promise.all(( Array.from(( this._sessionModels.values())).filter(session => this.shouldBeInHistory(session)).map(async session => {
-            const title = session.title || ( localize(6317, "New Chat"));
+            const title = session.title || ( localize(6868, "New Chat"));
             return {
                 sessionResource: session.sessionResource,
                 title,
@@ -323,17 +349,10 @@ let ChatService = class ChatService extends Disposable {
         const index = await this._chatSessionStore.getIndex();
         return ( ( Object.values(index)).filter(entry => !entry.isExternal).filter(entry => !( this._sessionModels.has(LocalChatSessionUri.forSession(entry.sessionId))) && entry.initialLocation === ChatAgentLocation.Chat && !entry.isEmpty).map(entry => {
             const sessionResource = LocalChatSessionUri.forSession(entry.sessionId);
-            const lastResponseState = entry.lastResponseState ?? ResponseModelState.Complete;
             return ({
                 ...entry,
                 sessionResource,
-                timing: entry.timing ?? {
-                    created: entry.lastMessageDate,
-                    lastRequestStarted: undefined,
-                    lastRequestEnded: entry.lastMessageDate
-                },
-                isActive: ( this._sessionModels.has(sessionResource)),
-                lastResponseState: lastResponseState === ResponseModelState.Pending || lastResponseState === ResponseModelState.NeedsInput ? ResponseModelState.Complete : lastResponseState
+                isActive: ( this._sessionModels.has(sessionResource))
             });
         }));
     }
@@ -344,13 +363,7 @@ let ChatService = class ChatService extends Disposable {
             return {
                 ...metadata,
                 sessionResource,
-                timing: metadata.timing ?? {
-                    created: metadata.lastMessageDate,
-                    lastRequestStarted: undefined,
-                    lastRequestEnded: metadata.lastMessageDate
-                },
-                isActive: ( this._sessionModels.has(sessionResource)),
-                lastResponseState: metadata.lastResponseState ?? ResponseModelState.Complete
+                isActive: ( this._sessionModels.has(sessionResource))
             };
         }
         return undefined;
@@ -368,15 +381,13 @@ let ChatService = class ChatService extends Disposable {
     async clearAllHistoryEntries() {
         await this._chatSessionStore.clearAllSessions();
     }
-    startSession(location, options) {
-        this.trace("startSession");
-        const sessionId = generateUuid();
-        const sessionResource = LocalChatSessionUri.forSession(sessionId);
+    startNewLocalSession(location, options) {
+        this.trace("startNewLocalSession");
+        const sessionResource = LocalChatSessionUri.forSession(generateUuid());
         return this._sessionModels.acquireOrCreate({
             initialData: undefined,
             location,
             sessionResource,
-            sessionId,
             canUseTools: options?.canUseTools ?? true,
             disableBackgroundKeepAlive: options?.disableBackgroundKeepAlive
         });
@@ -386,7 +397,6 @@ let ChatService = class ChatService extends Disposable {
             initialData,
             location,
             sessionResource,
-            sessionId,
             canUseTools,
             transferEditingSession,
             disableBackgroundKeepAlive,
@@ -396,7 +406,6 @@ let ChatService = class ChatService extends Disposable {
             initialLocation: location,
             canUseTools,
             resource: sessionResource,
-            sessionId,
             disableBackgroundKeepAlive,
             inputState
         });
@@ -431,25 +440,24 @@ let ChatService = class ChatService extends Disposable {
     getSession(sessionResource) {
         return this._sessionModels.get(sessionResource);
     }
-    getActiveSessionReference(sessionResource) {
+    acquireExistingSession(sessionResource) {
         return this._sessionModels.acquireExisting(sessionResource);
     }
-    async getOrRestoreSession(sessionResource) {
-        this.trace("getOrRestoreSession", `${sessionResource}`);
-        const existingRef = this._sessionModels.acquireExisting(sessionResource);
+    async acquireOrRestoreLocalSession(sessionResource) {
+        this.trace("acquireOrRestoreSession", `${sessionResource}`);
+        const existingRef = this.acquireExistingSession(sessionResource);
         if (existingRef) {
             return existingRef;
         }
-        const sessionId = LocalChatSessionUri.parseLocalSessionId(sessionResource);
-        if (!sessionId) {
-            throw ( new Error(`Cannot restore non-local session ${sessionResource}`));
-        }
         let sessionData;
         if (isEqual(this.transferredSessionResource, sessionResource)) {
             this._transferredSessionResource = undefined;
             sessionData = await this._chatSessionStore.readTransferredSession(sessionResource);
         } else {
-            sessionData = await this._chatSessionStore.readSession(sessionId);
+            const localSessionId = LocalChatSessionUri.parseLocalSessionId(sessionResource);
+            if (localSessionId) {
+                sessionData = await this._chatSessionStore.readSession(localSessionId);
+            }
         }
         if (!sessionData) {
             return undefined;
@@ -458,7 +466,6 @@ let ChatService = class ChatService extends Disposable {
             initialData: sessionData,
             location: sessionData.value.initialLocation ?? ChatAgentLocation.Chat,
             sessionResource,
-            sessionId,
             canUseTools: true
         });
         return sessionRef;
@@ -470,7 +477,7 @@ let ChatService = class ChatService extends Disposable {
         }
         return this._sessionModels.get(sessionResource)?.title ?? this._chatSessionStore.getMetadataForSessionSync(sessionResource)?.title;
     }
-    loadSessionFromContent(data) {
+    loadSessionFromData(data) {
         const sessionId = data.sessionId ?? generateUuid();
         const sessionResource = LocalChatSessionUri.forSession(sessionId);
         return this._sessionModels.acquireOrCreate({
@@ -480,33 +487,49 @@ let ChatService = class ChatService extends Disposable {
             },
             location: data.initialLocation ?? ChatAgentLocation.Chat,
             sessionResource,
-            sessionId,
             canUseTools: true
         });
     }
-    async loadSessionForResource(chatSessionResource, location, token) {
-        if (chatSessionResource.scheme === Schemas.vscodeLocalChatSession) {
-            return this.getOrRestoreSession(chatSessionResource);
+    async acquireOrLoadSession(sessionResource, location, token) {
+        if (sessionResource.scheme === Schemas.vscodeLocalChatSession) {
+            return this.acquireOrRestoreLocalSession(sessionResource);
+        } else {
+            return this.loadRemoteSession(sessionResource, location, token);
         }
-        const existingRef = this._sessionModels.acquireExisting(chatSessionResource);
-        if (existingRef) {
-            return existingRef;
+    }
+    async loadRemoteSession(sessionResource, location, token) {
+        await this.chatSessionService.canResolveChatSession(sessionResource);
+        {
+            const existingRef = this.acquireExistingSession(sessionResource);
+            if (existingRef) {
+                return existingRef;
+            }
         }
-        const providedSession = await this.chatSessionService.getOrCreateChatSession(chatSessionResource, CancellationToken.None);
-        const chatSessionType = chatSessionResource.scheme;
+        const providedSession = await this.chatSessionService.getOrCreateChatSession(sessionResource, token);
+        {
+            const existingRef = this.acquireExistingSession(sessionResource);
+            if (existingRef) {
+                providedSession.dispose();
+                return existingRef;
+            }
+        }
+        const chatSessionType = sessionResource.scheme;
         const modelRef = this._sessionModels.acquireOrCreate({
             initialData: undefined,
             location,
-            sessionResource: chatSessionResource,
+            sessionResource: sessionResource,
             canUseTools: false,
             transferEditingSession: providedSession.transferredState?.editingSession,
             inputState: providedSession.transferredState?.inputState
         });
         modelRef.object.setContributedChatSession({
-            chatSessionResource,
+            chatSessionResource: sessionResource,
             chatSessionType,
-            isUntitled: chatSessionResource.path.startsWith("/untitled-")
+            isUntitled: sessionResource.path.startsWith("/untitled-")
         });
+        if (providedSession.title) {
+            modelRef.object.setCustomTitle(providedSession.title);
+        }
         const model = modelRef.object;
         const disposables = ( new DisposableStore());
         disposables.add(modelRef.object.onDidDispose(() => {
@@ -539,7 +562,7 @@ let ChatService = class ChatService extends Disposable {
                 undefined,
                 undefined,
                 false,
-                undefined, undefined, message.id);
+                message.modelId, undefined, message.id);
             } else {
                 if (lastRequest) {
                     for (const part of message.parts) {
@@ -554,6 +577,10 @@ let ChatService = class ChatService extends Disposable {
         if (providedSession.progressObs && lastRequest && providedSession.interruptActiveResponseCallback) {
             const initialCancellationRequest = this.instantiationService.createInstance(CancellableRequest, ( new CancellationTokenSource()), undefined);
             this._pendingRequests.set(model.sessionResource, initialCancellationRequest);
+            this.telemetryService.publicLog2(ChatPendingRequestChangeEventName, {
+                action: "add",
+                source: "remoteSession"
+            });
             const cancellationListener = disposables.add(( new MutableDisposable()));
             const createCancellationListener = token => {
                 return token.onCancellationRequested(() => {
@@ -561,6 +588,10 @@ let ChatService = class ChatService extends Disposable {
                         if (!userConfirmedInterruption) {
                             const newCancellationRequest = this.instantiationService.createInstance(CancellableRequest, ( new CancellationTokenSource()), undefined);
                             this._pendingRequests.set(model.sessionResource, newCancellationRequest);
+                            this.telemetryService.publicLog2(ChatPendingRequestChangeEventName, {
+                                action: "add",
+                                source: "remoteSession"
+                            });
                             cancellationListener.value = createCancellationListener(newCancellationRequest.cancellationTokenSource.token);
                         }
                     });
@@ -584,6 +615,10 @@ let ChatService = class ChatService extends Disposable {
                 }
             }));
         } else {
+            this.telemetryService.publicLog2(ChatPendingRequestChangeEventName, {
+                action: "notCancelable",
+                source: "remoteSession"
+            });
             if (lastRequest && model.editingSession) {
                 await chatEditingSessionIsReady(model.editingSession);
                 lastRequest.response?.complete();
@@ -680,9 +715,12 @@ let ChatService = class ChatService extends Disposable {
             throw ( new Error(`Unknown session: ${sessionResource}`));
         }
         const hasPendingRequest = ( this._pendingRequests.has(sessionResource));
-        const hasPendingQueue = model.getPendingRequests().length > 0;
         if (options?.queue) {
-            return this.queuePendingRequest(model, sessionResource, request, options);
+            const queued = this.queuePendingRequest(model, sessionResource, request, options);
+            if (!options.pauseQueue) {
+                this.processPendingRequests(sessionResource);
+            }
+            return queued;
         } else if (hasPendingRequest) {
             this.trace("sendRequest", `Session ${sessionResource} already has a pending request`);
             return {
@@ -690,11 +728,6 @@ let ChatService = class ChatService extends Disposable {
                 reason: "Request already in progress"
             };
         }
-        if (options?.queue && hasPendingQueue) {
-            const queued = this.queuePendingRequest(model, sessionResource, request, options);
-            this.processNextPendingRequest(model);
-            return queued;
-        }
         const requests = model.getRequests();
         for (let i = requests.length - 1; i >= 0; i -= 1) {
             const request = requests[i];
@@ -744,6 +777,14 @@ let ChatService = class ChatService extends Disposable {
             };
             const commandPart = options.slashCommand ? ` ${chatSubcommandLeader}${options.slashCommand}` : "";
             request = `${chatAgentLeader}${agent.name}${commandPart} ${request}`;
+        } else if (options?.agentIdSilent && !parserContext?.forcedAgent) {
+            const silentAgent = this.chatAgentService.getAgent(options.agentIdSilent);
+            if (silentAgent) {
+                parserContext = {
+                    ...parserContext,
+                    forcedAgent: silentAgent
+                };
+            }
         }
         const parsedRequest = this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(sessionResource, request, location, parserContext);
         return parsedRequest;
@@ -774,7 +815,7 @@ let ChatService = class ChatService extends Disposable {
             agent: agentPart?.agent ?? defaultAgent,
             agentSlashCommandPart,
             commandPart,
-            sessionId: model.sessionId,
+            sessionResource: model.sessionResource,
             location: model.initialLocation,
             options,
             enableCommandDetection
@@ -812,7 +853,9 @@ let ChatService = class ChatService extends Disposable {
                             `Provider returned progress: ${JSON.stringify(progressItem)}`
                         );
                     }
-                    model.acceptResponseProgress(request, progressItem, !isLast);
+                    if (request) {
+                        model.acceptResponseProgress(request, progressItem, !isLast);
+                    }
                 }
                 completeResponseCreated();
             };
@@ -821,7 +864,7 @@ let ChatService = class ChatService extends Disposable {
             let collectedHooks;
             let hasDisabledClaudeHooks = false;
             try {
-                const hooksInfo = await this.promptsService.getHooks(token);
+                const hooksInfo = await this.promptsService.getHooks(token, model.sessionResource);
                 if (hooksInfo) {
                     collectedHooks = hooksInfo.hooks;
                     hasDisabledClaudeHooks = hooksInfo.hasDisabledClaudeHooks;
@@ -880,6 +923,11 @@ let ChatService = class ChatService extends Disposable {
                                 variables: this.prepareContext(request.attachedContext)
                             };
                             model.updateRequest(request, variableData);
+                            if (options?.resolvedVariables?.length) {
+                                variableData = {
+                                    variables: [...variableData.variables, ...options.resolvedVariables]
+                                };
+                            }
                             const promptTextResult = getPromptText(request.message);
                             variableData = updateRanges(variableData, promptTextResult.diff);
                             message = promptTextResult.message;
@@ -912,7 +960,7 @@ let ChatService = class ChatService extends Disposable {
                                 isInitialTools = false;
                                 return;
                             }
-                            if (tools) {
+                            if (tools && request) {
                                 this.chatAgentService.setRequestTools(agent.id, request.id, tools);
                                 agentRequest.userSelectedTools = tools;
                             }
@@ -926,7 +974,7 @@ let ChatService = class ChatService extends Disposable {
                             location
                         }, token);
                         if (result && this.chatAgentService.getAgent(result.agent.id)?.locations?.includes(location)) {
-                            request.response?.setAgent(result.agent, result.command);
+                            request?.response?.setAgent(result.agent, result.command);
                             detectedAgent = result.agent;
                             detectedCommand = result.command;
                         }
@@ -946,8 +994,9 @@ let ChatService = class ChatService extends Disposable {
                     const pendingRequest = this._pendingRequests.get(sessionResource);
                     if (pendingRequest) {
                         store.add(autorun(reader => {
-                            if (pendingRequest.yieldRequested.read(reader)) {
-                                this.chatAgentService.setYieldRequested(agent.id, request.id);
+                            const yieldRequested = pendingRequest.yieldRequested.read(reader);
+                            if (request) {
+                                this.chatAgentService.setYieldRequested(agent.id, request.id, yieldRequested);
                             }
                         }));
                         pendingRequest.requestId ??= requestProps.requestId;
@@ -1021,7 +1070,9 @@ let ChatService = class ChatService extends Disposable {
                 } else {
                     throw ( new Error(`Cannot handle request`));
                 }
-                if (token.isCancellationRequested && !rawResult) {
+                if ((token.isCancellationRequested && !rawResult)) {
+                    return;
+                } else if (!request) {
                     return;
                 } else {
                     if (!rawResult) {
@@ -1031,7 +1082,7 @@ let ChatService = class ChatService extends Disposable {
                         );
                         rawResult = {
                             errorDetails: {
-                                message: ( localize(6318, "Provider returned null response"))
+                                message: ( localize(6869, "Provider returned null response"))
                             }
                         };
                     }
@@ -1050,6 +1101,9 @@ let ChatService = class ChatService extends Disposable {
                         "sendRequest",
                         `Provider returned response for session ${model.sessionResource}`
                     );
+                    if (rawResult.errorDetails?.isRateLimited) {
+                        this.chatEntitlementService.markAnonymousRateLimited();
+                    }
                     shouldProcessPending = !rawResult.errorDetails && !token.isCancellationRequested;
                     request.response?.complete();
                     if (agentOrCommandFollowups) {
@@ -1062,15 +1116,15 @@ let ChatService = class ChatService extends Disposable {
                 }
             } catch (err) {
                 this.logService.error(`Error while handling chat request: ${toErrorMessage(err, true)}`);
-                requestTelemetry.complete({
-                    timeToFirstProgress: undefined,
-                    totalTime: undefined,
-                    result: "error",
-                    requestType,
-                    detectedAgent,
-                    request
-                });
                 if (request) {
+                    requestTelemetry.complete({
+                        timeToFirstProgress: undefined,
+                        totalTime: undefined,
+                        result: "error",
+                        requestType,
+                        detectedAgent,
+                        request
+                    });
                     const rawResult = {
                         errorDetails: {
                             message: err.message
@@ -1086,18 +1140,30 @@ let ChatService = class ChatService extends Disposable {
         };
         let shouldProcessPending = false;
         const rawResponsePromise = sendRequestInternal();
-        this._pendingRequests.set(
-            model.sessionResource,
-            this.instantiationService.createInstance(CancellableRequest, source, undefined)
-        );
+        const cancellableRequest = this.instantiationService.createInstance(CancellableRequest, source, undefined);
+        this._pendingRequests.set(model.sessionResource, cancellableRequest);
+        this.telemetryService.publicLog2(ChatPendingRequestChangeEventName, {
+            action: "add",
+            source: "sendRequest"
+        });
         rawResponsePromise.finally(() => {
-            this._pendingRequests.deleteAndDispose(model.sessionResource);
+            if (this._pendingRequests.get(model.sessionResource) === cancellableRequest) {
+                this._pendingRequests.deleteAndDispose(model.sessionResource);
+                this.telemetryService.publicLog2(ChatPendingRequestChangeEventName, {
+                    action: "remove",
+                    source: "sendRequestComplete"
+                });
+            }
             if (shouldProcessPending) {
                 this.processNextPendingRequest(model);
             }
         });
+        if (options?.userSelectedModelId) {
+            this.languageModelsService.addToRecentlyUsedList(options.userSelectedModelId);
+        }
         this._onDidSubmitRequest.fire({
-            chatSessionResource: model.sessionResource
+            chatSessionResource: model.sessionResource,
+            message: parsedRequest
         });
         return {
             responseCreatedPromise: responseCreated.p,
@@ -1232,6 +1298,10 @@ let ChatService = class ChatService extends Disposable {
         if (pendingRequest?.requestId === requestId) {
             pendingRequest.cancel();
             this._pendingRequests.deleteAndDispose(sessionResource);
+            this.telemetryService.publicLog2(ChatPendingRequestChangeEventName, {
+                action: "remove",
+                source: "removeRequest"
+            });
         }
         model.removeRequest(requestId);
     }
@@ -1250,6 +1320,14 @@ let ChatService = class ChatService extends Disposable {
             if (cts) {
                 cts.requestId = request.id;
                 this._pendingRequests.set(target.sessionResource, cts);
+                this.telemetryService.publicLog2(ChatPendingRequestChangeEventName, {
+                    action: "remove",
+                    source: "adoptRequest"
+                });
+                this.telemetryService.publicLog2(ChatPendingRequestChangeEventName, {
+                    action: "add",
+                    source: "adoptRequest"
+                });
             }
         }
     }
@@ -1279,10 +1357,34 @@ let ChatService = class ChatService extends Disposable {
         }
         request.response?.complete();
     }
-    cancelCurrentRequestForSession(sessionResource) {
+    cancelCurrentRequestForSession(sessionResource, source) {
         this.trace("cancelCurrentRequestForSession", `session: ${sessionResource}`);
-        this._pendingRequests.get(sessionResource)?.cancel();
+        const pendingRequest = this._pendingRequests.get(sessionResource);
+        if (!pendingRequest) {
+            const model = this._sessionModels.get(sessionResource);
+            const requestInProgress = model?.requestInProgress.get();
+            const pendingRequestsCount = model?.getPendingRequests().length ?? 0;
+            const lastRequest = model?.lastRequest;
+            this.telemetryService.publicLog2(ChatStopCancellationNoopEventName, {
+                source: source ?? "chatService",
+                reason: "noPendingRequest",
+                requestInProgress: requestInProgress === undefined ? "unknown" : requestInProgress ? "true" : "false",
+                pendingRequests: pendingRequestsCount,
+                sessionScheme: sessionResource.scheme,
+                lastRequestId: lastRequest?.id
+            });
+            this.info(
+                "cancelCurrentRequestForSession",
+                `No pending request was found for session ${sessionResource}. requestInProgress=${requestInProgress ?? "unknown"}, pendingRequests=${pendingRequestsCount}`
+            );
+            return;
+        }
+        pendingRequest.cancel();
         this._pendingRequests.deleteAndDispose(sessionResource);
+        this.telemetryService.publicLog2(ChatPendingRequestChangeEventName, {
+            action: "remove",
+            source: source ?? "cancelRequest"
+        });
     }
     setYieldRequested(sessionResource) {
         const pendingRequest = this._pendingRequests.get(sessionResource);
@@ -1294,6 +1396,11 @@ let ChatService = class ChatService extends Disposable {
         const model = this._sessionModels.get(sessionResource);
         if (model) {
             model.removePendingRequest(requestId);
+            const hasSteeringRequests = ( model.getPendingRequests().some(r => r.kind === ChatRequestQueueKind.Steering));
+            if (!hasSteeringRequests) {
+                const pendingRequest = this._pendingRequests.get(sessionResource);
+                pendingRequest?.resetYieldRequested();
+            }
         }
         const deferred = this._queuedRequestDeferreds.get(requestId);
         if (deferred) {
@@ -1347,7 +1454,7 @@ let ChatService = class ChatService extends Disposable {
     logChatIndex() {
         this._chatSessionStore.logIndex();
     }
-    setTitle(sessionResource, title) {
+    setSessionTitle(sessionResource, title) {
         this._sessionModels.get(sessionResource)?.setCustomTitle(title);
     }
     appendProgress(request, progress) {
@@ -1365,6 +1472,6 @@ let ChatService = class ChatService extends Disposable {
         return localSessionId;
     }
 };
-ChatService = ( __decorate([( __param(0, IStorageService)), ( __param(1, ILogService)), ( __param(2, IExtensionService)), ( __param(3, IInstantiationService)), ( __param(4, IWorkspaceContextService)), ( __param(5, IChatSlashCommandService)), ( __param(6, IChatAgentService)), ( __param(7, IConfigurationService)), ( __param(8, IChatTransferService)), ( __param(9, IChatSessionsService)), ( __param(10, IMcpService)), ( __param(11, IPromptsService))], ChatService));
+ChatService = ( __decorate([( __param(0, IStorageService)), ( __param(1, ILogService)), ( __param(2, ITelemetryService)), ( __param(3, IExtensionService)), ( __param(4, IInstantiationService)), ( __param(5, IWorkspaceContextService)), ( __param(6, IChatSlashCommandService)), ( __param(7, IChatAgentService)), ( __param(8, IConfigurationService)), ( __param(9, IChatTransferService)), ( __param(10, IChatSessionsService)), ( __param(11, IMcpService)), ( __param(12, IPromptsService)), ( __param(13, IChatEntitlementService)), ( __param(14, ILanguageModelsService)), ( __param(15, IChatDebugService))], ChatService));
 
 export { ChatService };

package/vscode/src/vs/workbench/contrib/chat/common/chatService/chatServiceTelemetry.d.ts

@@ -1,3 +1,4 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
 import { IChatAgentData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents";
 import { ChatRequestModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel";
@@ -116,7 +117,7 @@ export declare class ChatRequestTelemetry {
         agent: IChatAgentData;
         agentSlashCommandPart: ChatRequestAgentSubcommandPart | undefined;
         commandPart: ChatRequestSlashCommandPart | undefined;
-        sessionId: string;
+        sessionResource: URI;
         location: ChatAgentLocation;
         options: IChatSendRequestOptions | undefined;
         enableCommandDetection: boolean;