@codingame/monaco-vscode-chat-service-override 26.2.2 → 28.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,18 +38,20 @@ 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';
 import { IChatSlashCommandService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatSlashCommands.service';
 import { IChatTransferService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatTransferService.service';
 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 { 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';
+import { mergeHooks } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookSchema';
 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 { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
@@ -62,6 +68,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 +82,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 {
@@ -88,9 +100,6 @@ let ChatService = class ChatService extends Disposable {
     waitForModelDisposals() {
         return this._sessionModels.waitForModelDisposals();
     }
-    get edits2Enabled() {
-        return this.configurationService.getValue(ChatConfiguration.Edits2Enabled);
-    }
     get isEmptyWindow() {
         const workspace = this.workspaceContextService.getWorkspace();
         return !workspace.configuration && workspace.folders.length === 0;
@@ -98,6 +107,7 @@ let ChatService = class ChatService extends Disposable {
     constructor(
         storageService,
         logService,
+        telemetryService,
         extensionService,
         instantiationService,
         workspaceContextService,
@@ -107,11 +117,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 +136,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 +167,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 +310,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 +331,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(6984, "New Chat"));
             return {
                 sessionResource: session.sessionResource,
                 title,
@@ -323,17 +347,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 +361,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 +379,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 +395,6 @@ let ChatService = class ChatService extends Disposable {
             initialData,
             location,
             sessionResource,
-            sessionId,
             canUseTools,
             transferEditingSession,
             disableBackgroundKeepAlive,
@@ -396,7 +404,6 @@ let ChatService = class ChatService extends Disposable {
             initialLocation: location,
             canUseTools,
             resource: sessionResource,
-            sessionId,
             disableBackgroundKeepAlive,
             inputState
         });
@@ -431,25 +438,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 +464,6 @@ let ChatService = class ChatService extends Disposable {
             initialData: sessionData,
             location: sessionData.value.initialLocation ?? ChatAgentLocation.Chat,
             sessionResource,
-            sessionId,
             canUseTools: true
         });
         return sessionRef;
@@ -470,7 +475,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 +485,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.scheme);
+        {
+            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 +560,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 +575,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 +586,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 +613,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 +713,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 +726,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 +775,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 +813,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 +851,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 +862,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;
@@ -829,6 +870,18 @@ let ChatService = class ChatService extends Disposable {
             } catch (error) {
                 this.logService.warn("[ChatService] Failed to collect hooks:", error);
             }
+            const agentName = options?.modeInfo?.modeInstructions?.name;
+            if (agentName) {
+                try {
+                    const agents = await this.promptsService.getCustomAgents(token, model.sessionResource);
+                    const customAgent = agents.find(a => a.name === agentName);
+                    if (customAgent?.hooks) {
+                        collectedHooks = mergeHooks(collectedHooks, customAgent.hooks);
+                    }
+                } catch (error) {
+                    this.logService.warn("[ChatService] Failed to collect agent hooks:", error);
+                }
+            }
             const stopWatch = ( new StopWatch(false));
             store.add(token.onCancellationRequested(() => {
                 this.trace(
@@ -880,6 +933,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;
@@ -901,6 +959,7 @@ let ChatService = class ChatService extends Disposable {
                             userSelectedModelId: options?.userSelectedModelId,
                             userSelectedTools: options?.userSelectedTools?.get(),
                             modeInstructions: options?.modeInfo?.modeInstructions,
+                            permissionLevel: options?.modeInfo?.permissionLevel,
                             editedFileEvents: request.editedFileEvents,
                             hooks: collectedHooks,
                             hasHooksEnabled: !!collectedHooks && ( ( Object.values(collectedHooks)).some(arr => arr.length > 0))
@@ -912,7 +971,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 +985,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 +1005,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;
@@ -1014,14 +1074,18 @@ let ChatService = class ChatService extends Disposable {
                         history,
                         location,
                         model.sessionResource,
-                        token
+                        token,
+                        options
                     );
                     agentOrCommandFollowups = Promise.resolve(commandResult?.followUp);
                     rawResult = {};
                 } else {
                     throw ( new Error(`Cannot handle request`));
                 }
-                if (token.isCancellationRequested && !rawResult) {
+                if ((token.isCancellationRequested && !rawResult)) {
+                    return;
+                } else if (!request) {
+                    shouldProcessPending = !token.isCancellationRequested;
                     return;
                 } else {
                     if (!rawResult) {
@@ -1031,7 +1095,7 @@ let ChatService = class ChatService extends Disposable {
                         );
                         rawResult = {
                             errorDetails: {
-                                message: ( localize(6318, "Provider returned null response"))
+                                message: ( localize(6985, "Provider returned null response"))
                             }
                         };
                     }
@@ -1050,6 +1114,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 +1129,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 +1153,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,
@@ -1111,31 +1190,64 @@ let ChatService = class ChatService extends Disposable {
         }
     }
     processNextPendingRequest(model) {
-        const pendingRequest = model.dequeuePendingRequest();
-        if (!pendingRequest) {
+        const steeringRequests = model.dequeueAllSteeringRequests();
+        const nextQueued = steeringRequests.length === 0 ? model.dequeuePendingRequest() : undefined;
+        const allRequests = steeringRequests.length > 0 ? steeringRequests : (nextQueued ? [nextQueued] : []);
+        if (allRequests.length === 0) {
             return;
         }
         this.trace(
             "processNextPendingRequest",
-            `Processing queued request for session ${model.sessionResource}`
+            `Processing ${allRequests.length} queued request(s) for session ${model.sessionResource}`
         );
-        const deferred = this._queuedRequestDeferreds.get(pendingRequest.request.id);
-        this._queuedRequestDeferreds.delete(pendingRequest.request.id);
+        const deferreds = [];
+        for (const req of allRequests) {
+            const deferred = this._queuedRequestDeferreds.get(req.request.id);
+            this._queuedRequestDeferreds.delete(req.request.id);
+            if (deferred) {
+                deferreds.push(deferred);
+            }
+        }
+        const firstRequest = allRequests[0];
         const sendOptions = {
-            ...pendingRequest.sendOptions,
-            attachedContext: pendingRequest.request.variableData.variables.slice()
+            ...firstRequest.sendOptions,
+            attachedContext: allRequests.flatMap(req => req.request.variableData.variables.slice())
         };
         const location = sendOptions.location ?? sendOptions.locationData?.type ?? model.initialLocation;
         const defaultAgent = this.chatAgentService.getDefaultAgent(location, sendOptions.modeInfo?.kind);
         if (!defaultAgent) {
             this.logService.warn("processNextPendingRequest", `No default agent for location ${location}`);
-            deferred?.complete({
-                kind: "rejected",
-                reason: "No default agent available"
-            });
+            for (const deferred of deferreds) {
+                deferred.complete({
+                    kind: "rejected",
+                    reason: "No default agent available"
+                });
+            }
+            return;
+        }
+        let parsedRequest;
+        try {
+            if (allRequests.length > 1) {
+                const combinedText = ( allRequests.map(req => req.request.message.text)).join("\n\n");
+                parsedRequest = this.parseChatRequest(model.sessionResource, combinedText, location, {
+                    ...sendOptions,
+                    agentId: undefined,
+                    slashCommand: undefined
+                });
+            } else {
+                parsedRequest = firstRequest.request.message;
+            }
+        } catch (err) {
+            this.logService.error("processNextPendingRequest: failed to parse combined chat request", err);
+            const reason = toErrorMessage(err);
+            for (const deferred of deferreds) {
+                deferred.complete({
+                    kind: "rejected",
+                    reason
+                });
+            }
             return;
         }
-        const parsedRequest = pendingRequest.request.message;
         const silentAgent = sendOptions.agentIdSilent ? this.chatAgentService.getAgent(sendOptions.agentIdSilent) : undefined;
         const agent = silentAgent ?? parsedRequest.parts.find(r => r instanceof ChatRequestAgentPart)?.agent ?? defaultAgent;
         const agentSlashCommandPart = parsedRequest.parts.find(r => r instanceof ChatRequestAgentSubcommandPart);
@@ -1143,20 +1255,23 @@ let ChatService = class ChatService extends Disposable {
             model,
             model.sessionResource,
             parsedRequest,
-            pendingRequest.request.attempt,
+            firstRequest.request.attempt,
             !sendOptions.noCommandDetection,
             silentAgent ?? defaultAgent,
             location,
             sendOptions
         );
-        deferred?.complete({
+        const result = {
             kind: "sent",
             data: {
                 ...responseState,
                 agent,
                 slashCommand: agentSlashCommandPart?.command
             }
-        });
+        };
+        for (const deferred of deferreds) {
+            deferred.complete(result);
+        }
     }
     generateInitialChatTitleIfNeeded(model, request, defaultAgent, token) {
         if (model.getRequests().length !== 1 || model.customTitle) {
@@ -1232,6 +1347,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 +1369,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 +1406,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 +1445,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 +1503,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 +1521,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 };