@codingame/monaco-vscode-chat-service-override 36.2.6 → 37.0.0

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

@@ -6,12 +6,24 @@ import { ChatRequestAgentSubcommandPart, ChatRequestSlashCommandPart } from "@co
 import { IChatSendRequestOptions, IChatUserActionEvent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
 import { ChatAgentLocation, ChatPermissionLevel } 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";
-export type ChatProviderInvokedEvent = {
+type ChatSessionModeEvent = {
+    isAgentHostSession: boolean;
+};
+type ChatSessionModeClassification = {
+    isAgentHostSession: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "Whether the action was performed in an Agent Host-backed chat session.";
+    };
+};
+export type ChatProviderInvokedEvent = ChatSessionModeEvent & {
+    requestIndex: number;
     timeToFirstProgress: number | undefined;
     totalTime: number | undefined;
     result: "success" | "error" | "errorWithOutput" | "cancelled" | "filtered";
     requestType: "string" | "followup" | "slashCommand";
     chatSessionId: string;
+    requestId: string;
     agent: string;
     agentExtensionId: string | undefined;
     slashCommand: string | undefined;
@@ -26,8 +38,19 @@ export type ChatProviderInvokedEvent = {
     chatMode: string | undefined;
     sessionType: string | undefined;
     harness: string | undefined;
+    sessionTypeSelectionReason: string | undefined;
+    isVirtualWorkspace: boolean;
+    settingDefaultToCopilotHarness: boolean;
+    settingPreferCopilotHarness: boolean;
+    settingLocalAgentEnabled: boolean;
 };
-export type ChatProviderInvokedClassification = {
+export type ChatProviderInvokedClassification = ChatSessionModeClassification & {
+    requestIndex: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        isMeasurement: true;
+        comment: "The zero-based index of the request within the chat session.";
+    };
     timeToFirstProgress: {
         classification: "SystemMetaData";
         purpose: "PerformanceAndHealth";
@@ -53,6 +76,11 @@ export type ChatProviderInvokedClassification = {
         purpose: "FeatureInsight";
         comment: "A random ID for the session.";
     };
+    requestId: {
+        classification: "SystemMetaData";
+        purpose: "PerformanceAndHealth";
+        comment: "The identifier of the chat request, used to correlate workbench and agent host telemetry.";
+    };
     agent: {
         classification: "SystemMetaData";
         purpose: "FeatureInsight";
@@ -106,7 +134,7 @@ export type ChatProviderInvokedClassification = {
     permissionLevel: {
         classification: "SystemMetaData";
         purpose: "FeatureInsight";
-        comment: "The tool auto-approval permission level selected in the permission picker (default, autoApprove, or autopilot). Undefined when the picker is not applicable (e.g. ask mode or API-driven requests).";
+        comment: "The tool auto-approval permission level selected in the permission picker (default, assisted, autoApprove, or autopilot). Undefined when the picker is not applicable (e.g. ask mode or API-driven requests).";
     };
     chatMode: {
         classification: "SystemMetaData";
@@ -123,6 +151,31 @@ export type ChatProviderInvokedClassification = {
         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.";
     };
+    sessionTypeSelectionReason: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "Why the session type was selected when the session was created. Undefined for restored or reused sessions.";
+    };
+    isVirtualWorkspace: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "Whether the chat request was made in a virtual workspace.";
+    };
+    settingDefaultToCopilotHarness: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The effective value of the chat.defaultToCopilotHarness setting when the request started.";
+    };
+    settingPreferCopilotHarness: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The effective value of the chat.editor.preferCopilotHarness setting when the request started.";
+    };
+    settingLocalAgentEnabled: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The effective value of the chat.editor.localAgent.enabled setting when the request started.";
+    };
     owner: "roblourens";
     comment: "Provides insight into the performance of Chat agents.";
 };
@@ -130,7 +183,7 @@ export declare class ChatServiceTelemetry {
     private readonly telemetryService;
     constructor(telemetryService: ITelemetryService);
     notifyUserAction(action: IChatUserActionEvent): void;
-    retrievedFollowups(agentId: string, command: string | undefined, numFollowups: number): void;
+    retrievedFollowups(sessionResource: URI, agentId: string, command: string | undefined, numFollowups: number): void;
 }
 export declare class ChatRequestTelemetry {
     private readonly opts;
@@ -141,10 +194,16 @@ export declare class ChatRequestTelemetry {
         agent: IChatAgentData;
         agentSlashCommandPart: ChatRequestAgentSubcommandPart | undefined;
         commandPart: ChatRequestSlashCommandPart | undefined;
+        requestIndex: number;
+        sessionTypeSelectionReason: string | undefined;
         sessionResource: URI;
         location: ChatAgentLocation;
         options: IChatSendRequestOptions | undefined;
         enableCommandDetection: boolean;
+        isVirtualWorkspace: boolean;
+        settingDefaultToCopilotHarness: boolean;
+        settingPreferCopilotHarness: boolean;
+        settingLocalAgentEnabled: boolean;
     }, telemetryService: ITelemetryService, languageModelsService: ILanguageModelsService);
     complete({ timeToFirstProgress, totalTime, result, requestType, request, detectedAgent }: {
         timeToFirstProgress: number | undefined;
@@ -157,3 +216,4 @@ export declare class ChatRequestTelemetry {
     private attachmentKindsForTelemetry;
     private resolveModelId;
 }
+export {};

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 { isAgentHostSessionResource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
 import { isRemoteAgentHostSessionType, parseRemoteAgentHostHarness } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSessionType';
 
 let ChatServiceTelemetry = class ChatServiceTelemetry {
@@ -16,26 +17,31 @@ let ChatServiceTelemetry = class ChatServiceTelemetry {
         this.telemetryService = telemetryService;
     }
     notifyUserAction(action) {
+        const isAgentHostSession = getIsAgentHostSessionForTelemetry(action.sessionResource);
         if (action.action.kind === "vote") {
             this.telemetryService.publicLog2("interactiveSessionVote", {
+                isAgentHostSession,
                 direction: action.action.direction === ChatAgentVoteDirection.Up ? "up" : "down",
                 agentId: action.agentId ?? "",
                 command: action.command
             });
         } else if (action.action.kind === "copy") {
             this.telemetryService.publicLog2("interactiveSessionCopy", {
+                isAgentHostSession,
                 copyKind: action.action.copyKind === ChatCopyKind.Action ? "action" : "toolbar",
                 agentId: action.agentId ?? "",
                 command: action.command
             });
         } else if (action.action.kind === "insert") {
             this.telemetryService.publicLog2("interactiveSessionInsert", {
+                isAgentHostSession,
                 newFile: !!action.action.newFile,
                 agentId: action.agentId ?? "",
                 command: action.command
             });
         } else if (action.action.kind === "apply") {
             this.telemetryService.publicLog2("interactiveSessionApply", {
+                isAgentHostSession,
                 newFile: !!action.action.newFile,
                 codeMapper: action.action.codeMapper,
                 agentId: action.agentId ?? "",
@@ -44,17 +50,30 @@ let ChatServiceTelemetry = class ChatServiceTelemetry {
             });
         } else if (action.action.kind === "runInTerminal") {
             this.telemetryService.publicLog2("interactiveSessionRunInTerminal", {
+                isAgentHostSession,
                 languageId: action.action.languageId ?? "",
                 agentId: action.agentId ?? "",
                 command: action.command
             });
         } else if (action.action.kind === "followUp") {
             this.telemetryService.publicLog2("chatFollowupClicked", {
+                isAgentHostSession,
                 agentId: action.agentId ?? "",
                 command: action.command
             });
+        } else if (action.action.kind === "chatEditingSessionAction") {
+            this.telemetryService.publicLog2("chatEditSession", {
+                isAgentHostSession,
+                agentId: action.agentId ?? "",
+                outcome: action.action.outcome,
+                hasRemainingEdits: action.action.hasRemainingEdits,
+                requestId: action.requestId,
+                modelId: escapeModelIdForTelemetry(action.modelId) ?? "",
+                modeId: action.modeId ?? ""
+            });
         } else if (action.action.kind === "chatEditingHunkAction") {
             this.telemetryService.publicLog2("chatEditHunk", {
+                isAgentHostSession,
                 agentId: action.agentId ?? "",
                 outcome: action.action.outcome,
                 lineCount: action.action.lineCount,
@@ -65,8 +84,9 @@ let ChatServiceTelemetry = class ChatServiceTelemetry {
             });
         }
     }
-    retrievedFollowups(agentId, command, numFollowups) {
+    retrievedFollowups(sessionResource, agentId, command, numFollowups) {
         this.telemetryService.publicLog2("chatFollowupsRetrieved", {
+            isAgentHostSession: getIsAgentHostSessionForTelemetry(sessionResource),
             agentId,
             command,
             numFollowups
@@ -119,10 +139,13 @@ let ChatRequestTelemetry = class ChatRequestTelemetry {
         }
         this.isComplete = true;
         this.telemetryService.publicLog2("interactiveSessionProviderInvoked", {
+            requestIndex: this.opts.requestIndex,
+            sessionTypeSelectionReason: this.opts.sessionTypeSelectionReason,
             timeToFirstProgress,
             totalTime,
             result,
             requestType,
+            requestId: request.id,
             agent: detectedAgent?.id ?? this.opts.agent.id,
             agentExtensionId: detectedAgent?.extensionId.value ?? this.opts.agent.extensionId.value,
             slashCommand: this.opts.agentSlashCommandPart ? this.opts.agentSlashCommandPart.command.name : this.opts.commandPart?.slashCommand.command,
@@ -137,7 +160,12 @@ let ChatRequestTelemetry = class ChatRequestTelemetry {
             permissionLevel: this.opts.options?.modeInfo?.kind === ChatModeKind.Ask ? undefined : this.opts.options?.modeInfo?.permissionLevel,
             chatMode: this.opts.options?.modeInfo?.telemetryModeName ?? this.opts.options?.modeInfo?.telemetryModeId,
             sessionType: getChatSessionTypeForTelemetry(this.opts.sessionResource),
-            harness: getHarnessForTelemetry(this.opts.sessionResource)
+            harness: getHarnessForTelemetry(this.opts.sessionResource),
+            isAgentHostSession: getIsAgentHostSessionForTelemetry(this.opts.sessionResource),
+            isVirtualWorkspace: this.opts.isVirtualWorkspace,
+            settingDefaultToCopilotHarness: this.opts.settingDefaultToCopilotHarness,
+            settingPreferCopilotHarness: this.opts.settingPreferCopilotHarness,
+            settingLocalAgentEnabled: this.opts.settingLocalAgentEnabled
         });
     }
     attachmentKindsForTelemetry(variableData) {
@@ -184,6 +212,9 @@ function getChatSessionTypeForTelemetry(sessionResource) {
     const sessionType = getChatSessionType(sessionResource);
     return isRemoteAgentHostSessionType(sessionType) ? "remote-agent-host" : sessionType;
 }
+function getIsAgentHostSessionForTelemetry(sessionResource) {
+    return isAgentHostSessionResource(sessionResource);
+}
 function getHarnessForTelemetry(sessionResource) {
     return parseRemoteAgentHostHarness(getChatSessionType(sessionResource));
 }

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

@@ -0,0 +1,68 @@
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IChatSideChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSideChatService.service";
+/**
+ * Source text a side chat is anchored to, so the side chat can be given the
+ * excerpt the question is about.
+ */
+export interface IChatSideChatSelection {
+    readonly text: string;
+}
+/**
+ * Describes the conversation and turn a side chat branched from, so chat UI can
+ * show where the side chat came from and navigate back to it.
+ */
+export interface IChatSideChatOrigin {
+    /** Resource of the chat this side chat branched from. */
+    readonly sourceSessionResource: URI;
+    /** Id of the turn in the source chat the side chat branched from. */
+    readonly sourceTurnId: string;
+    /** Display title of the source chat, when known. */
+    readonly sourceTitle: string | undefined;
+    /** Immutable text snapshot the side chat was anchored to, when the user branched from a selection. */
+    readonly selection?: IChatSideChatSelection;
+}
+/**
+ * Supplies the ability to branch a conversation into a side chat — a question
+ * answered alongside the conversation without being added to it.
+ *
+ * Implemented today by the Agents window (`vs/sessions`), which owns side chat
+ * creation. The workbench declares the capability so chat UI can offer it
+ * without depending on that layer; when the workbench gains native side chats it
+ * registers a provider of its own.
+ */
+export interface IChatSideChatProvider {
+    /**
+     * Whether a side chat can be branched from `sessionResource` right now, e.g.
+     * the conversation supports side chats and has a turn to branch from.
+     */
+    canAskInSideChat(sessionResource: URI): boolean;
+    /**
+     * Branches a side chat from the conversation's latest turn, reveals it, and
+     * sends `query` on it. Rejects if the side chat could not be created.
+     */
+    askInSideChat(sessionResource: URI, query: string, selection?: IChatSideChatSelection): Promise<void>;
+    /**
+     * Observes how `sessionResource` came to exist as a side chat, or `undefined`
+     * when it is not a side chat. Observable because the source chat's title and
+     * the origin itself settle asynchronously as session state loads.
+     */
+    observeSideChatOrigin(sessionResource: URI): IObservable<IChatSideChatOrigin | undefined>;
+    /**
+     * Reveals the turn `sessionResource` branched from, activating the source
+     * chat. No-ops when `sessionResource` is not a side chat.
+     */
+    revealSideChatSource(sessionResource: URI): Promise<void>;
+}
+export declare class ChatSideChatService extends Disposable implements IChatSideChatService {
+    readonly _serviceBrand: undefined;
+    private readonly _providers;
+    private readonly _sideChatOrigins;
+    registerProvider(provider: IChatSideChatProvider): IDisposable;
+    canAskInSideChat(sessionResource: URI): boolean;
+    askInSideChat(sessionResource: URI, query: string, selection?: IChatSideChatSelection): Promise<void>;
+    observeSideChatOrigin(sessionResource: URI): IObservable<IChatSideChatOrigin | undefined>;
+    revealSideChatSource(sessionResource: URI): Promise<void>;
+    private _findProvider;
+}

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

@@ -0,0 +1,70 @@
+
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+
+class ChatSideChatService extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._providers = observableValue(this, []);
+        this._sideChatOrigins = ( new ResourceMap());
+    }
+    registerProvider(provider) {
+        if (!this._providers.get().includes(provider)) {
+            this._providers.set([...this._providers.get(), provider], undefined);
+        }
+        return toDisposable(() => {
+            const providers = this._providers.get();
+            const index = providers.indexOf(provider);
+            if (index !== -1) {
+                this._providers.set([...providers.slice(0, index), ...providers.slice(index + 1)], undefined);
+            }
+        });
+    }
+    canAskInSideChat(sessionResource) {
+        return !!this._findProvider(sessionResource);
+    }
+    async askInSideChat(sessionResource, query, selection) {
+        const provider = this._findProvider(sessionResource);
+        if (!provider) {
+            throw ( new Error(`No side chat provider for ${( sessionResource.toString())}`));
+        }
+        await provider.askInSideChat(sessionResource, query, selection);
+    }
+    observeSideChatOrigin(sessionResource) {
+        let origin = this._sideChatOrigins.get(sessionResource);
+        if (!origin) {
+            origin = derived(this, reader => {
+                for (const provider of this._providers.read(reader)) {
+                    const providerOrigin = provider.observeSideChatOrigin(sessionResource).read(reader);
+                    if (providerOrigin !== undefined) {
+                        return providerOrigin;
+                    }
+                }
+                return undefined;
+            });
+            this._sideChatOrigins.set(sessionResource, origin);
+        }
+        return origin;
+    }
+    async revealSideChatSource(sessionResource) {
+        for (const provider of this._providers.get()) {
+            if (provider.observeSideChatOrigin(sessionResource).get() !== undefined) {
+                await provider.revealSideChatSource(sessionResource);
+                return;
+            }
+        }
+    }
+    _findProvider(sessionResource) {
+        for (const provider of this._providers.get()) {
+            if (provider.canAskInSideChat(sessionResource)) {
+                return provider;
+            }
+        }
+        return undefined;
+    }
+}
+
+export { ChatSideChatService };

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

@@ -1,7 +1,8 @@
 import { Disposable, IReference } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
-import { ChatAgentLocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
+import { ChatAgentLocation, SessionTypeSelectionReason } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
 import { IChatEditingSession } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService";
 import { ChatModel, ISerializableChatModelInputState, ISerializedChatDataReference } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel";
 export interface IStartSessionProps {
@@ -12,6 +13,8 @@ export interface IStartSessionProps {
     readonly transferEditingSession?: IChatEditingSession;
     readonly disableBackgroundKeepAlive?: boolean;
     readonly inputState?: ISerializableChatModelInputState;
+    readonly isReadOnly?: IObservable<boolean>;
+    readonly sessionTypeSelectionReason?: SessionTypeSelectionReason;
 }
 export interface ChatModelStoreDelegate {
     createModel: (props: IStartSessionProps) => ChatModel;
@@ -53,7 +56,7 @@ export declare class ChatModelStore extends Disposable {
     private readonly _onDidCreateModel;
     readonly onDidCreateModel: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<ChatModel>;
     constructor(delegate: ChatModelStoreDelegate, logService: ILogService);
-    get observable(): import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").IObservable<Map<string, ChatModel>>;
+    get observable(): IObservable<Map<string, ChatModel>>;
     values(): Iterable<ChatModel>;
     /**
      * Get a ChatModel directly without acquiring a reference.

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

@@ -6,6 +6,7 @@ import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/reso
 import { hasKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { IChatRequestVariableEntry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries';
+import { serializeChatRequestOrigin } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatRequestOrigin';
 import { ResponseModelState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
 import { ModifiedFileEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService';
 import { serializeSendOptions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel';
@@ -39,6 +40,8 @@ const responsePartSchema = v(
             case "multiDiffData":
             case "mcpServersStarting":
             case "thinking":
+            case "planReview":
+            case "autoModeResolution":
                 return equals(a, b);
             case "clearToPreviousToolInvocation":
             case "codeblockUri":
@@ -53,7 +56,6 @@ const responsePartSchema = v(
             case "systemNotification":
             case "pullRequest":
             case "questionCarousel":
-            case "planReview":
             case "undoStop":
             case "warning":
             case "info":
@@ -61,7 +63,6 @@ const responsePartSchema = v(
             case "workspaceEdit":
             case "externalEdit":
             case "disabledClaudeHooks":
-            case "autoModeResolution":
                 return a.kind === b.kind;
             default:
                 {
@@ -91,7 +92,7 @@ const chatVariableSchema = object({
 });
 const requestSchema = object({
     requestId: t(m => m.id, key()),
-    timestamp: v(m => m.timestamp),
+    timestamp: v(m => m.requestTimestamp),
     confirmation: v(m => m.confirmation),
     message: t(m => m.message, messageSchema),
     shouldBeRemovedOnSend: v(m => m.shouldBeRemovedOnSend, equals),
@@ -100,11 +101,16 @@ const requestSchema = object({
     editedFileEvents: t(m => m.editedFileEvents, array(agentEditedFileEventSchema)),
     variableData: t(m => m.variableData, chatVariableSchema),
     isHidden: v(() => undefined),
+    hiddenFromTranscript: v(m => m.isHiddenFromTranscript),
+    requestHiddenFromTranscript: v(
+        m => m.isRequestHiddenFromTranscript && !m.isHiddenFromTranscript ? true : undefined
+    ),
     isCanceled: v(() => undefined),
     response: t(m => m.response?.entireResponse.value.filter(
-        p => p.kind !== "mcpAuthenticationRequired" && p.kind !== "mcpServersStartingSlow"
+        p => p.kind !== "mcpAuthenticationRequired" && p.kind !== "mcpServersStartingSlow" && p.kind !== "voiceProgress"
     ), array(responsePartSchema)),
     responseId: v(m => m.response?.id),
+    responseTimestamp: v(m => m.response?.timestamp),
     result: v(m => m.response?.result, equals),
     responseMarkdownInfo: v(m => m.response?.codeBlockInfos?.map(info => ({
         suggestionId: info.suggestionId
@@ -122,13 +128,20 @@ const requestSchema = object({
     outputBuffer: v(m => m.response?.usage?.outputBuffer),
     promptTokenDetails: v(m => m.response?.usage?.promptTokenDetails, equals),
     copilotCredits: v(m => m.response?.usage?.copilotCredits),
+    modelTotals: v(m => m.response?.usage?.modelTotals, equals),
+    sessionCopilotCredits: v(m => m.response?.usage?.sessionCopilotCredits),
     elapsedMs: v(
         m => m.response?.elapsedMs ?? (m.response?.completedAt ? Math.max(0, m.response.completedAt - m.response.confirmationAdjustedTimestamp.get()) : undefined)
     ),
     modeInfo: v(m => m.modeInfo, equals),
     isSystemInitiated: v(m => m.isSystemInitiated),
+    requestSource: v(m => m.requestSource),
     systemInitiatedLabel: v(m => m.systemInitiatedLabel),
-    terminalExecutionId: v(m => m.terminalExecutionId)
+    terminalExecutionId: v(m => m.terminalExecutionId),
+    origin: v(
+        m => m.origin ? serializeChatRequestOrigin(m.origin) : undefined,
+        equals
+    )
 }, {
     sealed: o => o.modelState?.value === ResponseModelState.Cancelled || o.modelState?.value === ResponseModelState.Failed || o.modelState?.value === ResponseModelState.Complete
 });

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

@@ -29,11 +29,11 @@ import { ResponseModelState } from '@codingame/monaco-vscode-api/vscode/vs/workb
 import { ModifiedFileEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService';
 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 { LocalChatSessionUri, getChatSessionStorageResource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 import { stringifyEntryWithFallback } from './objectMutationLog.js';
 
 var ChatSessionStore_1;
-const maxPersistedSessions = 50;
+const maxPersistedSessions = 400;
 const ChatIndexStorageKey = "chat.ChatSessionStore.index";
 const ChatTransferIndexStorageKey = "ChatSessionStore.transferIndex";
 let ChatSessionStore = class ChatSessionStore extends Disposable {
@@ -99,7 +99,7 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
             }
             e.join(this.storeTask, {
                 id: "join.chatSessionStore",
-                label: ( localize(8582, "Saving chat history"))
+                label: ( localize(10299, "Saving chat history"))
             });
         }));
     }
@@ -357,14 +357,14 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
                             this._didReportIssue = true;
                             this.dialogService.prompt({
                                 custom: true,
-                                title: ( localize(8583, "Error saving chat session")),
+                                title: ( localize(10300, "Error saving chat session")),
                                 message: ( localize(
-                                    8584,
+                                    10301,
                                     "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(8585, "Report Issue")),
+                                    label: ( localize(10302, "Report Issue")),
                                     run: () => this.openerService.open("https://github.com/microsoft/vscode/issues/new?template=bug_report.md")
                                 }]
                             });
@@ -441,7 +441,18 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
         if (!index.entries[sessionId]) {
             return;
         }
-        const storageLocation = this.getStorageLocation(sessionId);
+        let storageLocation;
+        try {
+            storageLocation = this.getStorageLocation(sessionId);
+        } catch (e) {
+            this.reportError(
+                "invalidSessionId",
+                `Removing invalid chat session from index: ${sessionId}`,
+                e
+            );
+            delete index.entries[sessionId];
+            return;
+        }
         for (const uri of [storageLocation.flat, storageLocation.log]) {
             try {
                 if (uri) {
@@ -578,7 +589,22 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
     }
     async readSession(sessionId) {
         return await this.storeQueue.queue(async () => {
-            const storageLocation = this.getStorageLocation(sessionId);
+            let storageLocation;
+            try {
+                storageLocation = this.getStorageLocation(sessionId);
+            } catch (e) {
+                this.reportError(
+                    "invalidSessionId",
+                    `Ignoring invalid chat session from index: ${sessionId}`,
+                    e
+                );
+                const index = this.internalGetIndex();
+                if (index.entries[sessionId]) {
+                    delete index.entries[sessionId];
+                    await this.flushIndex();
+                }
+                return undefined;
+            }
             return this.readSessionFromLocation(storageLocation.flat, storageLocation.log, sessionId);
         });
     }
@@ -643,7 +669,7 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
     async readSessionFromPreviousLocation(sessionId) {
         let rawData;
         if (this.previousEmptyWindowStorageRoot) {
-            const storageLocation2 = joinPath(this.previousEmptyWindowStorageRoot, `${sessionId}.json`);
+            const storageLocation2 = getChatSessionStorageResource(this.previousEmptyWindowStorageRoot, sessionId, ".json");
             try {
                 rawData = (await this.fileService.readFile(storageLocation2)).value;
                 this.logService.info(`ChatSessionStore: Read chat session ${sessionId} from previous location`);
@@ -660,13 +686,16 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
     }
     getStorageLocation(chatSessionId) {
         return {
-            flat: joinPath(this.storageRoot, `${chatSessionId}.json`),
-            log: this.configurationService.getValue("chat.useLogSessionStorage") !== false ? joinPath(this.storageRoot, `${chatSessionId}.jsonl`) : undefined
+            flat: getChatSessionStorageResource(this.storageRoot, chatSessionId, ".json"),
+            log: this.configurationService.getValue("chat.useLogSessionStorage") !== false ? getChatSessionStorageResource(this.storageRoot, chatSessionId, ".jsonl") : undefined
         };
     }
     getTransferredSessionStorageLocation(sessionResource) {
         const sessionId = LocalChatSessionUri.parseLocalSessionId(sessionResource);
-        return joinPath(this.transferredSessionStorageRoot, `${sessionId}.json`);
+        if (!sessionId) {
+            throw ( new Error(`Invalid local chat session resource: ${( sessionResource.toString())}`));
+        }
+        return getChatSessionStorageResource(this.transferredSessionStorageRoot, sessionId, ".json");
     }
     updateAndFlushIndexSync(localSessions, externalSessions) {
         const index = this.internalGetIndex();
@@ -728,7 +757,7 @@ function getSessionMetadataSync(session) {
     } : undefined;
     return {
         sessionId: session.sessionId,
-        title: title || ( localize(8586, "New Chat")),
+        title: title || ( localize(10303, "New Chat")),
         lastMessageDate: session.lastMessageDate,
         timing: session.timing,
         initialLocation: session.initialLocation,
@@ -750,7 +779,7 @@ async function getSessionMetadata(session) {
     const lastMessageDate = session.requests.at(-1)?.timestamp ?? session.creationDate;
     return {
         sessionId: session.sessionId,
-        title: session.customTitle || ( localize(8586, "New Chat")),
+        title: session.customTitle || ( localize(10303, "New Chat")),
         lastMessageDate,
         timing: {
             created: session.creationDate,

package/vscode/src/vs/workbench/contrib/chat/common/participants/chatSlashCommands.d.ts

@@ -18,6 +18,10 @@ export interface IChatSlashData {
      * as it is entered. Defaults to `false`.
      */
     executeImmediately?: boolean;
+    /**
+     * Whether a silent command can execute independently while the chat has a request in progress.
+     */
+    executeDuringRequest?: boolean;
     /**
      * Whether the command should be added as a request/response
      * turn to the chat history. Defaults to `false`.