chatSessions when clause (microsoft#257900)

chatSessions when clause

Author: joshspicer

src/vs/workbench/contrib/chat/browser/chatSessions.contribution.ts

@@ -8,6 +8,7 @@ import { Codicon } from '../../../../base/common/codicons.js';
 import { Emitter, Event } from '../../../../base/common/event.js';
 import { Disposable, IDisposable } from '../../../../base/common/lifecycle.js';
 import { localize } from '../../../../nls.js';
+import { ContextKeyExpr, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
 import { InstantiationType, registerSingleton } from '../../../../platform/instantiation/common/extensions.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { ILogService } from '../../../../platform/log/common/log.js';
@@ -104,11 +105,13 @@ class ContributedChatSessionData implements IDisposable {
 		readonly session: ChatSession,
 		readonly chatSessionType: string,
 		readonly id: string,
-		onWillDispose: (session: ChatSession, chatSessionType: string, id: string) => void
+		private readonly onWillDispose: (session: ChatSession, chatSessionType: string, id: string) => void
 	) {
 	}
 
 	dispose(): void {
+		this.onWillDispose(this.session, this.chatSessionType, this.id);
+		this.session.dispose();
 	}
 }
 
@@ -121,33 +124,139 @@ export class ChatSessionsService extends Disposable implements IChatSessionsServ
 	readonly onDidChangeItemsProviders: Event<IChatSessionItemProvider> = this._onDidChangeItemsProviders.event;
 	private readonly _contentProviders: Map<string, IChatSessionContentProvider> = new Map();
 	private readonly _contributions: Map<string, IChatSessionsExtensionPoint> = new Map();
+	private readonly _dynamicAgentDisposables: Map<string, IDisposable> = new Map();
+	private readonly _contextKeys = new Set<string>();
 	private readonly _onDidChangeSessionItems = this._register(new Emitter<string>());
 	readonly onDidChangeSessionItems: Event<string> = this._onDidChangeSessionItems.event;
+	private readonly _onDidChangeAvailability = this._register(new Emitter<void>());
+	readonly onDidChangeAvailability: Event<void> = this._onDidChangeAvailability.event;
 
 	constructor(
 		@ILogService private readonly _logService: ILogService,
 		@IInstantiationService private readonly _instantiationService: IInstantiationService,
 		@IChatAgentService private readonly _chatAgentService: IChatAgentService,
 		@IExtensionService private readonly _extensionService: IExtensionService,
+		@IContextKeyService private readonly _contextKeyService: IContextKeyService,
 	) {
 		super();
+
+		// Listen for context changes and re-evaluate contributions
+		this._register(Event.filter(this._contextKeyService.onDidChangeContext, e => e.affectsSome(this._contextKeys))(() => {
+			this._evaluateAvailability();
+		}));
 	}
 	public registerContribution(contribution: IChatSessionsExtensionPoint): IDisposable {
 		if (this._contributions.has(contribution.id)) {
 			this._logService.warn(`Chat session contribution with id '${contribution.id}' is already registered.`);
 			return { dispose: () => { } };
 		}
+
+		// Track context keys from the when condition
+		if (contribution.when) {
+			const whenExpr = ContextKeyExpr.deserialize(contribution.when);
+			if (whenExpr) {
+				for (const key of whenExpr.keys()) {
+					this._contextKeys.add(key);
+				}
+			}
+		}
+
 		this._contributions.set(contribution.id, contribution);
-		const dynamicAgentDisposable = this.registerDynamicAgent(contribution);
+
+		// Register dynamic agent if the when condition is satisfied
+		this._registerDynamicAgentIfAvailable(contribution);
+
 		return {
 			dispose: () => {
 				this._contributions.delete(contribution.id);
-				dynamicAgentDisposable.dispose();
+				this._disposeDynamicAgent(contribution.id);
 			}
 		};
 	}
 
-	private registerDynamicAgent(contribution: IChatSessionsExtensionPoint): IDisposable {
+	private _isContributionAvailable(contribution: IChatSessionsExtensionPoint): boolean {
+		if (!contribution.when) {
+			return true;
+		}
+
+		const whenExpr = ContextKeyExpr.deserialize(contribution.when);
+		return !whenExpr || this._contextKeyService.contextMatchesRules(whenExpr);
+	}
+
+	private _registerDynamicAgentIfAvailable(contribution: IChatSessionsExtensionPoint): void {
+		if (this._isContributionAvailable(contribution)) {
+			const disposable = this._registerDynamicAgent(contribution);
+			this._dynamicAgentDisposables.set(contribution.id, disposable);
+		}
+	}
+
+	private _disposeDynamicAgent(contributionId: string): void {
+		const disposable = this._dynamicAgentDisposables.get(contributionId);
+		if (disposable) {
+			disposable.dispose();
+			this._dynamicAgentDisposables.delete(contributionId);
+		}
+	}
+
+	private _evaluateAvailability(): void {
+		let hasChanges = false;
+
+		for (const contribution of this._contributions.values()) {
+			const isCurrentlyRegistered = this._dynamicAgentDisposables.has(contribution.id);
+			const shouldBeRegistered = this._isContributionAvailable(contribution);
+
+			if (isCurrentlyRegistered && !shouldBeRegistered) {
+				// Should be unregistered
+				this._disposeDynamicAgent(contribution.id);
+				// Also dispose any cached sessions for this contribution
+				this._disposeSessionsForContribution(contribution.id);
+				hasChanges = true;
+			} else if (!isCurrentlyRegistered && shouldBeRegistered) {
+				// Should be registered
+				this._registerDynamicAgentIfAvailable(contribution);
+				hasChanges = true;
+			}
+		}
+
+		// Fire events to notify UI about provider availability changes
+		if (hasChanges) {
+			// Fire the main availability change event
+			this._onDidChangeAvailability.fire();
+
+			// Notify that the list of available item providers has changed
+			for (const provider of this._itemsProviders.values()) {
+				this._onDidChangeItemsProviders.fire(provider);
+			}
+
+			// Notify about session items changes for all chat session types
+			for (const contribution of this._contributions.values()) {
+				this._onDidChangeSessionItems.fire(contribution.id);
+			}
+		}
+	}
+
+	private _disposeSessionsForContribution(contributionId: string): void {
+		// Find and dispose all sessions that belong to this contribution
+		const sessionsToDispose: string[] = [];
+		for (const [sessionKey, sessionData] of this._sessions) {
+			if (sessionData.chatSessionType === contributionId) {
+				sessionsToDispose.push(sessionKey);
+			}
+		}
+
+		if (sessionsToDispose.length > 0) {
+			this._logService.info(`Disposing ${sessionsToDispose.length} cached sessions for contribution '${contributionId}' due to when clause change`);
+		}
+
+		for (const sessionKey of sessionsToDispose) {
+			const sessionData = this._sessions.get(sessionKey);
+			if (sessionData) {
+				sessionData.dispose(); // This will call _onWillDisposeSession and clean up
+			}
+		}
+	}
+
+	private _registerDynamicAgent(contribution: IChatSessionsExtensionPoint): IDisposable {
 		const { id, name, displayName, description, extensionDescription } = contribution;
 		const { identifier: extensionId, name: extensionName, displayName: extensionDisplayName, publisher: extensionPublisherId } = extensionDescription;
 		const agentData: IChatAgentData = {
@@ -178,14 +287,26 @@ export class ChatSessionsService extends Disposable implements IChatSessionsServ
 	}
 
 	getChatSessionContributions(): IChatSessionsExtensionPoint[] {
-		return Array.from(this._contributions.values());
+		return Array.from(this._contributions.values()).filter(contribution =>
+			this._isContributionAvailable(contribution)
+		);
 	}
 
 	getChatSessionItemProviders(): IChatSessionItemProvider[] {
-		return [...this._itemsProviders.values()];
+		return [...this._itemsProviders.values()].filter(provider => {
+			// Check if the provider's corresponding contribution is available
+			const contribution = this._contributions.get(provider.chatSessionType);
+			return !contribution || this._isContributionAvailable(contribution);
+		});
 	}
 
 	async canResolveItemProvider(chatViewType: string) {
+		// First check if the contribution is available based on its when clause
+		const contribution = this._contributions.get(chatViewType);
+		if (contribution && !this._isContributionAvailable(contribution)) {
+			return false;
+		}
+
 		if (this._itemsProviders.has(chatViewType)) {
 			return true;
 		}
@@ -201,6 +322,12 @@ export class ChatSessionsService extends Disposable implements IChatSessionsServ
 	}
 
 	async canResolveContentProvider(chatViewType: string) {
+		// First check if the contribution is available based on its when clause
+		const contribution = this._contributions.get(chatViewType);
+		if (contribution && !this._isContributionAvailable(contribution)) {
+			return false;
+		}
+
 		if (this._contentProviders.has(chatViewType)) {
 			return true;
 		}
@@ -283,15 +410,9 @@ export class ChatSessionsService extends Disposable implements IChatSessionsServ
 		this._sessions.set(sessionKey, sessionData);
 
 		return session;
-	}
-
-	private _onWillDisposeSession(session: ChatSession, chatSessionType: string, id: string): void {
+	} private _onWillDisposeSession(session: ChatSession, chatSessionType: string, id: string): void {
 		const sessionKey = `${chatSessionType}_${id}`;
-		const sessionData = this._sessions.get(sessionKey);
-		if (sessionData) {
-			this._sessions.delete(sessionKey);
-			sessionData.dispose();
-		}
+		this._sessions.delete(sessionKey);
 	}
 
 	public get hasChatSessionItemProviders(): boolean {

src/vs/workbench/contrib/chat/browser/chatSessions.ts

@@ -379,6 +379,11 @@ class ChatSessionsViewPaneContainer extends ViewPaneContainer {
 		this._register(this.chatSessionsService.onDidChangeSessionItems((chatSessionType) => {
 			this.refreshProviderTree(chatSessionType);
 		}));
+
+		// Listen for contribution availability changes and update view registration
+		this._register(this.chatSessionsService.onDidChangeAvailability(() => {
+			this.updateViewRegistration();
+		}));
 	}
 
 	override getTitle(): string {

src/vs/workbench/contrib/chat/common/chatSessionsService.ts

@@ -64,6 +64,7 @@ export interface IChatSessionsService {
 	readonly _serviceBrand: undefined;
 	readonly onDidChangeItemsProviders: Event<IChatSessionItemProvider>;
 	readonly onDidChangeSessionItems: Event<string>;
+	readonly onDidChangeAvailability: Event<void>;
 	registerContribution(contribution: IChatSessionsExtensionPoint): IDisposable;
 	getChatSessionContributions(): IChatSessionsExtensionPoint[];
 	canResolveItemProvider(chatSessionType: string): Promise<boolean>;