Implement chatAgent2 proposal

build/lib/compilation.ts

@@ -277,7 +277,7 @@ function generateApiProposalNames() {
 		eol = os.EOL;
 	}
 
-	const pattern = /vscode\.proposed\.([a-zA-Z]+)\.d\.ts$/;
+	const pattern = /vscode\.proposed\.([a-zA-Z\d]+)\.d\.ts$/;
 	const proposalNames = new Set<string>();
 
 	const input = es.through();

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

@@ -21,6 +21,7 @@ import './mainThreadLocalization';
 import './mainThreadBulkEdits';
 import './mainThreadChatProvider';
 import './mainThreadChatAgents';
+import './mainThreadChatAgents2';
 import './mainThreadChatVariables';
 import './mainThreadCodeInsets';
 import './mainThreadCLICommands';

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

@@ -7,7 +7,8 @@ import { DisposableMap } from 'vs/base/common/lifecycle';
 import { revive } from 'vs/base/common/marshalling';
 import { IProgress } from 'vs/platform/progress/common/progress';
 import { ExtHostChatAgentsShape, ExtHostContext, MainContext, MainThreadChatAgentsShape } from 'vs/workbench/api/common/extHost.protocol';
-import { IChatAgentMetadata, IChatAgentService } from 'vs/workbench/contrib/chat/common/chatAgents';
+import { IChatAgentCommand, IChatAgentMetadata, IChatAgentService } from 'vs/workbench/contrib/chat/common/chatAgents';
+import { IChatProgress } from 'vs/workbench/contrib/chat/common/chatService';
 import { IChatSlashFragment } from 'vs/workbench/contrib/chat/common/chatSlashCommands';
 import { IExtHostContext, extHostNamedCustomer } from 'vs/workbench/services/extensions/common/extHostCustomers';
 
