Merge pull request microsoft#256378 from microsoft/osortega/session-provider

Chat session provider

Author: osortega

src/vs/platform/extensions/common/extensionsApiProposals.ts

@@ -53,6 +53,9 @@ const _allApiProposals = {
 	chatReferenceDiagnostic: {
 		proposal: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.chatReferenceDiagnostic.d.ts',
 	},
+	chatSessionsProvider: {
+		proposal: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.chatSessionsProvider.d.ts',
+	},
 	chatStatusItem: {
 		proposal: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.chatStatusItem.d.ts',
 	},

src/vs/workbench/api/browser/extensionHost.contribution.ts

@@ -91,6 +91,7 @@ import './mainThreadAiEmbeddingVector.js';
 import './mainThreadAiSettingsSearch.js';
 import './mainThreadMcp.js';
 import './mainThreadChatStatus.js';
+import './mainThreadChatSessions.js';
 import './mainThreadDataChannels.js';
 
 export class ExtensionPoints implements IWorkbenchContribution {

src/vs/workbench/api/browser/mainThreadChatSessions.ts

@@ -0,0 +1,48 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { CancellationToken } from '../../../base/common/cancellation.js';
+import { Disposable, DisposableMap } from '../../../base/common/lifecycle.js';
+import { ILogService } from '../../../platform/log/common/log.js';
+import { IChatSessionContent, IChatSessionsProvider, IChatSessionsService } from '../../contrib/chat/common/chatSessionsService.js';
+import { extHostNamedCustomer, IExtHostContext } from '../../services/extensions/common/extHostCustomers.js';
+import { ExtHostContext, MainContext, MainThreadChatSessionsShape } from '../common/extHost.protocol.js';
+
+@extHostNamedCustomer(MainContext.MainThreadChatSessions)
+export class MainThreadChatSessions extends Disposable implements MainThreadChatSessionsShape {
+	private readonly _registrations = this._register(new DisposableMap<number>());
+
+	constructor(
+		private readonly _extHostContext: IExtHostContext,
+		@IChatSessionsService private readonly _chatSessionsService: IChatSessionsService,
+		@ILogService private readonly _logService: ILogService,
+	) {
+		super();
+	}
+
+	$registerChatSessionsProvider(handle: number): void {
+		// Register the provider handle - this tracks that a provider exists
+		const provider: IChatSessionsProvider = {
+			provideChatSessions: (token) => this._provideChatSessionsInformation(handle, token)
+		};
+		this._registrations.set(handle, this._chatSessionsService.registerChatSessionsProvider(handle, provider));
+	}
+
+	private async _provideChatSessionsInformation(handle: number, token: CancellationToken): Promise<IChatSessionContent[]> {
+		const proxy = this._extHostContext.getProxy(ExtHostContext.ExtHostChatSessions);
+
+		try {
+			// Get all results as an array from the RPC call
+			return await proxy.$provideChatSessions(handle, token);
+		} catch (error) {
+			this._logService.error('Error providing chat sessions:', error);
+		}
+		return [];
+	}
+
+	$unregisterChatSessionsProvider(handle: number): void {
+		this._registrations.deleteAndDispose(handle);
+	}
+}

src/vs/workbench/api/common/extHost.api.impl.ts

@@ -112,6 +112,7 @@ import { ExtHostWebviewViews } from './extHostWebviewView.js';
 import { IExtHostWindow } from './extHostWindow.js';
 import { IExtHostWorkspace } from './extHostWorkspace.js';
 import { ExtHostAiSettingsSearch } from './extHostAiSettingsSearch.js';
+import { IExtHostChatSessions } from './extHostChatSessions.js';
 
 export interface IExtensionRegistries {
 	mine: ExtensionDescriptionRegistry;
@@ -153,6 +154,7 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 	const extHostLanguageModels = accessor.get(IExtHostLanguageModels);
 	const extHostMcp = accessor.get(IExtHostMpcService);
 	const extHostDataChannels = accessor.get(IExtHostDataChannels);
+	const extHostChatSessions = accessor.get(IExtHostChatSessions);
 
 	// register addressable instances
 	rpcProtocol.set(ExtHostContext.ExtHostFileSystemInfo, extHostFileSystemInfo);
@@ -172,6 +174,7 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 	rpcProtocol.set(ExtHostContext.ExtHostAuthentication, extHostAuthentication);
 	rpcProtocol.set(ExtHostContext.ExtHostChatProvider, extHostLanguageModels);
 	rpcProtocol.set(ExtHostContext.ExtHostDataChannels, extHostDataChannels);
+	rpcProtocol.set(ExtHostContext.ExtHostChatSessions, extHostChatSessions);
 
 	// automatically create and register addressable instances
 	const extHostDecorations = rpcProtocol.set(ExtHostContext.ExtHostDecorations, accessor.get(IExtHostDecorations));
@@ -1501,7 +1504,11 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 			onDidDisposeChatSession: (listeners, thisArgs?, disposables?) => {
 				checkProposedApiEnabled(extension, 'chatParticipantPrivate');
 				return _asExtensionEvent(extHostChatAgents2.onDidDisposeChatSession)(listeners, thisArgs, disposables);
-			}
+			},
+			registerChatSessionsProvider(provider: vscode.ChatSessionsProvider) {
+				checkProposedApiEnabled(extension, 'chatSessionsProvider');
+				return extHostChatSessions.registerChatSessionsProvider(provider);
+			},
 		};
 
 		// namespace: lm

src/vs/workbench/api/common/extHost.common.services.ts

@@ -34,6 +34,7 @@ import { ExtHostMcpService, IExtHostMpcService } from './extHostMcp.js';
 import { ExtHostUrls, IExtHostUrlsService } from './extHostUrls.js';
 import { ExtHostProgress, IExtHostProgress } from './extHostProgress.js';
 import { ExtHostDataChannels, IExtHostDataChannels } from './extHostDataChannels.js';
+import { ExtHostChatSessions, IExtHostChatSessions } from './extHostChatSessions.js';
 
 registerSingleton(IExtHostLocalizationService, ExtHostLocalizationService, InstantiationType.Delayed);
 registerSingleton(ILoggerService, ExtHostLoggerService, InstantiationType.Delayed);
@@ -64,3 +65,4 @@ registerSingleton(IExtHostEditorTabs, ExtHostEditorTabs, InstantiationType.Eager
 registerSingleton(IExtHostVariableResolverProvider, ExtHostVariableResolverProviderService, InstantiationType.Eager);
 registerSingleton(IExtHostMpcService, ExtHostMcpService, InstantiationType.Eager);
 registerSingleton(IExtHostDataChannels, ExtHostDataChannels, InstantiationType.Eager);
+registerSingleton(IExtHostChatSessions, ExtHostChatSessions, InstantiationType.Eager);

src/vs/workbench/api/common/extHost.protocol.ts

@@ -3,6 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import { ChatSessionContent } from 'vscode';
 import { VSBuffer } from '../../../base/common/buffer.js';
 import { CancellationToken } from '../../../base/common/cancellation.js';
 import { IRemoteConsoleLog } from '../../../base/common/console.js';
@@ -3100,6 +3101,15 @@ export interface MainThreadChatStatusShape {
 	$disposeEntry(id: string): void;
 }
 
+export interface MainThreadChatSessionsShape extends IDisposable {
+	$registerChatSessionsProvider(handle: number): void;
+	$unregisterChatSessionsProvider(handle: number): void;
+}
+
+export interface ExtHostChatSessionsShape {
+	$provideChatSessions(handle: number, token: CancellationToken): Promise<ChatSessionContent[]>;
+}
+
 // --- proxy identifiers
 
 export const MainContext = {
@@ -3177,6 +3187,7 @@ export const MainContext = {
 	MainThreadChatStatus: createProxyIdentifier<MainThreadChatStatusShape>('MainThreadChatStatus'),
 	MainThreadAiSettingsSearch: createProxyIdentifier<MainThreadAiSettingsSearchShape>('MainThreadAiSettingsSearch'),
 	MainThreadDataChannels: createProxyIdentifier<MainThreadDataChannelsShape>('MainThreadDataChannels'),
+	MainThreadChatSessions: createProxyIdentifier<MainThreadChatSessionsShape>('MainThreadChatSessions'),
 };
 
 export const ExtHostContext = {
@@ -3250,4 +3261,5 @@ export const ExtHostContext = {
 	ExtHostLocalization: createProxyIdentifier<ExtHostLocalizationShape>('ExtHostLocalization'),
 	ExtHostMcp: createProxyIdentifier<ExtHostMcpShape>('ExtHostMcp'),
 	ExtHostDataChannels: createProxyIdentifier<ExtHostDataChannelsShape>('ExtHostDataChannels'),
+	ExtHostChatSessions: createProxyIdentifier<ExtHostChatSessionsShape>('ExtHostChatSessions'),
 };

src/vs/workbench/api/common/extHostChatSessions.ts

@@ -0,0 +1,61 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Disposable, DisposableStore } from '../../../base/common/lifecycle.js';
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+import { ExtHostChatSessionsShape, MainContext, MainThreadChatSessionsShape } from './extHost.protocol.js';
+import type * as vscode from 'vscode';
+import { ILogService } from '../../../platform/log/common/log.js';
+import { Proxied } from '../../services/extensions/common/proxyIdentifier.js';
+
+export interface IExtHostChatSessions extends ExtHostChatSessionsShape {
+	registerChatSessionsProvider(provider: vscode.ChatSessionsProvider): vscode.Disposable;
+	$provideChatSessions(handle: number, token: vscode.CancellationToken): Promise<vscode.ChatSessionContent[]>;
+}
+export const IExtHostChatSessions = createDecorator<IExtHostChatSessions>('IExtHostChatSessions');
+
+export class ExtHostChatSessions extends Disposable implements IExtHostChatSessions {
+	declare _serviceBrand: undefined;
+
+	private readonly _proxy: Proxied<MainThreadChatSessionsShape>;
+	private readonly _statusProviders = new Map<number, { provider: vscode.ChatSessionsProvider; disposable: DisposableStore }>();
+	private _nextHandle = 0;
+
+	constructor(
+		@IExtHostRpcService private readonly _extHostRpc: IExtHostRpcService,
+		@ILogService private readonly _logService: ILogService,
+	) {
+		super();
+		this._proxy = this._extHostRpc.getProxy(MainContext.MainThreadChatSessions);
+	}
+
+	registerChatSessionsProvider(provider: vscode.ChatSessionsProvider): vscode.Disposable {
+		const handle = this._nextHandle++;
+		const disposables = new DisposableStore();
+
+		this._statusProviders.set(handle, { provider, disposable: disposables });
+		this._proxy.$registerChatSessionsProvider(handle);
+
+		return {
+			dispose: () => {
+				this._statusProviders.delete(handle);
+				disposables.dispose();
+				provider.dispose();
+				this._proxy.$unregisterChatSessionsProvider(handle);
+			}
+		};
+	}
+
+	async $provideChatSessions(handle: number, token: vscode.CancellationToken): Promise<vscode.ChatSessionContent[]> {
+		const entry = this._statusProviders.get(handle);
+		if (!entry) {
+			this._logService.error(`No provider registered for handle ${handle}`);
+			return [];
+		}
+
+		return await entry.provider.provideChatSessions(token);
+	}
+}

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

@@ -0,0 +1,79 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Disposable, IDisposable } from '../../../../base/common/lifecycle.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+import { InstantiationType, registerSingleton } from '../../../../platform/instantiation/common/extensions.js';
+import { IconPath } from '../../../../editor/common/languages.js';
+import { UriComponents } from '../../../../base/common/uri.js';
+
+export interface IChatSessionContent {
+	uri: UriComponents;
+	label: string;
+	iconPath?: IconPath;
+}
+
+export interface IChatSessionsProvider {
+	provideChatSessions(token: CancellationToken): Promise<IChatSessionContent[]>;
+}
+
+export interface IChatSessionsService {
+	readonly _serviceBrand: undefined;
+	registerChatSessionsProvider(handle: number, provider: IChatSessionsProvider): IDisposable;
+	hasChatSessionsProviders: boolean;
+	provideChatSessions(token: CancellationToken): Promise<IChatSessionContent[]>;
+}
+
+export const IChatSessionsService = createDecorator<IChatSessionsService>('chatSessionsService');
+
+export class ChatSessionsService extends Disposable implements IChatSessionsService {
+	readonly _serviceBrand: undefined;
+	private _providers: Map<number, IChatSessionsProvider> = new Map();
+
+	constructor(
+		@ILogService private readonly _logService: ILogService,
+	) {
+		super();
+	}
+
+	public async provideChatSessions(token: CancellationToken): Promise<IChatSessionContent[]> {
+		const results: IChatSessionContent[] = [];
+
+		// Iterate through all registered providers and collect their results
+		for (const [handle, provider] of this._providers) {
+			try {
+				if (provider.provideChatSessions) {
+					results.push(...await provider.provideChatSessions(token));
+				}
+			} catch (error) {
+				this._logService.error(`Error getting chat sessions from provider ${handle}:`, error);
+			}
+
+			if (token.isCancellationRequested) {
+				break;
+			}
+		}
+
+		return results;
+	}
+
+	public registerChatSessionsProvider(handle: number, provider: IChatSessionsProvider): IDisposable {
+		this._providers.set(handle, provider);
+		return {
+			dispose: () => {
+				this._providers.delete(handle);
+			}
+		};
+	}
+
+	public get hasChatSessionsProviders(): boolean {
+		return this._providers.size > 0;
+	}
+}
+
+registerSingleton(IChatSessionsService, ChatSessionsService, InstantiationType.Delayed);
+

src/vscode-dts/vscode.proposed.chatSessionsProvider.d.ts

@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+declare module 'vscode' {
+	/**
+	 * Provides a list of chat sessions
+	 */
+	export interface ChatSessionsProvider extends Disposable {
+
+		/**
+		 * Fired when chat sessions change.
+		 */
+		readonly onDidChangeChatSessionContent: Event<void>;
+
+		/**
+		 * Provide a list of chat sessions.
+		 * */
+		provideChatSessions(token: CancellationToken): Thenable<ChatSessionContent[]>;
+	}
+
+	export interface ChatSessionContent {
+		/**
+		 * Identifies the session
+		 *		 */
+		uri: Uri;
+
+		/**
+		 * Human readable name of the session shown in the UI
+		 */
+		label: string;
+
+		/**
+		 * An icon for the participant shown in UI.
+		 */
+		iconPath?: IconPath;
+	}
+
+	export namespace chat {
+		export function registerChatSessionsProvider(provider: ChatSessionsProvider): Disposable;
+	}
+}