@codingame/monaco-vscode-workbench-service-override 37.6.1 → 38.0.1

package/vscode/src/vs/sessions/services/sessions/browser/sessionsManagementService.js

@@ -3,30 +3,33 @@ import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { raceCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { CancellationTokenSource, CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
-import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { isCancellationError, CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
 import { Disposable, DisposableMap, DisposableStore, toDisposable, MutableDisposable } 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 { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
 import { agentHostAuthority } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
 import { IRemoteAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
 import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { IChatWidgetHistoryService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/widget/chatWidgetHistoryService.service';
 import { dedupeMigratedCopilotCliSessions, getCopilotCliSessionRawId, buildHostLocalEventsPath } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/copilotCliEventsUri';
-import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService';
 import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 import { getSessionReferenceResource } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionReference';
 import { WorkspaceNotTrustedError } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
-import { SessionStatus, ChatModelSource } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { SessionStatus, ChatModelSource, isActiveSessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
 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 { IWorkspaceTrustManagementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/platform/path/common/pathService.service';
 
 const LAST_USED_QUICK_CHAT_SESSION_TYPE_STORAGE_KEY = "sessions.quickChat.lastUsedSessionType";
 let SessionsManagementService = class SessionsManagementService extends Disposable {
@@ -39,7 +42,8 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
         storageService,
         pathService,
         remoteAgentHostService,
-        workspaceTrustManagementService
+        workspaceTrustManagementService,
+        notificationService
     ) {
         super();
         this.logService = logService;
@@ -51,6 +55,7 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
         this.pathService = pathService;
         this.remoteAgentHostService = remoteAgentHostService;
         this.workspaceTrustManagementService = workspaceTrustManagementService;
+        this.notificationService = notificationService;
         this._onDidChangeSessions = this._register(( new Emitter()));
         this.onDidChangeSessions = this._onDidChangeSessions.event;
         this._onDidStartSession = this._register(( new Emitter()));
@@ -75,6 +80,7 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
         this.onDidChangeSessionTypes = this._onDidChangeSessionTypes.event;
         this._onDidReplaceSession = this._register(( new Emitter()));
         this.onDidReplaceSession = this._onDidReplaceSession.event;
+        this._explicitlyMarkedUnreadMainChats = ( new ResourceMap());
         this._onDidDiscardNewSession = this._register(( new Emitter()));
         this.onDidDiscardNewSession = this._onDidDiscardNewSession.event;
         this._onDidReplaceNewDraftSession = this._register(( new Emitter()));
@@ -124,13 +130,23 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
         for (const provider of e.removed) {
             this._providerListeners.deleteAndDispose(provider.id);
         }
-        if (e.added.length) {
-            this._subscribeToProviders(e.added);
-        }
+        const added = this._subscribeToProviders(e.added);
+        this._onDidChangeSessions.fire({
+            added,
+            removed: [],
+            changed: []
+        });
     }
     _subscribeToProviders(providers) {
+        const added = [];
         for (const provider of providers) {
+            const sessions = provider.getSessions();
+            if (this.sessionsProvidersService.getProvider(provider.id) !== provider) {
+                continue;
+            }
             const disposables = ( new DisposableStore());
+            this._providerListeners.set(provider.id, disposables);
+            added.push(...sessions);
             disposables.add(
                 provider.onDidChangeSessions(e => this.onDidChangeSessionsFromSessionsProviders(e))
             );
@@ -142,10 +158,11 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
             if (provider.onDidChangeSessionTypes) {
                 disposables.add(provider.onDidChangeSessionTypes(() => this._updateSessionTypes()));
             }
-            this._providerListeners.set(provider.id, disposables);
         }
+        return added;
     }
     _handleDidReplaceSession(from, to) {
+        this._explicitlyMarkedUnreadMainChats.delete(from.resource);
         this.chatWidgetHistoryService.moveHistory(ChatAgentLocation.Chat, from.sessionId, to.sessionId);
         this._onDidReplaceSession.fire({
             from,
@@ -190,25 +207,67 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
         return resource;
     }
     getSessions() {
-        return this._dedupeMigratedCopilotCliSessions(this._getMergedSessions());
+        const sessions = this._getMergedSessions();
+        for (const {
+            session
+        } of ( this._inFlightNewSessionRequests.values())) {
+            if (!( sessions.some(
+                candidate => this.uriIdentityService.extUri.isEqual(candidate.resource, session.resource)
+            ))) {
+                sessions.push(session);
+            }
+        }
+        return this._dedupeMigratedCopilotCliSessions(sessions);
     }
     getInFlightNewSessionRequests() {
         return Array.from(( this._inFlightNewSessionRequests.values()), entry => entry.session);
     }
-    trackInFlightNewSessionRequest(session) {
+    getInFlightNewSessionRequest(resource) {
+        return this._inFlightNewSessionRequests.get(resource)?.input;
+    }
+    trackInFlightNewSessionRequest(session, options) {
         const entry = this._inFlightNewSessionRequests.get(session.resource);
         if (entry) {
             entry.count++;
         } else {
+            const published = !( this._getMergedSessions().some(
+                candidate => this.uriIdentityService.extUri.isEqual(candidate.resource, session.resource)
+            ));
             this._inFlightNewSessionRequests.set(session.resource, {
                 session,
+                input: options ? {
+                    query: options.query,
+                    attachedContext: options.attachedContext?.slice()
+                } : undefined,
+                published,
                 count: 1
             });
+            if (published) {
+                this._onDidChangeSessions.fire({
+                    added: [session],
+                    removed: [],
+                    changed: []
+                });
+            }
         }
         return toDisposable(() => {
             const current = this._inFlightNewSessionRequests.get(session.resource);
             if (current?.count === 1) {
                 this._inFlightNewSessionRequests.delete(session.resource);
+                if (current.published) {
+                    const listedSession = this._getMergedSessions().find(
+                        candidate => this.uriIdentityService.extUri.isEqual(candidate.resource, session.resource)
+                    );
+                    this._onDidChangeSessions.fire(listedSession ? {
+                        added: [],
+                        removed: [],
+                        changed: [listedSession]
+                    } : {
+                        added: [],
+                        removed: [],
+                        changed: []
+                    });
+                }
             } else if (current) {
                 current.count--;
             }
@@ -250,6 +309,10 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
         }
         return undefined;
     }
+    getSessionContextReference(resource) {
+        const ownedChat = this.getSessionForChatResource(resource);
+        return ownedChat ? this._getProvider(ownedChat.session)?.getSessionContextReference?.(ownedChat.chat.resource) : undefined;
+    }
     getAllSessionTypes() {
         return [...this._sessionTypes];
     }
@@ -370,7 +433,7 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
         let provider;
         let workspace;
         let sessionTypeId;
-        const requiresWorktreeConfiguration = options?.isolationMode === "worktree" || options?.worktreeBranchTrack !== undefined || options?.worktreeCreateNewBranch !== undefined || options?.branch !== undefined;
+        const requiresWorktreeConfiguration = options?.isolationMode === "worktree" || options?.branch !== undefined || options?.pullRequestUrl !== undefined;
         const resolveSessionTypeId = candidate => {
             const sessionTypes = candidate.getSessionTypes(folderUri);
             if (options?.sessionTypeId) {
@@ -443,7 +506,7 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
         const session = provider.createNewSession(
             folderUri,
             sessionTypeId,
-            this._providerCreateSessionOptions(provider, options)
+            this._providerCreateSessionOptions(provider, sessionTypeId, options)
         );
         if (previousNewSession && previousNewSession.sessionId !== session.sessionId) {
             this._getProvider(previousNewSession)?.deleteNewSession(previousNewSession.sessionId);
@@ -460,12 +523,17 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
             provider,
             sessionTypeId
         } = this._resolveProviderForNewSession(folderUri, options);
+        if (provider.automations?.catalogueState.get() !== "ready") {
+            throw ( new Error(( localize(
+                6336,
+                "The selected provider does not currently provide Automation configuration."
+            ))));
+        }
         const previousAutomationSession = this._automationSession.get();
-        const session = provider.createNewSession(
-            folderUri,
-            sessionTypeId,
-            this._providerCreateSessionOptions(provider, options)
-        );
+        const session = provider.createNewSession(folderUri, sessionTypeId, {
+            ...this._providerCreateSessionOptions(provider, sessionTypeId, options),
+            isAutomationDraft: true
+        });
         if (previousAutomationSession && previousAutomationSession.sessionId !== session.sessionId) {
             this._getProvider(previousAutomationSession)?.deleteNewSession(previousAutomationSession.sessionId);
         }
@@ -525,7 +593,10 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
             sessionTypeId
         } = this._resolveProviderForQuickChat(options);
         const previousNewSession = this._newSession.get();
-        const session = provider.createQuickChat(sessionTypeId, this._providerCreateSessionOptions(provider, options));
+        const session = provider.createQuickChat(
+            sessionTypeId,
+            this._providerCreateSessionOptions(provider, sessionTypeId, options)
+        );
         this._newSession.set(session, undefined);
         this.storageService.store(
             LAST_USED_QUICK_CHAT_SESSION_TYPE_STORAGE_KEY,
@@ -543,26 +614,64 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
             provider,
             sessionTypeId
         } = this._resolveProviderForQuickChat(options);
+        if (provider.automations?.catalogueState.get() !== "ready") {
+            throw ( new Error(( localize(
+                6336,
+                "The selected provider does not currently provide Automation configuration."
+            ))));
+        }
         const previousAutomationSession = this._automationSession.get();
-        const session = provider.createQuickChat(sessionTypeId, this._providerCreateSessionOptions(provider, options));
+        const session = provider.createQuickChat(sessionTypeId, {
+            ...this._providerCreateSessionOptions(provider, sessionTypeId, options),
+            isAutomationDraft: true
+        });
         if (previousAutomationSession && previousAutomationSession.sessionId !== session.sessionId) {
             this._getProvider(previousAutomationSession)?.deleteNewSession(previousAutomationSession.sessionId);
         }
         this._automationSession.set(session, undefined);
         return session;
     }
-    _providerCreateSessionOptions(provider, options) {
+    _providerCreateSessionOptions(provider, sessionTypeId, options) {
         const sessionTemplate = options?.sessionTemplate ?? options?.automationConfiguration?.sessionTemplate;
         if (sessionTemplate && provider.supportsAutomationSessionConfiguration !== true) {
             throw ( new Error(
                 `Sessions provider '${provider.id}' does not support Automation session templates.`
             ));
         }
+        if (options?.modelConfiguration && !options.modelId) {
+            throw ( new Error("Session model configuration requires a model identifier."));
+        }
+        if (options?.modelConfiguration && provider.supportsModelConfigurationForCreation !== true) {
+            throw ( new Error(
+                `Sessions provider '${provider.id}' does not support model configuration during session creation.`
+            ));
+        }
+        if (options?.permissionId && provider.supportsPermissionsForCreation !== true) {
+            throw ( new Error(
+                `Sessions provider '${provider.id}' does not support permission '${options.permissionId}' for session type '${sessionTypeId}'.`
+            ));
+        }
         const automationConfiguration = sessionTemplate ? {
             sessionTemplate
         } : options?.automationConfiguration;
         return {
             metadata: options?.metadata,
+            ...(options?.createdBySession ? {
+                createdBySession: options.createdBySession
+            } : {}),
+            ...(options?.modelId && options.modelConfiguration ? {
+                modelId: options.modelId,
+                modelConfiguration: options.modelConfiguration
+            } : {}),
+            ...(options?.permissionId ? {
+                permissionId: options.permissionId
+            } : {}),
+            ...(options?.modeId ? {
+                modeId: options.modeId
+            } : {}),
+            ...(options?.pullRequestUrl ? {
+                pullRequestUrl: options.pullRequestUrl
+            } : {}),
             ...(automationConfiguration ? {
                 automationConfiguration
             } : {})
@@ -636,7 +745,7 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
                 remainingAttachments = remaining;
             }
         }
-        const isTroubleshoot = /^\s*\/troubleshoot\b/.test(options.query);
+        const isTroubleshoot = /^\s*\/troubleshoot(?=\s|$)/.test(options.query);
         if (!isTroubleshoot && referencedResources.length === 0) {
             return options;
         }
@@ -672,17 +781,21 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
             throw ( new Error(`Sessions provider '${session.providerId}' not found`));
         }
         const isNewSessionRequest = session.status.get() === SessionStatus.Untitled;
-        const inFlightRequest = isNewSessionRequest ? this.trackInFlightNewSessionRequest(session) : undefined;
+        const inFlightRequest = isNewSessionRequest ? this.trackInFlightNewSessionRequest(session, options) : undefined;
         if (options.background) {
             this._newSession.set(undefined, undefined);
             void this._prepareAndSendNewChatRequestInBackground(provider, session, options).catch(e => {
-                this.logService.error("[SessionsManagement] Failed to send background request:", e);
+                if (!isCancellationError(e) && !(e instanceof WorkspaceNotTrustedError)) {
+                    this.logService.error("[SessionsManagement] Failed to send background request:", e);
+                    this.notificationService.error(( localize(6337, "Failed to start session: {0}", toErrorMessage(e))));
+                }
             }).finally(() => inFlightRequest?.dispose());
             return;
         }
         const requestActivity = ( new MutableDisposable());
         try {
             requestActivity.value = provider.startNewSessionRequest?.(session.sessionId);
+            const newSessionConfig = provider.getNewSessionConfig ? await provider.getNewSessionConfig(session.sessionId) : undefined;
             ({
                 provider,
                 session
@@ -710,6 +823,7 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
                 chat,
                 isNewSession: true,
                 isNewChat: true,
+                newSessionConfig,
                 options
             });
         } finally {
@@ -775,12 +889,10 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
         if (requestActivity) {
             requestActivity.value = preparedRequestActivity;
         }
-        if (replaceCurrentDraft) {
-            this._onDidReplaceNewDraftSession.fire({
-                from: originalSession,
-                to: preparedSession
-            });
-        }
+        this._onDidReplaceNewDraftSession.fire({
+            from: originalSession,
+            to: preparedSession
+        });
         return {
             provider: preparedProvider,
             session: preparedSession
@@ -801,14 +913,14 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
         const session = provider.createNewSession(
             folderUri,
             sessionTypeId,
-            this._providerCreateSessionOptions(provider, createOptions)
+            this._providerCreateSessionOptions(provider, sessionTypeId, createOptions)
         );
         this._unlistedNewSessions.set(session.resource, session);
         const requestActivity = ( new MutableDisposable());
         try {
             try {
                 requestActivity.value = isDeferredNewSessionRequestOptions(options) ? provider.startNewSessionRequest?.(session.sessionId, options.activity) : provider.startNewSessionRequest?.(session.sessionId);
-                createOptions?.onSessionCreated?.(session);
+                await createOptions?.onSessionCreated?.(session);
             } catch (error) {
                 provider.deleteNewSession(session.sessionId);
                 throw error;
@@ -834,7 +946,16 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
             provider,
             sessionTypeId
         } = this._resolveProviderForQuickChat(createOptions);
-        const session = provider.createQuickChat(sessionTypeId, this._providerCreateSessionOptions(provider, createOptions));
+        const session = provider.createQuickChat(
+            sessionTypeId,
+            this._providerCreateSessionOptions(provider, sessionTypeId, createOptions)
+        );
+        try {
+            await createOptions?.onSessionCreated?.(session);
+        } catch (error) {
+            provider.deleteNewSession(session.sessionId);
+            throw error;
+        }
         return this._configureAndSendNewSession(provider, session, options, createOptions, false, token);
     }
     async _configureAndSendNewSession(
@@ -871,8 +992,9 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
             if (token.isCancellationRequested) {
                 throw ( new CancellationError());
             }
+            const newSessionConfig = provider.getNewSessionConfig ? await raceCancellationError(provider.getNewSessionConfig(session.sessionId), token) : undefined;
             return await raceCancellationError(
-                this._sendNewChatRequestInBackground(provider, session, resolvedOptions, token),
+                this._sendNewChatRequestInBackground(provider, session, resolvedOptions, newSessionConfig, token),
                 token
             );
         } catch (e) {
@@ -905,12 +1027,10 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
         if (createOptions?.permissionLevel) {
             provider.setPermissionLevel?.(session.sessionId, createOptions.permissionLevel);
         }
-        if (supportsWorktreeConfiguration && (createOptions?.isolationMode || createOptions?.worktreeBranchTrack !== undefined || createOptions?.worktreeCreateNewBranch !== undefined || createOptions?.branch)) {
+        if (supportsWorktreeConfiguration && (createOptions?.isolationMode || createOptions?.branch)) {
             if (provider.setWorktreeConfiguration) {
                 await raceCancellationError(provider.setWorktreeConfiguration(session.sessionId, {
                     isolationMode: createOptions.isolationMode,
-                    worktreeBranchTrack: createOptions.worktreeBranchTrack,
-                    worktreeCreateNewBranch: createOptions.worktreeCreateNewBranch,
                     branch: createOptions.branch
                 }), token);
             } else {
@@ -920,18 +1040,6 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
                         token
                     );
                 }
-                if (createOptions.worktreeBranchTrack !== undefined && provider.setWorktreeBranchTrack) {
-                    await raceCancellationError(
-                        provider.setWorktreeBranchTrack(session.sessionId, createOptions.worktreeBranchTrack),
-                        token
-                    );
-                }
-                if (createOptions.worktreeCreateNewBranch !== undefined && provider.setWorktreeCreateNewBranch) {
-                    await raceCancellationError(
-                        provider.setWorktreeCreateNewBranch(session.sessionId, createOptions.worktreeCreateNewBranch),
-                        token
-                    );
-                }
                 if (createOptions.branch && provider.setBranch) {
                     await raceCancellationError(provider.setBranch(session.sessionId, createOptions.branch), token);
                 }
@@ -1005,17 +1113,24 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
         let graduatingProvider = provider;
         let graduatingSession = session;
         try {
+            const newSessionConfig = provider.getNewSessionConfig ? await provider.getNewSessionConfig(session.sessionId) : undefined;
             ({
                 provider: graduatingProvider,
                 session: graduatingSession
             } = await this._prepareNewSessionForSend(provider, session, undefined, false, options.query));
-            await this._sendNewChatRequestInBackground(graduatingProvider, graduatingSession, options);
+            await this._sendNewChatRequestInBackground(graduatingProvider, graduatingSession, options, newSessionConfig);
         } catch (error) {
             graduatingProvider.deleteNewSession(graduatingSession.sessionId);
             throw error;
         }
     }
-    async _sendNewChatRequestInBackground(provider, session, options, token = CancellationToken.None) {
+    async _sendNewChatRequestInBackground(
+        provider,
+        session,
+        options,
+        newSessionConfig,
+        token = CancellationToken.None
+    ) {
         if (token.isCancellationRequested) {
             throw ( new CancellationError());
         }
@@ -1049,6 +1164,7 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
             chat,
             isNewSession: true,
             isNewChat: true,
+            newSessionConfig,
             options
         });
         return updatedSession;
@@ -1113,7 +1229,10 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
         return this.sessionsProvidersService.getProviders().find(p => p.id === session.providerId);
     }
     async cancelCurrentRequest(session) {
-        const resource = session.mainChat.get().resource;
+        await this._cancelChatRequest(session.mainChat.get());
+    }
+    async _cancelChatRequest(chat) {
+        const resource = chat.resource;
         const modelRef = await this.chatService.acquireOrLoadSession(
             resource,
             ChatAgentLocation.Chat,
@@ -1121,7 +1240,7 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
             "sessionsManagement:cancel"
         );
         if (!modelRef) {
-            throw ( new Error(( localize(5024, "Failed to load chat session for cancellation."))));
+            throw ( new Error(( localize(6338, "Failed to load chat session for cancellation."))));
         }
         try {
             await this.chatService.cancelCurrentRequestForSession(resource, "sessionsManagement");
@@ -1130,27 +1249,95 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
         }
     }
     async archiveSession(session) {
+        const activeChats = session.chats.get().filter(chat => isActiveSessionStatus(chat.status.get()));
+        if (activeChats.length === 0 && isActiveSessionStatus(session.status.get())) {
+            await this._cancelChatRequest(session.mainChat.get());
+        }
+        for (const chat of activeChats) {
+            await this._cancelChatRequest(chat);
+        }
         await this._getProvider(session)?.archiveSession(session.sessionId);
         this._onDidArchiveSession.fire(session);
     }
+    getSessionWorktreeDiskUsage(session) {
+        return this._getProvider(session)?.getSessionWorktreeDiskUsage?.(session.sessionId) ?? Promise.resolve(undefined);
+    }
     async unarchiveSession(session) {
         await this._getProvider(session)?.unarchiveSession(session.sessionId);
         this._onDidUnarchiveSession.fire(session);
     }
+    async archiveChat(session, chat) {
+        const provider = this._getProvider(session);
+        if (!provider?.archiveChat) {
+            throw ( new Error(
+                `Provider does not support archiving chats for session: ${session.sessionId}`
+            ));
+        }
+        await provider.archiveChat(session.sessionId, chat.resource);
+    }
+    async unarchiveChat(session, chat) {
+        const provider = this._getProvider(session);
+        if (!provider?.unarchiveChat) {
+            throw ( new Error(
+                `Provider does not support restoring chats for session: ${session.sessionId}`
+            ));
+        }
+        await provider.unarchiveChat(session.sessionId, chat.resource);
+    }
     async setSessionReadState(session, isRead) {
+        if (isRead) {
+            this._explicitlyMarkedUnreadMainChats.delete(session.resource);
+        }
         await this._getProvider(session)?.setSessionReadState(session.sessionId, isRead);
     }
-    markRead(session) {
-        return this.setSessionReadState(session, true);
+    async markChatRead(session, chat) {
+        return this._getProvider(session)?.setChatReadState?.(session.sessionId, chat.resource, true) ?? false;
+    }
+    markRead(session, options) {
+        if (options?.preserveExplicitUnread && ( this._explicitlyMarkedUnreadMainChats.has(session.resource)) && this._explicitlyMarkedUnreadMainChats.get(session.resource) === this._getMainChatReadMarker(session)) {
+            return Promise.resolve();
+        }
+        return this._setMainChatReadState(session, true);
     }
-    markUnread(session) {
-        return this.setSessionReadState(session, false);
+    _getMainChatReadMarker(session) {
+        const chat = session.mainChat.get();
+        return (chat.lastTurnEnd.get() ?? chat.updatedAt.get())?.getTime();
+    }
+    async markUnread(session) {
+        const provider = this._getProvider(session);
+        if (!provider) {
+            return;
+        }
+        const hadExplicitUnread = ( this._explicitlyMarkedUnreadMainChats.has(session.resource));
+        const previousMarker = this._explicitlyMarkedUnreadMainChats.get(session.resource);
+        this._explicitlyMarkedUnreadMainChats.set(session.resource, this._getMainChatReadMarker(session));
+        try {
+            await this._setMainChatReadState(session, false, provider);
+        } catch (error) {
+            if (hadExplicitUnread) {
+                this._explicitlyMarkedUnreadMainChats.set(session.resource, previousMarker);
+            } else {
+                this._explicitlyMarkedUnreadMainChats.delete(session.resource);
+            }
+            throw error;
+        }
+    }
+    _setMainChatReadState(session, isRead, provider = this._getProvider(session)) {
+        if (isRead) {
+            this._explicitlyMarkedUnreadMainChats.delete(session.resource);
+        }
+        if (!provider) {
+            return Promise.resolve(false);
+        }
+        const mainChat = session.mainChat.get();
+        return provider.setChatReadState ? provider.setChatReadState(session.sessionId, mainChat.resource, isRead) : provider.setSessionReadState(session.sessionId, isRead);
     }
     async markAllRead(sessions) {
         await Promise.all(sessions.map(session => this.setSessionReadState(session, true)));
     }
     async deleteSession(session) {
         await this._getProvider(session)?.deleteSession(session.sessionId);
+        this._explicitlyMarkedUnreadMainChats.delete(session.resource);
         this._onDidDeleteSession.fire(session);
     }
     async deleteSessions(sessions) {
@@ -1172,6 +1359,7 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
             try {
                 await provider.deleteSessions(providerSessions.map(session => session.sessionId));
                 for (const session of providerSessions) {
+                    this._explicitlyMarkedUnreadMainChats.delete(session.resource);
                     this._onDidDeleteSession.fire(session);
                 }
             } catch (error) {
@@ -1183,10 +1371,16 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
         }
     }
     async deleteChat(session, chatUri, options) {
-        const deleted = await this._getProvider(session)?.deleteChat(session.sessionId, chatUri, options);
+        const deletedChat = ( Object.freeze({
+            session,
+            sessionResource: session.resource,
+            chatResource: chatUri
+        }));
+        const deleted = (await this._getProvider(session)?.deleteChat(session.sessionId, chatUri, options)) ?? false;
         if (deleted) {
-            this._onDidDeleteChat.fire(session);
+            this._onDidDeleteChat.fire(deletedChat);
         }
+        return deleted;
     }
     async renameChat(session, chatUri, title) {
         await this._getProvider(session)?.renameChat(session.sessionId, chatUri, title);
@@ -1196,15 +1390,39 @@ let SessionsManagementService = class SessionsManagementService extends Disposab
         await this._getProvider(session)?.renameSession(session.sessionId, title);
         this._onDidRenameSession.fire(session);
     }
+    async listCanvases(session, chat) {
+        const provider = this._getProvider(session);
+        if (!session.capabilities.get().supportsCanvases || !provider?.listCanvases) {
+            return [];
+        }
+        return provider.listCanvases(session.sessionId, chat.resource);
+    }
+    async openCanvas(session, chat, canvas, instanceId) {
+        const provider = this._getProvider(session);
+        if (!session.capabilities.get().supportsCanvases || !provider?.openCanvas) {
+            throw ( new Error(( localize(6339, "Opening canvases is not supported for this session."))));
+        }
+        await provider.openCanvas(session.sessionId, chat.resource, canvas, instanceId);
+    }
     async removeSessionArtifact(session, artifactId) {
         const provider = this._getProvider(session);
         if (!session.capabilities.get().supportsRemoveArtifacts || !provider?.removeSessionArtifact) {
-            throw ( new Error(( localize(5025, "Removing artifacts is not supported for this session."))));
+            throw ( new Error(( localize(6340, "Removing artifacts is not supported for this session."))));
         }
         await provider.removeSessionArtifact(session.sessionId, artifactId);
     }
+    async importSession(session) {
+        const provider = this._getProvider(session);
+        if (!session.isExternal?.get()) {
+            return;
+        }
+        if (!session.capabilities.get().supportsImport || !provider?.importSession) {
+            throw ( new Error(( localize(6341, "Importing is not supported for this session."))));
+        }
+        await provider.importSession(session.sessionId);
+    }
 };
-SessionsManagementService = ( __decorate([( __param(0, ILogService)), ( __param(1, ISessionsProvidersService)), ( __param(2, IUriIdentityService)), ( __param(3, IChatService)), ( __param(4, IChatWidgetHistoryService)), ( __param(5, IStorageService)), ( __param(6, IPathService)), ( __param(7, IRemoteAgentHostService)), ( __param(8, IWorkspaceTrustManagementService))], SessionsManagementService));
+SessionsManagementService = ( __decorate([( __param(0, ILogService)), ( __param(1, ISessionsProvidersService)), ( __param(2, IUriIdentityService)), ( __param(3, IChatService)), ( __param(4, IChatWidgetHistoryService)), ( __param(5, IStorageService)), ( __param(6, IPathService)), ( __param(7, IRemoteAgentHostService)), ( __param(8, IWorkspaceTrustManagementService)), ( __param(9, INotificationService))], SessionsManagementService));
 function isDeferredNewSessionRequestOptions(options) {
     return options.kind === "deferred";
 }