@codingame/monaco-vscode-chat-service-override 34.1.3 → 35.0.1

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

@@ -8,6 +8,7 @@ import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/even
 import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
 import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
 import { Disposable, DisposableResourceMap, DisposableStore, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
@@ -35,7 +36,7 @@ import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbe
 import { chatEditingSessionIsReady } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService';
 import { logChangesToStateModel, normalizeSerializableChatData, ChatModel, ChatRequestRemovalReason, ChatRequestModel, updateRanges, toChatHistoryContent } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel';
 import { ChatModelStore } from '../model/chatModelStore.js';
-import { ChatRequestTextPart, ChatRequestSlashCommandPart, getPromptText, ChatRequestAgentPart, ChatRequestAgentSubcommandPart, chatSubcommandLeader, chatAgentLeader } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatParserTypes';
+import { ChatRequestTextPart, ChatRequestAgentPart, ChatRequestAgentSubcommandPart, ChatRequestSlashCommandPart, getPromptText, chatSubcommandLeader, chatAgentLeader } 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 { ChatPendingRequestChangeEventName, ChatRequestQueueKind, ChatMcpServersStarting, ChatStopCancellationNoopEventName, ResponseModelState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
 import { ChatServiceTelemetry, ChatRequestTelemetry } from './chatServiceTelemetry.js';
@@ -46,9 +47,10 @@ import { IChatSlashCommandService } from '@codingame/monaco-vscode-api/vscode/vs
 import { IChatTransferService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatTransferService.service';
 import { LocalChatSessionUri, getChatSessionType, chatSessionResourceToId, isUntitledChatSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 import { isExplicitFileOrImageVariableEntry, IChatRequestVariableEntry, ChatRequestVariableSet, isPromptTextVariableEntry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries';
-import { ChatAgentLocation, ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatAgentLocation, ChatModeKind, ChatConfiguration } 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 { ToolAndToolSetEnablementMap } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
 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';
@@ -111,7 +113,7 @@ let CancellableRequest = class CancellableRequest {
 };
 CancellableRequest = ( __decorate([( __param(4, ILanguageModelToolsService))], CancellableRequest));
 const EMPTY_REFERENCES = ( Object.freeze([]));
-const EMPTY_TOOL_ENABLEMENT_MAP = ( new Map());
+const EMPTY_TOOL_ENABLEMENT_MAP = ToolAndToolSetEnablementMap.fromEntries([]);
 let ChatService = class ChatService extends Disposable {
     get transferredSessionResource() {
         return this._transferredSessionResource;
@@ -166,6 +168,7 @@ let ChatService = class ChatService extends Disposable {
         this.chatDebugService = chatDebugService;
         this._pendingRequests = this._register(( new DisposableResourceMap()));
         this._queuedRequestDeferreds = ( new Map());
+        this._inFlightUntitledMaterializations = ( new ResourceMap());
         this._saveModelsEnabled = true;
         this._onDidSubmitRequest = this._register(( new Emitter()));
         this.onDidSubmitRequest = this._onDidSubmitRequest.event;
@@ -215,6 +218,7 @@ let ChatService = class ChatService extends Disposable {
         this._register(this._sessionModels.onDidDisposeModel(model => {
             clearChatMarks(model.sessionResource);
             this.chatDebugService.endSession(model.sessionResource);
+            this.chatSessionService.clearMaterializedSessionResource(model.sessionResource);
             this._onDidDisposeSession.fire({
                 sessionResources: [model.sessionResource],
                 reason: "cleared"
@@ -562,6 +566,7 @@ let ChatService = class ChatService extends Disposable {
         const storedInputState = storedMetadata?.inputState;
         let initialData = undefined;
         let historySelectedModel = undefined;
+        let historyDerivedModel = undefined;
         if ((modelId || agentUri)) {
             const mode = agentUri ? {
                 kind: ChatModeKind.Agent,
@@ -571,11 +576,15 @@ let ChatService = class ChatService extends Disposable {
                 id: ChatMode.Agent.id
             };
             const modelMetadata = modelId ? this.languageModelsService.lookupLanguageModel(modelId) : undefined;
+            const storedModelConfiguration = storedInputState?.selectedModel?.modelConfiguration ?? storedInputState?.modelConfiguration;
+            const modelConfiguration = storedInputState?.selectedModel?.identifier === modelId ? storedModelConfiguration : undefined;
             const selectedModel = modelId && modelMetadata ? {
                 identifier: modelId,
-                metadata: modelMetadata
+                metadata: modelMetadata,
+                modelConfiguration
             } : undefined;
             historySelectedModel = selectedModel?.identifier;
+            historyDerivedModel = selectedModel;
             initialData = {
                 serializer: ( new ChatSessionOperationLog()),
                 value: {
@@ -600,13 +609,17 @@ let ChatService = class ChatService extends Disposable {
                 }
             };
         }
+        const restoredDraft = storedInputState ? {
+            ...storedInputState,
+            selectedModel: historyDerivedModel
+        } : undefined;
         const modelRef = this._sessionModels.acquireOrCreate({
             initialData,
             location,
             sessionResource: sessionResource,
             canUseTools: false,
             transferEditingSession: providedSession.transferredState?.editingSession,
-            inputState: providedSession.transferredState?.inputState
+            inputState: providedSession.transferredState?.inputState ?? restoredDraft
         }, debugOwner ?? "ChatService#loadRemoteSession");
         logChangesToStateModel(
             modelRef.object.inputModel,
@@ -674,7 +687,7 @@ let ChatService = class ChatService extends Disposable {
                     kind: ChatModeKind.Agent,
                     isBuiltin: message.modeInstructions.isBuiltin ?? false,
                     modeInstructions: message.modeInstructions,
-                    modeId: "custom",
+                    telemetryModeId: "custom",
                     applyCodeBlockSuggestionId: undefined
                 } : undefined;
                 lastRequest = model.addRequest(parsedRequest, message.variableData ?? {
@@ -691,9 +704,14 @@ let ChatService = class ChatService extends Disposable {
                     for (const part of message.parts) {
                         model.acceptResponseProgress(lastRequest, part);
                     }
-                    if (message.details && lastRequest.response) {
+                    if (lastRequest.response && (message.details || message.errorDetails)) {
                         lastRequest.response.setResult({
-                            details: message.details
+                            ...(message.details ? {
+                                details: message.details
+                            } : {}),
+                            ...(message.errorDetails ? {
+                                errorDetails: message.errorDetails
+                            } : {})
                         });
                     }
                 }
@@ -871,94 +889,161 @@ let ChatService = class ChatService extends Disposable {
                 reason: "Empty message"
             };
         }
+        let newSessionResource;
+        const materializedReal = this.chatSessionService.getMaterializedSessionResource(sessionResource);
+        if (materializedReal) {
+            sessionResource = materializedReal;
+            newSessionResource = materializedReal;
+        }
         let model = this._sessionModels.get(sessionResource);
         if (!model) {
             throw ( new Error(`Unknown session: ${sessionResource}`));
         }
-        let tempRef;
-        let newSessionResource;
-        try {
-            if (!model.hasRequests && isUntitledChatSession(sessionResource) && getChatSessionType(sessionResource) !== localChatSessionType) {
-                const parsedRequest = this.parseChatRequest(
+        if (!model.hasRequests && isUntitledChatSession(sessionResource) && getChatSessionType(sessionResource) !== localChatSessionType) {
+            const materialized = await this._materializeUntitledSession(sessionResource, request, options, model);
+            if (materialized) {
+                model = materialized.model;
+                sessionResource = materialized.sessionResource;
+                newSessionResource = materialized.newSessionResource;
+            }
+        }
+        const hasPendingRequest = ( this._pendingRequests.has(sessionResource));
+        if (options?.queue) {
+            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 {
+                kind: "rejected",
+                reason: "Request already in progress"
+            };
+        }
+        const requests = model.getRequests();
+        for (let i = requests.length - 1; i >= 0; i -= 1) {
+            const request = requests[i];
+            if (request.shouldBeRemovedOnSend) {
+                if (request.shouldBeRemovedOnSend.afterUndoStop) {
+                    request.response?.finalizeUndoState();
+                } else {
+                    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);
+        if (!defaultAgent) {
+            this.logService.warn("sendRequest", `No default agent for location ${location}`);
+            return {
+                kind: "rejected",
+                reason: "No default agent available"
+            };
+        }
+        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 {
+            kind: "sent",
+            newSessionResource,
+            data: {
+                ...this._sendRequestAsync(
+                    model,
                     sessionResource,
-                    request,
-                    options?.location ?? model.initialLocation,
+                    parsedRequest,
+                    attempt,
+                    !options?.noCommandDetection,
+                    silentAgent ?? defaultAgent,
+                    location,
                     options
+                ),
+                agent,
+                slashCommand: agentSlashCommandPart?.command
+            }
+        };
+    }
+    async _materializeUntitledSession(untitledResource, request, options, untitledModel) {
+        const inFlight = this._inFlightUntitledMaterializations.get(untitledResource);
+        if (inFlight) {
+            const realResource = await inFlight;
+            if (!realResource) {
+                this.trace(
+                    "materializeUntitledSession",
+                    `In-flight materialization of ${( untitledResource.toString())} produced no real session; keeping untitled`
                 );
-                const commandPart = parsedRequest.parts.find(r => r instanceof ChatRequestSlashCommandPart);
-                const requestText = getPromptText(parsedRequest).message;
-                const initialSessionOptions = this.chatSessionService.getSessionOptions(sessionResource);
-                const newItem = await this.chatSessionService.createNewChatSessionItem(getChatSessionType(sessionResource), {
-                    prompt: requestText,
-                    command: commandPart?.text,
-                    initialSessionOptions,
-                    untitledResource: sessionResource
-                }, CancellationToken.None);
-                if (newItem) {
-                    this.chatSessionService.registerSessionResourceAlias(sessionResource, newItem.resource);
-                    tempRef = await this.loadRemoteSession(newItem.resource, model.initialLocation, CancellationToken.None);
-                    model = tempRef?.object;
-                    if (!model) {
-                        throw ( new Error(`Failed to load session for resource: ${newItem.resource}`));
-                    }
-                    if (initialSessionOptions) {
-                        this.chatSessionService.updateSessionOptions(model.sessionResource, initialSessionOptions);
-                    }
-                    sessionResource = newItem.resource;
-                    newSessionResource = newItem.resource;
-                }
+                return undefined;
             }
-            const hasPendingRequest = ( this._pendingRequests.has(sessionResource));
-            if (options?.queue) {
-                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 {
-                    kind: "rejected",
-                    reason: "Request already in progress"
-                };
+            const realModel = this._sessionModels.get(realResource);
+            if (!realModel) {
+                this.info(
+                    "materializeUntitledSession",
+                    `Joined in-flight materialization of ${( untitledResource.toString())} but real model ${( realResource.toString())} is missing; keeping untitled`
+                );
+                return undefined;
             }
-            const requests = model.getRequests();
-            for (let i = requests.length - 1; i >= 0; i -= 1) {
-                const request = requests[i];
-                if (request.shouldBeRemovedOnSend) {
-                    if (request.shouldBeRemovedOnSend.afterUndoStop) {
-                        request.response?.finalizeUndoState();
-                    } else {
-                        await this.removeRequest(sessionResource, request.id);
-                    }
-                }
+            this.trace(
+                "materializeUntitledSession",
+                `Concurrent send joined in-flight materialization ${( untitledResource.toString())} -> ${( realResource.toString())}`
+            );
+            return {
+                model: realModel,
+                sessionResource: realResource,
+                newSessionResource: realResource
+            };
+        }
+        const materialized = ( new DeferredPromise());
+        this._inFlightUntitledMaterializations.set(untitledResource, materialized.p);
+        try {
+            const parsedRequest = this.parseChatRequest(
+                untitledResource,
+                request,
+                options?.location ?? untitledModel.initialLocation,
+                options
+            );
+            const commandPart = parsedRequest.parts.find(r => r instanceof ChatRequestSlashCommandPart);
+            const requestText = getPromptText(parsedRequest).message;
+            const initialSessionOptions = this.chatSessionService.getSessionOptions(untitledResource);
+            const newItem = await this.chatSessionService.createNewChatSessionItem(getChatSessionType(untitledResource), {
+                prompt: requestText,
+                command: commandPart?.text,
+                initialSessionOptions,
+                untitledResource
+            }, CancellationToken.None);
+            if (!newItem) {
+                materialized.complete(undefined);
+                return undefined;
+            }
+            this.chatSessionService.registerSessionResourceAlias(untitledResource, newItem.resource);
+            const tempRef = await this.loadRemoteSession(newItem.resource, untitledModel.initialLocation, CancellationToken.None);
+            const realModel = tempRef?.object;
+            if (!realModel) {
+                throw ( new Error(`Failed to load session for resource: ${newItem.resource}`));
             }
-            const location = options?.location ?? model.initialLocation;
-            const attempt = options?.attempt ?? 0;
-            const defaultAgent = this.chatAgentService.getDefaultAgent(location, options?.modeInfo?.kind);
-            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);
+            if (initialSessionOptions) {
+                this.chatSessionService.updateSessionOptions(realModel.sessionResource, initialSessionOptions);
+            }
+            this.chatSessionService.setMaterializedSessionResource(untitledResource, newItem.resource);
+            materialized.complete(newItem.resource);
+            this.info(
+                "materializeUntitledSession",
+                `Materialized untitled session ${( untitledResource.toString())} into real session ${( newItem.resource.toString())}`
+            );
             return {
-                kind: "sent",
-                newSessionResource,
-                data: {
-                    ...this._sendRequestAsync(
-                        model,
-                        sessionResource,
-                        parsedRequest,
-                        attempt,
-                        !options?.noCommandDetection,
-                        silentAgent ?? defaultAgent,
-                        location,
-                        options
-                    ),
-                    agent,
-                    slashCommand: agentSlashCommandPart?.command
-                }
+                model: realModel,
+                sessionResource: newItem.resource,
+                newSessionResource: newItem.resource
             };
-        } finally {}
+        } catch (err) {
+            materialized.complete(undefined);
+            throw err;
+        } finally {
+            if (this._inFlightUntitledMaterializations.get(untitledResource) === materialized.p) {
+                this._inFlightUntitledMaterializations.delete(untitledResource);
+            }
+        }
     }
     getAttachmentCapabilitiesForParser(chatSessionType, agent) {
         return this.chatSessionService.getCapabilitiesForSessionType(chatSessionType) ?? agent?.capabilities;
@@ -1091,7 +1176,7 @@ let ChatService = class ChatService extends Disposable {
                         model.acceptResponseProgress(request, {
                             kind: "markdownContent",
                             content: ( new MarkdownString(( localize(
-                                7939,
+                                8538,
                                 "The `{0}` skill requires `{1}` to be enabled. After enabling, reload the window to apply. [Enable in Settings](command:workbench.action.openSettings?{2})",
                                 TROUBLESHOOT_COMMAND_NAME,
                                 AGENT_DEBUG_LOG_FILE_LOGGING_ENABLED_SETTING,
@@ -1143,6 +1228,9 @@ let ChatService = class ChatService extends Disposable {
                 if (!ctx) {
                     return [];
                 }
+                if (this.configurationService.getValue(ChatConfiguration.CollectInstructionsInExtension) === true) {
+                    return [];
+                }
                 markChat(sessionResource, ChatPerfMark.WillCollectInstructions);
                 try {
                     const variableSet = ( new ChatRequestVariableSet(options?.attachedContext));
@@ -1250,7 +1338,7 @@ let ChatService = class ChatService extends Disposable {
                             rejectedConfirmationData: options?.rejectedConfirmationData,
                             agentHostSessionConfig: options?.agentHostSessionConfig,
                             userSelectedModelId: options?.userSelectedModelId,
-                            modelConfiguration: options?.userSelectedModelId ? this.languageModelsService.getModelConfiguration(options.userSelectedModelId) : undefined,
+                            modelConfiguration: options?.userSelectedModelConfiguration ?? (options?.userSelectedModelId ? this.languageModelsService.getModelConfiguration(options.userSelectedModelId) : undefined),
                             userSelectedTools: options?.userSelectedTools?.get(),
                             modeInstructions: options?.modeInfo?.modeInstructions,
                             permissionLevel: options?.modeInfo?.permissionLevel,
@@ -1393,7 +1481,7 @@ let ChatService = class ChatService extends Disposable {
                         );
                         rawResult = {
                             errorDetails: {
-                                message: ( localize(7940, "Provider returned null response"))
+                                message: ( localize(8539, "Provider returned null response"))
                             }
                         };
                     }
@@ -1820,6 +1908,56 @@ let ChatService = class ChatService extends Disposable {
             model.setPendingRequests(requests);
         }
     }
+    async sendPendingRequestImmediately(sessionResource, requestId) {
+        const model = this._sessionModels.get(sessionResource);
+        if (!model) {
+            return;
+        }
+        const pendingRequests = model.getPendingRequests();
+        const target = pendingRequests.find(r => r.request.id === requestId);
+        if (!target) {
+            return;
+        }
+        if (this._isServerManagedQueue(sessionResource)) {
+            const message = target.request.message.text;
+            const attachedContext = target.request.variableData.variables.slice();
+            const sendOptions = {
+                ...target.sendOptions,
+                queue: undefined,
+                attachedContext
+            };
+            this.removePendingRequest(sessionResource, requestId);
+            await this.cancelCurrentRequestForSession(sessionResource, "queueRunNext");
+            let result;
+            try {
+                result = await this.sendRequest(sessionResource, message, sendOptions);
+            } catch (err) {
+                this.logService.error("sendPendingRequestImmediately: re-send failed", err);
+            }
+            if (!result || result.kind === "rejected") {
+                this.info(
+                    "sendPendingRequestImmediately",
+                    `Re-send was not accepted (${result?.kind ?? "error"}); restoring pending message to the queue`
+                );
+                await this.sendRequest(sessionResource, message, {
+                    ...sendOptions,
+                    attachedContext,
+                    queue: target.kind
+                });
+            }
+            return;
+        }
+        const reordered = [{
+            requestId: target.request.id,
+            kind: target.kind
+        }, ...( pendingRequests.filter(r => r.request.id !== requestId).map(r => ({
+            requestId: r.request.id,
+            kind: r.kind
+        })))];
+        this.setPendingRequests(sessionResource, reordered);
+        await this.cancelCurrentRequestForSession(sessionResource, "queueRunNext");
+        this.processPendingRequests(sessionResource);
+    }
     hasSessions() {
         return this._chatSessionStore.hasSessions();
     }
@@ -1877,7 +2015,7 @@ let ChatService = class ChatService extends Disposable {
 };
 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));
 async function chatModelToChatDetail(model) {
-    const title = model.title || ( localize(7941, "New Chat"));
+    const title = model.title || ( localize(8540, "New Chat"));
     return {
         sessionResource: model.sessionResource,
         title,

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

@@ -25,6 +25,7 @@ export type ChatProviderInvokedEvent = {
     permissionLevel: ChatPermissionLevel | undefined;
     chatMode: string | undefined;
     sessionType: string | undefined;
+    harness: string | undefined;
 };
 export type ChatProviderInvokedClassification = {
     timeToFirstProgress: {
@@ -117,6 +118,11 @@ export type ChatProviderInvokedClassification = {
         purpose: "FeatureInsight";
         comment: "The session type scheme (e.g. vscodeLocalChatSession for local, or remote session scheme).";
     };
+    harness: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "For remote agent host sessions, the underlying harness/provider (e.g. copilotcli, claude, codex) so remote activity can be split by harness. Undefined for non-remote sessions.";
+    };
     owner: "roblourens";
     comment: "Provides insight into the performance of Chat agents.";
 };

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

@@ -9,6 +9,7 @@ import { isImageVariableEntry } from '@codingame/monaco-vscode-api/vscode/vs/wor
 import { ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
 import { chatSessionResourceToId, getChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { isRemoteAgentHostSessionType, parseRemoteAgentHostHarness } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSessionType';
 
 let ChatServiceTelemetry = class ChatServiceTelemetry {
     constructor(telemetryService) {
@@ -134,8 +135,9 @@ let ChatRequestTelemetry = class ChatRequestTelemetry {
             attachmentKinds: this.attachmentKindsForTelemetry(request.variableData),
             model: this.resolveModelId(this.opts.options?.userSelectedModelId),
             permissionLevel: this.opts.options?.modeInfo?.kind === ChatModeKind.Ask ? undefined : this.opts.options?.modeInfo?.permissionLevel,
-            chatMode: this.opts.options?.modeInfo?.modeName ?? this.opts.options?.modeInfo?.modeId,
-            sessionType: getChatSessionTypeForTelemetry(this.opts.sessionResource)
+            chatMode: this.opts.options?.modeInfo?.telemetryModeName ?? this.opts.options?.modeInfo?.telemetryModeId,
+            sessionType: getChatSessionTypeForTelemetry(this.opts.sessionResource),
+            harness: getHarnessForTelemetry(this.opts.sessionResource)
         });
     }
     attachmentKindsForTelemetry(variableData) {
@@ -180,7 +182,10 @@ let ChatRequestTelemetry = class ChatRequestTelemetry {
 ChatRequestTelemetry = ( __decorate([( __param(1, ITelemetryService)), ( __param(2, ILanguageModelsService))], ChatRequestTelemetry));
 function getChatSessionTypeForTelemetry(sessionResource) {
     const sessionType = getChatSessionType(sessionResource);
-    return sessionType.startsWith("remote-") ? "remote-agent-host" : sessionType;
+    return isRemoteAgentHostSessionType(sessionType) ? "remote-agent-host" : sessionType;
+}
+function getHarnessForTelemetry(sessionResource) {
+    return parseRemoteAgentHostHarness(getChatSessionType(sessionResource));
 }
 
 export { ChatRequestTelemetry, ChatServiceTelemetry };

package/vscode/src/vs/workbench/contrib/chat/common/model/chatSessionOperationLog.js

@@ -50,6 +50,7 @@ const responsePartSchema = v(
             case "markdownVuln":
             case "notebookEditGroup":
             case "progressMessage":
+            case "systemNotification":
             case "pullRequest":
             case "questionCarousel":
             case "planReview":
@@ -60,6 +61,7 @@ const responsePartSchema = v(
             case "workspaceEdit":
             case "externalEdit":
             case "disabledClaudeHooks":
+            case "autoModeResolution":
                 return a.kind === b.kind;
             default:
                 {
@@ -99,7 +101,9 @@ const requestSchema = object({
     variableData: t(m => m.variableData, chatVariableSchema),
     isHidden: v(() => undefined),
     isCanceled: v(() => undefined),
-    response: t(m => m.response?.entireResponse.value, array(responsePartSchema)),
+    response: t(m => m.response?.entireResponse.value.filter(
+        p => p.kind !== "mcpAuthenticationRequired" && p.kind !== "mcpServersStartingSlow"
+    ), array(responsePartSchema)),
     responseId: v(m => m.response?.id),
     result: v(m => m.response?.result, equals),
     responseMarkdownInfo: v(m => m.response?.codeBlockInfos?.map(info => ({
@@ -114,6 +118,10 @@ const requestSchema = object({
     codeCitations: v(m => m.response?.codeCitations, equals),
     timeSpentWaiting: v(m => m.response?.timestamp),
     completionTokens: v(m => m.response?.completionTokenCount),
+    promptTokens: v(m => m.response?.usage?.promptTokens),
+    outputBuffer: v(m => m.response?.usage?.outputBuffer),
+    promptTokenDetails: v(m => m.response?.usage?.promptTokenDetails, equals),
+    copilotCredits: v(m => m.response?.usage?.copilotCredits),
     elapsedMs: v(
         m => m.response?.elapsedMs ?? (m.response?.completedAt ? Math.max(0, m.response.completedAt - m.response.confirmationAdjustedTimestamp.get()) : undefined)
     ),
@@ -127,7 +135,10 @@ const requestSchema = object({
 const inputStateSchema = object({
     attachments: v(i => ( i.attachments.map(IChatRequestVariableEntry.toExport)), equals),
     mode: v(i => i.mode, (a, b) => a.id === b.id),
-    selectedModel: v(i => i.selectedModel, (a, b) => a?.identifier === b?.identifier),
+    selectedModel: v(
+        i => i.selectedModel,
+        (a, b) => a?.identifier === b?.identifier && equals(a?.modelConfiguration, b?.modelConfiguration)
+    ),
     inputText: v(i => i.inputText),
     selections: v(i => i.selections, equals),
     permissionLevel: v(i => i.permissionLevel),

package/vscode/src/vs/workbench/contrib/chat/common/model/chatSessionStore.js

@@ -30,6 +30,7 @@ import { ModifiedFileEntryState } from '@codingame/monaco-vscode-api/vscode/vs/w
 import { ChatModel, normalizeSerializableChatData } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel';
 import { ChatSessionOperationLog } from './chatSessionOperationLog.js';
 import { LocalChatSessionUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { stringifyEntryWithFallback } from './objectMutationLog.js';
 
 var ChatSessionStore_1;
 const maxPersistedSessions = 50;
@@ -98,7 +99,7 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
             }
             e.join(this.storeTask, {
                 id: "join.chatSessionStore",
-                label: ( localize(7976, "Saving chat history"))
+                label: ( localize(8582, "Saving chat history"))
             });
         }));
     }
@@ -243,7 +244,7 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
             }
         }
         try {
-            const content = JSON.stringify(session, undefined, 2);
+            const content = stringifyEntryWithFallback(session);
             const storageLocation = this.getTransferredSessionStorageLocation(session.sessionResource);
             await this.fileService.writeFile(storageLocation, VSBuffer.fromString(content));
         } catch (e) {
@@ -356,14 +357,14 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
                             this._didReportIssue = true;
                             this.dialogService.prompt({
                                 custom: true,
-                                title: ( localize(7977, "Error saving chat session")),
+                                title: ( localize(8583, "Error saving chat session")),
                                 message: ( localize(
-                                    7978,
+                                    8584,
                                     "Error serializing chat session for storage. The session will be lost if the window is closed. Please report this issue to the VS Code team:\n\n{0}",
                                     e.stack || toErrorMessage(e)
                                 )),
                                 buttons: [{
-                                    label: ( localize(7979, "Report Issue")),
+                                    label: ( localize(8585, "Report Issue")),
                                     run: () => this.openerService.open("https://github.com/microsoft/vscode/issues/new?template=bug_report.md")
                                 }]
                             });
@@ -381,7 +382,10 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
                     await this.fileService.writeFile(storageLocation.log, content);
                 }
             } else {
-                await this.fileService.writeFile(storageLocation.flat, VSBuffer.fromString(JSON.stringify(session)));
+                await this.fileService.writeFile(
+                    storageLocation.flat,
+                    VSBuffer.fromString(stringifyEntryWithFallback(session))
+                );
             }
             const newMetadata = await getSessionMetadata(session);
             index.entries[session.sessionId] = newMetadata;
@@ -724,7 +728,7 @@ function getSessionMetadataSync(session) {
     } : undefined;
     return {
         sessionId: session.sessionId,
-        title: title || ( localize(7980, "New Chat")),
+        title: title || ( localize(8586, "New Chat")),
         lastMessageDate: session.lastMessageDate,
         timing: session.timing,
         initialLocation: session.initialLocation,
@@ -746,7 +750,7 @@ async function getSessionMetadata(session) {
     const lastMessageDate = session.requests.at(-1)?.timestamp ?? session.creationDate;
     return {
         sessionId: session.sessionId,
-        title: session.customTitle || ( localize(7980, "New Chat")),
+        title: session.customTitle || ( localize(8586, "New Chat")),
         lastMessageDate,
         timing: {
             created: session.creationDate,

package/vscode/src/vs/workbench/contrib/chat/common/model/objectMutationLog.d.ts

@@ -99,6 +99,11 @@ export declare const PERSIST_ENTRY_MAX_TOTAL_CHARS: number;
  * entire chat session.
  */
 export declare function stringifyEntryWithFallback(entry: unknown): string;
+/**
+ * Deep-clones `value` through JSON with the same V8 max-string-length safety net
+ * as {@link stringifyEntryWithFallback}. Exported for testing only.
+ */
+export declare function deepCloneWithFallback<T>(value: T): T;
 /**
  * Exported for testing only. Builds the stateful `JSON.stringify` replacer
  * used by {@link stringifyEntryWithFallback} on its retry path.