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

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

@@ -1,9 +1,10 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
 import { IChatAgentData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents";
 import { ChatRequestModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel";
 import { ChatRequestAgentSubcommandPart, ChatRequestSlashCommandPart } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatParserTypes";
 import { IChatSendRequestOptions, IChatUserActionEvent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
-import { ChatAgentLocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
+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 = {
     timeToFirstProgress: number | undefined;
@@ -21,6 +22,9 @@ export type ChatProviderInvokedEvent = {
     enableCommandDetection: boolean;
     attachmentKinds: string[];
     model: string | undefined;
+    permissionLevel: ChatPermissionLevel | undefined;
+    chatMode: string | undefined;
+    sessionType: string | undefined;
 };
 export type ChatProviderInvokedClassification = {
     timeToFirstProgress: {
@@ -98,6 +102,21 @@ export type ChatProviderInvokedClassification = {
         purpose: "FeatureInsight";
         comment: "The model used to generate the response.";
     };
+    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).";
+    };
+    chatMode: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The chat mode used for the request. Built-in modes (ask, agent, edit), extension-contributed names (e.g. Plan), or a hashed identifier for user-created custom agents.";
+    };
+    sessionType: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The session type scheme (e.g. vscodeLocalChatSession for local, or remote session scheme).";
+    };
     owner: "roblourens";
     comment: "Provides insight into the performance of Chat agents.";
 };
@@ -116,7 +135,7 @@ export declare class ChatRequestTelemetry {
         agent: IChatAgentData;
         agentSlashCommandPart: ChatRequestAgentSubcommandPart | undefined;
         commandPart: ChatRequestSlashCommandPart | undefined;
-        sessionId: string;
+        sessionResource: URI;
         location: ChatAgentLocation;
         options: IChatSendRequestOptions | undefined;
         enableCommandDetection: boolean;

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

@@ -5,7 +5,9 @@ import { isLocation } from '@codingame/monaco-vscode-api/vscode/vs/editor/common
 import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
 import { ChatAgentVoteDirection, ChatCopyKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
 import { isImageVariableEntry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries';
+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 } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 
 let ChatServiceTelemetry = class ChatServiceTelemetry {
     constructor(telemetryService) {
@@ -120,14 +122,17 @@ let ChatRequestTelemetry = class ChatRequestTelemetry {
             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,
-            chatSessionId: this.opts.sessionId,
+            chatSessionId: chatSessionResourceToId(this.opts.sessionResource),
             enableCommandDetection: this.opts.enableCommandDetection,
             isParticipantDetected: !!detectedAgent,
             location: this.opts.location,
             citations: request.response?.codeCitations.length ?? 0,
             numCodeBlocks: getCodeBlocks(request.response?.response.toString() ?? "").length,
             attachmentKinds: this.attachmentKindsForTelemetry(request.variableData),
-            model: this.resolveModelId(this.opts.options?.userSelectedModelId)
+            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: this.opts.sessionResource.scheme
         });
     }
     attachmentKindsForTelemetry(variableData) {

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

@@ -1,4 +1,4 @@
-import { IDisposable, IReference, ReferenceCollection } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { Disposable, IReference } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 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";
@@ -8,7 +8,6 @@ export interface IStartSessionProps {
     readonly initialData?: ISerializedChatDataReference;
     readonly location: ChatAgentLocation;
     readonly sessionResource: URI;
-    readonly sessionId?: string;
     readonly canUseTools: boolean;
     readonly transferEditingSession?: IChatEditingSession;
     readonly disableBackgroundKeepAlive?: boolean;
@@ -18,10 +17,10 @@ export interface ChatModelStoreDelegate {
     createModel: (props: IStartSessionProps) => ChatModel;
     willDisposeModel: (model: ChatModel) => Promise<void>;
 }
-export declare class ChatModelStore extends ReferenceCollection<ChatModel> implements IDisposable {
+export declare class ChatModelStore extends Disposable {
     private readonly delegate;
     private readonly logService;
-    private readonly _store;
+    private readonly _refCollection;
     private readonly _models;
     private readonly _modelsToDispose;
     private readonly _pendingDisposals;
@@ -39,8 +38,8 @@ export declare class ChatModelStore extends ReferenceCollection<ChatModel> imple
     has(uri: URI): boolean;
     acquireExisting(uri: URI): IReference<ChatModel> | undefined;
     acquireOrCreate(props: IStartSessionProps): IReference<ChatModel>;
-    protected createReferencedObject(key: string, props?: IStartSessionProps): ChatModel;
-    protected destroyReferencedObject(key: string, object: ChatModel): void;
+    private createReferencedObject;
+    private destroyReferencedObject;
     private doDestroyReferencedObject;
     /**
      * For test use only

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

@@ -1,24 +1,32 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { ReferenceCollection, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, ReferenceCollection } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { ObservableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/map';
 
-let ChatModelStore = class ChatModelStore extends ReferenceCollection {
+let ChatModelStore = class ChatModelStore extends Disposable {
     constructor(delegate, logService) {
         super();
         this.delegate = delegate;
         this.logService = logService;
-        this._store = ( new DisposableStore());
         this._models = ( new ObservableMap());
         this._modelsToDispose = ( new Set());
         this._pendingDisposals = ( new Set());
-        this._onDidDisposeModel = this._store.add(( new Emitter()));
+        this._onDidDisposeModel = this._register(( new Emitter()));
         this.onDidDisposeModel = this._onDidDisposeModel.event;
-        this._onDidCreateModel = this._store.add(( new Emitter()));
+        this._onDidCreateModel = this._register(( new Emitter()));
         this.onDidCreateModel = this._onDidCreateModel.event;
+        const self = this;
+        this._refCollection = new (class extends ReferenceCollection {
+            createReferencedObject(key, props) {
+                return self.createReferencedObject(key, props);
+            }
+            destroyReferencedObject(key, object) {
+                return self.destroyReferencedObject(key, object);
+            }
+        })();
     }
     get observable() {
         return this._models.observable;
@@ -37,10 +45,10 @@ let ChatModelStore = class ChatModelStore extends ReferenceCollection {
         if (!( this._models.has(key))) {
             return undefined;
         }
-        return this.acquire(key);
+        return this._refCollection.acquire(key);
     }
     acquireOrCreate(props) {
-        return this.acquire(this.toKey(props.sessionResource), props);
+        return this._refCollection.acquire(this.toKey(props.sessionResource), props);
     }
     createReferencedObject(key, props) {
         this._modelsToDispose.delete(key);
@@ -90,7 +98,7 @@ let ChatModelStore = class ChatModelStore extends ReferenceCollection {
         return ( uri.toString());
     }
     dispose() {
-        this._store.dispose();
+        super.dispose();
         this._models.forEach(model => model.dispose());
     }
 };

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

@@ -1,14 +1,17 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service";
 import { IEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service";
 import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
 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 { IUserDataProfilesService } from "@codingame/monaco-vscode-api/vscode/vs/platform/userDataProfile/common/userDataProfile.service";
 import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
 import { ILifecycleService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+import { IWorkspaceEditingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/workspaces/common/workspaceEditing.service";
 import { IChatSessionStats, IChatSessionTiming, ResponseModelState } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
 import { ChatAgentLocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
 import { ChatModel, ISerializableChatData, ISerializableChatsData, ISerializedChatDataReference } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel";
@@ -22,13 +25,18 @@ export declare class ChatSessionStore extends Disposable {
     private readonly lifecycleService;
     private readonly userDataProfilesService;
     private readonly configurationService;
-    private readonly storageRoot;
+    private readonly workspaceEditingService;
+    private readonly dialogService;
+    private readonly openerService;
+    private storageRoot;
     private readonly previousEmptyWindowStorageRoot;
     private readonly transferredSessionStorageRoot;
     private readonly storeQueue;
     private storeTask;
     private shuttingDown;
-    constructor(fileService: IFileService, environmentService: IEnvironmentService, logService: ILogService, workspaceContextService: IWorkspaceContextService, telemetryService: ITelemetryService, storageService: IStorageService, lifecycleService: ILifecycleService, userDataProfilesService: IUserDataProfilesService, configurationService: IConfigurationService);
+    constructor(fileService: IFileService, environmentService: IEnvironmentService, logService: ILogService, workspaceContextService: IWorkspaceContextService, telemetryService: ITelemetryService, storageService: IStorageService, lifecycleService: ILifecycleService, userDataProfilesService: IUserDataProfilesService, configurationService: IConfigurationService, workspaceEditingService: IWorkspaceEditingService, dialogService: IDialogService, openerService: IOpenerService);
+    private handleWorkspaceTransition;
+    private migrateSessionsToNewWorkspace;
     storeSessions(sessions: ChatModel[]): Promise<void>;
     storeSessionsMetadataOnly(sessions: ChatModel[]): Promise<void>;
     storeTransferSession(transferData: IChatTransfer, session: ChatModel): Promise<void>;
@@ -37,6 +45,7 @@ export declare class ChatSessionStore extends Disposable {
     getTransferredSessionData(): URI | undefined;
     readTransferredSession(sessionResource: URI): Promise<ISerializedChatDataReference | undefined>;
     private cleanupTransferredSession;
+    private _didReportIssue;
     private writeSession;
     private writeSessionMetadataOnly;
     private flushIndex;
@@ -68,11 +77,11 @@ export interface IChatSessionEntryMetadata {
     sessionId: string;
     title: string;
     lastMessageDate: number;
-    timing?: IChatSessionTiming;
+    timing: IChatSessionTiming;
     initialLocation?: ChatAgentLocation;
     hasPendingEdits?: boolean;
     stats?: IChatSessionStats;
-    lastResponseState?: ResponseModelState;
+    lastResponseState: ResponseModelState;
     /**
      * This only exists because the migrated data from the storage service had empty sessions persisted, and it's impossible to know which ones are
      * currently in use. Now, `clearSession` deletes empty sessions, so old ones shouldn't take up space in the store anymore, but we still need to

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

@@ -10,16 +10,20 @@ import { joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/res
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
 import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';
 import { toFileOperationResult, FileOperationResult } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
 import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
 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 { IUserDataProfilesService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
+import { isEmptyWorkspaceIdentifier } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace';
 import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
 import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { IWorkspaceEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/workspaces/common/workspaceEditing.service';
 import { awaitStatsForSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chat';
 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';
@@ -44,7 +48,10 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
         storageService,
         lifecycleService,
         userDataProfilesService,
-        configurationService
+        configurationService,
+        workspaceEditingService,
+        dialogService,
+        openerService
     ) {
         super();
         this.fileService = fileService;
@@ -56,8 +63,12 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
         this.lifecycleService = lifecycleService;
         this.userDataProfilesService = userDataProfilesService;
         this.configurationService = configurationService;
+        this.workspaceEditingService = workspaceEditingService;
+        this.dialogService = dialogService;
+        this.openerService = openerService;
         this.storeQueue = ( new Sequencer());
         this.shuttingDown = false;
+        this._didReportIssue = false;
         const workspace = this.workspaceContextService.getWorkspace();
         const isEmptyWindow = !workspace.configuration && workspace.folders.length === 0;
         const workspaceId = this.workspaceContextService.getWorkspace().id;
@@ -74,6 +85,12 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
             this.userDataProfilesService.defaultProfile.globalStorageHome,
             "transferredChatSessions"
         );
+        this._register(this.workspaceEditingService.onDidEnterWorkspace(event => {
+            const transitionPromise = this.storeQueue.queue(
+                () => this.handleWorkspaceTransition(event.oldWorkspace, event.newWorkspace)
+            );
+            event.join(transitionPromise);
+        }));
         this._register(this.lifecycleService.onWillShutdown(e => {
             this.shuttingDown = true;
             if (!this.storeTask) {
@@ -81,10 +98,96 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
             }
             e.join(this.storeTask, {
                 id: "join.chatSessionStore",
-                label: ( localize(6352, "Saving chat history"))
+                label: ( localize(7020, "Saving chat history"))
             });
         }));
     }
+    async handleWorkspaceTransition(oldWorkspace, newWorkspace) {
+        const wasEmptyWindow = isEmptyWorkspaceIdentifier(oldWorkspace);
+        const isNewWorkspaceEmpty = isEmptyWorkspaceIdentifier(newWorkspace);
+        const oldWorkspaceId = oldWorkspace.id;
+        const newWorkspaceId = newWorkspace.id;
+        this.logService.info(
+            `ChatSessionStore: Workspace transition from ${oldWorkspaceId} to ${newWorkspaceId}`
+        );
+        const oldStorageRoot = wasEmptyWindow ? joinPath(
+            this.userDataProfilesService.defaultProfile.globalStorageHome,
+            "emptyWindowChatSessions"
+        ) : joinPath(
+            this.environmentService.workspaceStorageHome,
+            oldWorkspaceId,
+            "chatSessions"
+        );
+        const newStorageRoot = isNewWorkspaceEmpty ? joinPath(
+            this.userDataProfilesService.defaultProfile.globalStorageHome,
+            "emptyWindowChatSessions"
+        ) : joinPath(
+            this.environmentService.workspaceStorageHome,
+            newWorkspaceId,
+            "chatSessions"
+        );
+        if (( oldStorageRoot.toString()) === ( newStorageRoot.toString())) {
+            this.storageRoot = newStorageRoot;
+            return;
+        }
+        this.storageRoot = newStorageRoot;
+        await this.migrateSessionsToNewWorkspace(oldStorageRoot, wasEmptyWindow, isNewWorkspaceEmpty);
+    }
+    async migrateSessionsToNewWorkspace(oldStorageRoot, wasEmptyWindow, isNewWorkspaceEmpty) {
+        try {
+            const oldStorageExists = await this.fileService.exists(oldStorageRoot);
+            if (!oldStorageExists) {
+                this.logService.info(
+                    `ChatSessionStore: Old storage location does not exist, skipping migration`
+                );
+                return;
+            }
+            const oldDirectory = await this.fileService.resolve(oldStorageRoot);
+            if (!oldDirectory.children) {
+                this.logService.info(
+                    `ChatSessionStore: No children in old storage location, skipping migration`
+                );
+                return;
+            }
+            this.logService.info(
+                `ChatSessionStore: Found ${oldDirectory.children.length} files in old storage location`
+            );
+            let migratedCount = 0;
+            for (const child of oldDirectory.children) {
+                if (!child.isDirectory && (child.name.endsWith(".json") || child.name.endsWith(".jsonl"))) {
+                    const oldFilePath = child.resource;
+                    const newFilePath = joinPath(this.storageRoot, child.name);
+                    try {
+                        await this.fileService.copy(oldFilePath, newFilePath, false);
+                        migratedCount++;
+                    } catch (e) {
+                        if (toFileOperationResult(e) === FileOperationResult.FILE_MOVE_CONFLICT) {
+                            this.logService.trace(
+                                `ChatSessionStore: Session file ${child.name} already exists at target, skipping`
+                            );
+                        } else {
+                            this.reportError("sessionMigration", `Error migrating chat session file ${child.name}`, e);
+                        }
+                    }
+                }
+            }
+            this.logService.info(
+                `ChatSessionStore: Copied ${migratedCount} chat session files from ${wasEmptyWindow ? "empty window" : ( oldStorageRoot.toString())} to ${isNewWorkspaceEmpty ? "empty window" : ( this.storageRoot.toString())} (originals preserved at old location)`
+            );
+            this.indexCache = undefined;
+            try {
+                await this.flushIndex();
+            } catch (e) {
+                this.reportError(
+                    "migrateWorkspace",
+                    "Error flushing chat session index after workspace migration",
+                    e
+                );
+            }
+        } catch (e) {
+            this.reportError("migrateWorkspace", "Error migrating chat sessions to new workspace", e);
+        }
+    }
     async storeSessions(sessions) {
         if (this.shuttingDown) {
             return;
@@ -241,10 +344,32 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
                     if (!session.dataSerializer) {
                         session.dataSerializer = ( new ChatSessionOperationLog());
                     }
-                    const {
-                        op,
-                        data
-                    } = session.dataSerializer.write(session);
+                    let op;
+                    let data;
+                    try {
+                        ({
+                            op,
+                            data
+                        } = session.dataSerializer.write(session));
+                    } catch (e) {
+                        if (!this._didReportIssue) {
+                            this._didReportIssue = true;
+                            this.dialogService.prompt({
+                                custom: true,
+                                title: ( localize(7021, "Error saving chat session")),
+                                message: ( localize(
+                                    7022,
+                                    "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(7023, "Report Issue")),
+                                    run: () => this.openerService.open("https://github.com/microsoft/vscode/issues/new?template=bug_report.md")
+                                }]
+                            });
+                        }
+                        throw e;
+                    }
                     if (data.byteLength > 0) {
                         await this.fileService.writeFile(storageLocation.log, data, {
                             append: op === "append"
@@ -257,7 +382,8 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
             } else {
                 await this.fileService.writeFile(storageLocation.flat, VSBuffer.fromString(JSON.stringify(session)));
             }
-            index.entries[session.sessionId] = await getSessionMetadata(session);
+            const newMetadata = await getSessionMetadata(session);
+            index.entries[session.sessionId] = newMetadata;
         } catch (e) {
             this.reportError("sessionWrite", "Error writing chat session", e);
         }
@@ -389,15 +515,22 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
                     entries: {}
                 };
             }
-            return this.indexCache;
         } catch (e) {
             this.reportError("invalidIndexJSON", `Index corrupt: ${data}`, e);
             this.indexCache = {
                 version: 1,
                 entries: {}
             };
-            return this.indexCache;
         }
+        for (const entry of ( Object.values(this.indexCache.entries))) {
+            entry.timing ??= {
+                created: entry.lastMessageDate,
+                lastRequestStarted: undefined,
+                lastRequestEnded: entry.lastMessageDate
+            };
+            entry.lastResponseState ??= entry.lastResponseState === ResponseModelState.Pending || entry.lastResponseState === ResponseModelState.NeedsInput ? ResponseModelState.Complete : entry.lastResponseState || ResponseModelState.Complete;
+        }
+        return this.indexCache;
     }
     async getIndex() {
         return this.storeQueue.queue(async () => {
@@ -534,7 +667,7 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
         return this.storageRoot;
     }
 };
-ChatSessionStore = ChatSessionStore_1 = ( __decorate([( __param(0, IFileService)), ( __param(1, IEnvironmentService)), ( __param(2, ILogService)), ( __param(3, IWorkspaceContextService)), ( __param(4, ITelemetryService)), ( __param(5, IStorageService)), ( __param(6, ILifecycleService)), ( __param(7, IUserDataProfilesService)), ( __param(8, IConfigurationService))], ChatSessionStore));
+ChatSessionStore = ChatSessionStore_1 = ( __decorate([( __param(0, IFileService)), ( __param(1, IEnvironmentService)), ( __param(2, ILogService)), ( __param(3, IWorkspaceContextService)), ( __param(4, ITelemetryService)), ( __param(5, IStorageService)), ( __param(6, ILifecycleService)), ( __param(7, IUserDataProfilesService)), ( __param(8, IConfigurationService)), ( __param(9, IWorkspaceEditingService)), ( __param(10, IDialogService)), ( __param(11, IOpenerService))], ChatSessionStore));
 function isChatSessionEntryMetadata(obj) {
     return (!!obj && typeof obj === "object" && typeof obj.sessionId === "string" && typeof obj.title === "string" && typeof obj.lastMessageDate === "number");
 }
@@ -575,7 +708,7 @@ async function getSessionMetadata(session) {
     }
     return {
         sessionId: session.sessionId,
-        title: title || ( localize(6353, "New Chat")),
+        title: title || ( localize(7024, "New Chat")),
         lastMessageDate,
         timing,
         initialLocation: session.initialLocation,

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

@@ -3,6 +3,21 @@ import { assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/
 import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
 import { isUndefinedOrNull } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 
+function prefixError(e, prefix) {
+    e.message = prefix + e.message;
+    if (e.stack) {
+        const nlIdx = e.stack.indexOf("\n");
+        e.stack = nlIdx !== -1 ? `${e.name}: ${e.message}${e.stack.slice(nlIdx)}` : `${e.name}: ${e.message}`;
+    }
+}
+function rethrowWithPathSegment(e, segment) {
+    if (e instanceof Error) {
+        const part = typeof segment === "number" ? `[${segment}]` : `.${segment}`;
+        const needsSep = !e.message.startsWith("[") && !e.message.startsWith(".");
+        prefixError(e, part + (needsSep ? ": " : ""));
+    }
+    throw e;
+}
 var TransformKind;
 (function(TransformKind) {
     TransformKind[TransformKind["Key"] = 0] = "Key";
@@ -34,7 +49,13 @@ function array(schema) {
     return {
         kind: TransformKind.Array,
         itemSchema: schema,
-        extract: from => from?.map(item => schema.extract(item))
+        extract: from => from?.map((item, i) => {
+            try {
+                return schema.extract(item);
+            } catch (e) {
+                rethrowWithPathSegment(e, i);
+            }
+        })
     };
 }
 function object(schema, options) {
@@ -49,7 +70,11 @@ function object(schema, options) {
             }
             const result = Object.create(null);
             for (const [key, transform] of entries) {
-                result[key] = transform.extract(from);
+                try {
+                    result[key] = transform.extract(from);
+                } catch (e) {
+                    rethrowWithPathSegment(e, key);
+                }
             }
             return result;
         }
@@ -152,7 +177,15 @@ class ObjectMutationLog {
         }
         const entries = [];
         const path = [];
-        this._diff(this._transform, path, this._previous, currentValue, entries);
+        try {
+            this._diff(this._transform, path, this._previous, currentValue, entries);
+        } catch (e) {
+            if (e instanceof Error) {
+                const pathStr = ( path.map(s => typeof s === "number" ? `[${s}]` : `.${s}`)).join("") || "<root>";
+                prefixError(e, `error diffing at ${pathStr}: `);
+            }
+            throw e;
+        }
         if (entries.length === 0) {
             return {
                 op: "append",

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

@@ -3,10 +3,11 @@ import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event"
 import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { IProgress } from "@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress";
 import { IChatMessage } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels";
-import { IChatFollowup, IChatProgress, IChatResponseProgressFileTreeData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
+import { IChatFollowup, IChatProgress, IChatResponseProgressFileTreeData, IChatSendRequestOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
 import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
 import { ChatAgentLocation, ChatModeKind } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { Target } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
 import { IChatSlashCommandService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatSlashCommands.service";
 export interface IChatSlashData {
     command: string;
@@ -27,6 +28,7 @@ export interface IChatSlashData {
     silent?: boolean;
     locations: ChatAgentLocation[];
     modes?: ChatModeKind[];
+    target?: Target;
 }
 export interface IChatSlashFragment {
     content: string | {
@@ -34,7 +36,7 @@ export interface IChatSlashFragment {
     };
 }
 export type IChatSlashCallback = {
-    (prompt: string, progress: IProgress<IChatProgress>, history: IChatMessage[], location: ChatAgentLocation, sessionResource: URI, token: CancellationToken): Promise<{
+    (prompt: string, progress: IProgress<IChatProgress>, history: IChatMessage[], location: ChatAgentLocation, sessionResource: URI, token: CancellationToken, options?: IChatSendRequestOptions): Promise<{
         followUp: IChatFollowup[];
     } | void>;
 };
@@ -49,7 +51,7 @@ export declare class ChatSlashCommandService extends Disposable implements IChat
     registerSlashCommand(data: IChatSlashData, command: IChatSlashCallback): IDisposable;
     getCommands(location: ChatAgentLocation, mode: ChatModeKind): Array<IChatSlashData>;
     hasCommand(id: string): boolean;
-    executeCommand(id: string, prompt: string, progress: IProgress<IChatProgress>, history: IChatMessage[], location: ChatAgentLocation, sessionResource: URI, token: CancellationToken): Promise<{
+    executeCommand(id: string, prompt: string, progress: IProgress<IChatProgress>, history: IChatMessage[], location: ChatAgentLocation, sessionResource: URI, token: CancellationToken, options?: IChatSendRequestOptions): Promise<{
         followUp: IChatFollowup[];
     } | void>;
 }

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

@@ -39,7 +39,7 @@ let ChatSlashCommandService = class ChatSlashCommandService extends Disposable {
     hasCommand(id) {
         return ( this._commands.has(id));
     }
-    async executeCommand(id, prompt, progress, history, location, sessionResource, token) {
+    async executeCommand(id, prompt, progress, history, location, sessionResource, token, options) {
         const data = this._commands.get(id);
         if (!data) {
             throw ( new Error("No command with id ${id} NOT registered"));
@@ -50,7 +50,7 @@ let ChatSlashCommandService = class ChatSlashCommandService extends Disposable {
         if (!data.command) {
             throw ( new Error(`No command with id ${id} NOT resolved`));
         }
-        return await data.command(prompt, progress, history, location, sessionResource, token);
+        return await data.command(prompt, progress, history, location, sessionResource, token, options);
     }
 };
 ChatSlashCommandService = ( __decorate([( __param(0, IExtensionService))], ChatSlashCommandService));