@@ -16,7 +17,7 @@ import { IExtHostContext, extHostNamedCustomer } from 'vs/workbench/services/ext
 export class MainThreadChatAgents implements MainThreadChatAgentsShape {
 
 	private readonly _agents = new DisposableMap<number>;
-	private readonly _pendingProgress = new Map<number, IProgress<IChatSlashFragment>>();
+	private readonly _pendingProgress = new Map<number, IProgress<IChatProgress>>();
 	private readonly _proxy: ExtHostChatAgentsShape;
 
 	constructor(
@@ -34,29 +35,37 @@ export class MainThreadChatAgents implements MainThreadChatAgentsShape {
 		this._agents.clearAndDisposeAll();
 	}
 
-	$registerAgent(handle: number, name: string, metadata: IChatAgentMetadata): void {
-		if (!this._chatAgentService.hasAgent(name)) {
-			// dynamic!
-			this._chatAgentService.registerAgentData({
-				id: name,
-				metadata: revive(metadata)
-			});
-		}
-
-		const d = this._chatAgentService.registerAgentCallback(name, async (prompt, progress, history, token) => {
-			const requestId = Math.random();
-			this._pendingProgress.set(requestId, progress);
-			try {
-				return await this._proxy.$invokeAgent(handle, requestId, prompt, { history }, token);
-			} finally {
-				this._pendingProgress.delete(requestId);
-			}
+	$registerAgent(handle: number, name: string, metadata: IChatAgentMetadata & { subCommands: IChatAgentCommand[] }): void {
+		const d = this._chatAgentService.registerAgent({
+			id: name,
+			metadata: revive(metadata),
+			invoke: async (request, progress, history, token) => {
+				const requestId = Math.random();
+				this._pendingProgress.set(requestId, progress);
+				try {
+					const result = await this._proxy.$invokeAgent(handle, requestId, request.message, { history }, token);
+					return {
+						followUp: result?.followUp ?? [],
+					};
+				} finally {
+					this._pendingProgress.delete(requestId);
+				}
+			},
+			async provideSlashCommands() {
+				return metadata.subCommands;
+			},
 		});
 		this._agents.set(handle, d);
 	}
 
 	async $handleProgressChunk(requestId: number, chunk: IChatSlashFragment): Promise<void> {
-		this._pendingProgress.get(requestId)?.report(revive(chunk));
+		// An extra step because TS really struggles with type inference in the Revived generic parameter?
+		const revived = revive<IChatSlashFragment>(chunk);
+		if (typeof revived.content === 'string') {
+			this._pendingProgress.get(requestId)?.report({ content: revived.content });
+		} else {
+			this._pendingProgress.get(requestId)?.report(revived.content);
+		}
 	}
 
 	$unregisterCommand(handle: number): void {

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

@@ -0,0 +1,80 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { DisposableMap, IDisposable } from 'vs/base/common/lifecycle';
+import { revive } from 'vs/base/common/marshalling';
+import { IProgress } from 'vs/platform/progress/common/progress';
+import { ExtHostChatAgentsShape2, ExtHostContext, IChatResponseProgressDto, IExtensionChatAgentMetadata, MainContext, MainThreadChatAgentsShape2 } from 'vs/workbench/api/common/extHost.protocol';
+import { IChatAgentService } from 'vs/workbench/contrib/chat/common/chatAgents';
+import { IChatProgress } from 'vs/workbench/contrib/chat/common/chatService';
+import { IExtHostContext, extHostNamedCustomer } from 'vs/workbench/services/extensions/common/extHostCustomers';
+
+
+type AgentData = {
+	dispose: () => void;
+	name: string;
+	hasSlashCommands?: boolean;
+	hasFollowups?: boolean;
+};
+
+@extHostNamedCustomer(MainContext.MainThreadChatAgents2)
+export class MainThreadChatAgents implements MainThreadChatAgentsShape2, IDisposable {
+
+	private readonly _agents = new DisposableMap<number, AgentData>;
+	private readonly _pendingProgress = new Map<number, IProgress<IChatProgress>>();
+	private readonly _proxy: ExtHostChatAgentsShape2;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IChatAgentService private readonly _chatAgentService: IChatAgentService
+	) {
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostChatAgents2);
+	}
+
+	$unregisterAgent(handle: number): void {
+		this._agents.deleteAndDispose(handle);
+	}
+
+	dispose(): void {
+		this._agents.clearAndDisposeAll();
+	}
+
+	$registerAgent(handle: number, name: string, metadata: IExtensionChatAgentMetadata): void {
+		const d = this._chatAgentService.registerAgent({
+			id: name,
+			metadata: revive(metadata),
+			invoke: async (request, progress, history, token) => {
+				const requestId = Math.random(); // Make this a guid
+				this._pendingProgress.set(requestId, progress);
+				try {
+					return await this._proxy.$invokeAgent(handle, requestId, request, { history }, token) ?? {};
+				} finally {
+					this._pendingProgress.delete(requestId);
+				}
+			},
+			provideSlashCommands: async (token) => {
+				if (!this._agents.get(handle)?.hasSlashCommands) {
+					return []; // safe an IPC call
+				}
+				return this._proxy.$provideSlashCommands(handle, token);
+			}
+		});
+		this._agents.set(handle, { name, dispose: d.dispose, hasSlashCommands: metadata.hasSlashCommands });
+	}
+
+	$updateAgent(handle: number, metadataUpdate: IExtensionChatAgentMetadata): void {
+		const data = this._agents.get(handle);
+		if (!data) {
+			throw new Error(`No agent with handle ${handle} registered`);
+		}
+		data.hasSlashCommands = metadataUpdate.hasSlashCommands;
+		this._chatAgentService.updateAgent(data.name, revive(metadataUpdate));
+	}
+
+	async $handleProgressChunk(requestId: number, chunk: IChatResponseProgressDto): Promise<void> {
+		// TODO copy/move $acceptResponseProgress from MainThreadChat
+		this._pendingProgress.get(requestId)?.report(revive(chunk) as any);
+	}
+}

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

@@ -108,6 +108,7 @@ import { ExtHostChatVariables } from 'vs/workbench/api/common/extHostChatVariabl
 import { ExtHostRelatedInformation } from 'vs/workbench/api/common/extHostAiRelatedInformation';
 import { ExtHostAiEmbeddingVector } from 'vs/workbench/api/common/extHostEmbeddingVector';
 import { ExtHostChatAgents } from 'vs/workbench/api/common/extHostChatAgents';
+import { ExtHostChatAgents2 } from 'vs/workbench/api/common/extHostChatAgents2';
 
 export interface IExtensionRegistries {
 	mine: ExtensionDescriptionRegistry;
@@ -209,6 +210,7 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 	const extHostInteractiveEditor = rpcProtocol.set(ExtHostContext.ExtHostInlineChat, new ExtHostInteractiveEditor(rpcProtocol, extHostCommands, extHostDocuments, extHostLogService));
 	const extHostChatProvider = rpcProtocol.set(ExtHostContext.ExtHostChatProvider, new ExtHostChatProvider(rpcProtocol, extHostLogService));
 	const extHostChatAgents = rpcProtocol.set(ExtHostContext.ExtHostChatAgents, new ExtHostChatAgents(rpcProtocol, extHostChatProvider, extHostLogService));
+	const extHostChatAgents2 = rpcProtocol.set(ExtHostContext.ExtHostChatAgents2, new ExtHostChatAgents2(rpcProtocol, extHostChatProvider, extHostLogService));
 	const extHostChatVariables = rpcProtocol.set(ExtHostContext.ExtHostChatVariables, new ExtHostChatVariables(rpcProtocol));
 	const extHostChat = rpcProtocol.set(ExtHostContext.ExtHostChat, new ExtHostChat(rpcProtocol, extHostLogService));
 	const extHostAiRelatedInformation = rpcProtocol.set(ExtHostContext.ExtHostAiRelatedInformation, new ExtHostRelatedInformation(rpcProtocol));
@@ -1366,11 +1368,14 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 				checkProposedApiEnabled(extension, 'mappedEditsProvider');
 				return extHostLanguageFeatures.registerMappedEditsProvider(extension, selector, provider);
 			},
+			createChatAgent(name: string, handler: vscode.ChatAgentHandler) {
+				checkProposedApiEnabled(extension, 'chatAgents2');
+				return extHostChatAgents2.createChatAgent(extension.identifier, name, handler);
+			},
 			registerAgent(name: string, agent: vscode.ChatAgent, metadata: vscode.ChatAgentMetadata) {
 				checkProposedApiEnabled(extension, 'chatAgents');
 				return extHostChatAgents.registerAgent(extension.identifier, name, agent, metadata);
 			}
-
 		};
 
 		return <typeof vscode>{

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

@@ -50,7 +50,7 @@ import * as tasks from 'vs/workbench/api/common/shared/tasks';
 import { SaveReason } from 'vs/workbench/common/editor';
 import { IRevealOptions, ITreeItem, IViewBadge } from 'vs/workbench/common/views';
 import { CallHierarchyItem } from 'vs/workbench/contrib/callHierarchy/common/callHierarchy';
-import { IChatAgentMetadata } from 'vs/workbench/contrib/chat/common/chatAgents';
+import { IChatAgentCommand, IChatAgentMetadata, IChatAgentRequest, IChatAgentResult } from 'vs/workbench/contrib/chat/common/chatAgents';
 import { IChatMessage, IChatResponseFragment, IChatResponseProviderMetadata } from 'vs/workbench/contrib/chat/common/chatProvider';
 import { IChatDynamicRequest, IChatFollowup, IChatReplyFollowup, IChatResponseErrorDetails, IChatUserActionEvent, ISlashCommand } from 'vs/workbench/contrib/chat/common/chatService';
 import { IChatSlashFragment } from 'vs/workbench/contrib/chat/common/chatSlashCommands';
@@ -1147,15 +1147,33 @@ export interface ExtHostChatProviderShape {
 }
 
 export interface MainThreadChatAgentsShape extends IDisposable {
-	$registerAgent(handle: number, name: string, metadata: IChatAgentMetadata): void;
+	$registerAgent(handle: number, name: string, metadata: IChatAgentMetadata & { subCommands: IChatAgentCommand[] }): void;
 	$unregisterAgent(handle: number): void;
 	$handleProgressChunk(requestId: number, chunk: IChatSlashFragment): Promise<void>;
 }
 
+export interface IExtensionChatAgentMetadata extends Dto<IChatAgentMetadata> {
+	hasSlashCommands?: boolean;
+	hasFollowup?: boolean;
+}
+
+export interface MainThreadChatAgentsShape2 extends IDisposable {
+	$registerAgent(handle: number, name: string, metadata: IExtensionChatAgentMetadata): void;
+	$updateAgent(handle: number, metadataUpdate: IExtensionChatAgentMetadata): void;
+	$unregisterAgent(handle: number): void;
+	$handleProgressChunk(requestId: number, chunk: IChatResponseProgressDto): Promise<void>;
+}
+
 export interface ExtHostChatAgentsShape {
 	$invokeAgent(handle: number, requestId: number, prompt: string, context: { history: IChatMessage[] }, token: CancellationToken): Promise<any>;
 }
 
+export interface ExtHostChatAgentsShape2 {
+	$invokeAgent(handle: number, requestId: number, request: IChatAgentRequest, context: { history: IChatMessage[] }, token: CancellationToken): Promise<IChatAgentResult | undefined>;
+	$provideSlashCommands(handle: number, token: CancellationToken): Promise<IChatAgentCommand[]>;
+	$provideFollowups(handle: number, requestId: number, token: CancellationToken): Promise<IChatFollowup[]>;
+}
+
 export interface MainThreadChatVariablesShape extends IDisposable {
 	$registerVariable(handle: number, data: IChatVariableData): void;
 	$unregisterVariable(handle: number): void;
@@ -2664,6 +2682,7 @@ export const MainContext = {
 	MainThreadBulkEdits: createProxyIdentifier<MainThreadBulkEditsShape>('MainThreadBulkEdits'),
 	MainThreadChatProvider: createProxyIdentifier<MainThreadChatProviderShape>('MainThreadChatProvider'),
 	MainThreadChatAgents: createProxyIdentifier<MainThreadChatAgentsShape>('MainThreadChatAgents'),
+	MainThreadChatAgents2: createProxyIdentifier<MainThreadChatAgentsShape2>('MainThreadChatAgents2'),
 	MainThreadChatVariables: createProxyIdentifier<MainThreadChatVariablesShape>('MainThreadChatVariables'),
 	MainThreadClipboard: createProxyIdentifier<MainThreadClipboardShape>('MainThreadClipboard'),
 	MainThreadCommands: createProxyIdentifier<MainThreadCommandsShape>('MainThreadCommands'),
@@ -2785,6 +2804,7 @@ export const ExtHostContext = {
 	ExtHostInlineChat: createProxyIdentifier<ExtHostInlineChatShape>('ExtHostInlineChatShape'),
 	ExtHostChat: createProxyIdentifier<ExtHostChatShape>('ExtHostChat'),
 	ExtHostChatAgents: createProxyIdentifier<ExtHostChatAgentsShape>('ExtHostChatAgents'),
+	ExtHostChatAgents2: createProxyIdentifier<ExtHostChatAgentsShape2>('ExtHostChatAgents'),
 	ExtHostChatVariables: createProxyIdentifier<ExtHostChatVariablesShape>('ExtHostChatVariables'),
 	ExtHostChatProvider: createProxyIdentifier<ExtHostChatProviderShape>('ExtHostChatProvider'),
 	ExtHostAiRelatedInformation: createProxyIdentifier<ExtHostAiRelatedInformationShape>('ExtHostAiRelatedInformation'),

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

@@ -260,7 +260,7 @@ export class ExtHostChat implements ExtHostChatShape {
 	}
 
 	async $onDidPerformUserAction(event: IChatUserActionEvent): Promise<void> {
-		this._onDidPerformUserAction.fire(event);
+		this._onDidPerformUserAction.fire(event as any);
 	}
 
 	//#endregion