Chat code cleanup

extensions/vscode-api-tests/src/singlefolder-tests/chat.test.ts

@@ -5,7 +5,7 @@
 
 import * as assert from 'assert';
 import 'mocha';
-import { CancellationToken, chat, ChatAgentRequest, ChatVariableLevel, CompletionItemKind, Disposable, interactive, InteractiveProgress, InteractiveRequest, InteractiveResponseForProgress, InteractiveSession, InteractiveSessionState, Progress, ProviderResult } from 'vscode';
+import { CancellationToken, chat, ChatAgentRequest, ChatVariableLevel, Disposable, interactive, InteractiveSession, ProviderResult } from 'vscode';
 import { assertNoRpc, closeAllEditors, DeferredPromise, disposeAll } from '../utils';
 
 suite('chat', () => {
@@ -22,24 +22,12 @@ suite('chat', () => {
 
 	function getDeferredForRequest(): DeferredPromise<ChatAgentRequest> {
 		disposables.push(interactive.registerInteractiveSessionProvider('provider', {
-			prepareSession: (_initialState: InteractiveSessionState | undefined, _token: CancellationToken): ProviderResult<InteractiveSession> => {
+			prepareSession: (_token: CancellationToken): ProviderResult<InteractiveSession> => {
 				return {
 					requester: { name: 'test' },
 					responder: { name: 'test' },
 				};
 			},
-
-			provideResponseWithProgress: (_request: InteractiveRequest, _progress: Progress<InteractiveProgress>, _token: CancellationToken): ProviderResult<InteractiveResponseForProgress> => {
-				return null;
-			},
-
-			provideSlashCommands: (_session, _token) => {
-				return [{ command: 'hello', title: 'Hello', kind: CompletionItemKind.Text }];
-			},
-
-			removeRequest: (_session: InteractiveSession, _requestId: string): void => {
-				throw new Error('Function not implemented.');
-			}
 		}));
 
 		const deferred = new DeferredPromise<ChatAgentRequest>();

src/vs/base/common/lifecycle.ts

@@ -781,6 +781,10 @@ export class DisposableMap<K, V extends IDisposable = IDisposable> implements ID
 		return this._store.keys();
 	}
 
+	values(): IterableIterator<V> {
+		return this._store.values();
+	}
+
 	[Symbol.iterator](): IterableIterator<[K, V]> {
 		return this._store[Symbol.iterator]();
 	}

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

@@ -20,7 +20,6 @@ import { StatusBarItemsExtensionPoint } from 'vs/workbench/api/browser/statusBar
 import './mainThreadLocalization';
 import './mainThreadBulkEdits';
 import './mainThreadChatProvider';
-import './mainThreadChatAgents';
 import './mainThreadChatAgents2';
 import './mainThreadChatVariables';
 import './mainThreadCodeInsets';

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

@@ -3,31 +3,23 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { DeferredPromise } from 'vs/base/common/async';
 import { Emitter } from 'vs/base/common/event';
-import { IMarkdownString } from 'vs/base/common/htmlContent';
 import { Disposable, DisposableMap } from 'vs/base/common/lifecycle';
-import { revive } from 'vs/base/common/marshalling';
 import { URI, UriComponents } from 'vs/base/common/uri';
-import { ExtHostChatShape, ExtHostContext, IChatRequestDto, IChatResponseProgressDto, ILocationDto, MainContext, MainThreadChatShape } from 'vs/workbench/api/common/extHost.protocol';
+import { ExtHostChatShape, ExtHostContext, MainContext, MainThreadChatShape } from 'vs/workbench/api/common/extHost.protocol';
 import { IChatWidgetService } from 'vs/workbench/contrib/chat/browser/chat';
 import { IChatContributionService } from 'vs/workbench/contrib/chat/common/chatContributionService';
-import { isCompleteInteractiveProgressTreeData } from 'vs/workbench/contrib/chat/common/chatModel';
-import { IChat, IChatDynamicRequest, IChatProgress, IChatResponse, IChatResponseProgressFileTreeData, IChatService } from 'vs/workbench/contrib/chat/common/chatService';
+import { IChatDynamicRequest, IChatService } from 'vs/workbench/contrib/chat/common/chatService';
 import { IExtHostContext, extHostNamedCustomer } from 'vs/workbench/services/extensions/common/extHostCustomers';
 
 @extHostNamedCustomer(MainContext.MainThreadChat)
 export class MainThreadChat extends Disposable implements MainThreadChatShape {
 
 	private readonly _providerRegistrations = this._register(new DisposableMap<number>());
-	private readonly _activeRequestProgressCallbacks = new Map<string, (progress: IChatProgress) => (DeferredPromise<string | IMarkdownString> | void)>();
 	private readonly _stateEmitters = new Map<number, Emitter<any>>();
 
 	private readonly _proxy: ExtHostChatShape;
 
-	private _responsePartHandlePool = 0;
-	private readonly _activeResponsePartPromises = new Map<string, DeferredPromise<string | IMarkdownString | { treeData: IChatResponseProgressFileTreeData }>>();
-
 	constructor(
 		extHostContext: IExtHostContext,
 		@IChatService private readonly _chatService: IChatService,
@@ -64,8 +56,8 @@ export class MainThreadChat extends Disposable implements MainThreadChatShape {
 		const unreg = this._chatService.registerProvider({
 			id,
 			displayName: registration.label,
-			prepareSession: async (initialState, token) => {
-				const session = await this._proxy.$prepareChat(handle, initialState, token);
+			prepareSession: async (token) => {
+				const session = await this._proxy.$prepareChat(handle, token);
 				if (!session) {
 					return undefined;
 				}
@@ -75,102 +67,31 @@ export class MainThreadChat extends Disposable implements MainThreadChatShape {
 
 				const emitter = new Emitter<any>();
 				this._stateEmitters.set(session.id, emitter);
-				return <IChat>{
+				return {
 					id: session.id,
 					requesterUsername: session.requesterUsername,
 					requesterAvatarIconUri: URI.revive(session.requesterAvatarIconUri),
 					responderUsername: session.responderUsername,
 					responderAvatarIconUri,
 					inputPlaceholder: session.inputPlaceholder,
-					onDidChangeState: emitter.event,
 					dispose: () => {
 						emitter.dispose();
 						this._stateEmitters.delete(session.id);
 						this._proxy.$releaseSession(session.id);
 					}
 				};
 			},
-			provideReply: async (request, progress, token) => {
-				const id = `${handle}_${request.session.id}`;
-				this._activeRequestProgressCallbacks.set(id, progress);
-				try {
-					const requestDto: IChatRequestDto = {
-						message: request.message,
-						variables: request.variables
-					};
-					const dto = await this._proxy.$provideReply(handle, request.session.id, requestDto, token);
-					return <IChatResponse>{
-						session: request.session,
-						...dto
-					};
-				} finally {
-					this._activeRequestProgressCallbacks.delete(id);
-				}
-			},
 			provideWelcomeMessage: (token) => {
 				return this._proxy.$provideWelcomeMessage(handle, token);
 			},
 			provideSampleQuestions: (token) => {
 				return this._proxy.$provideSampleQuestions(handle, token);
 			},
-			provideSlashCommands: (session, token) => {
-				return this._proxy.$provideSlashCommands(handle, session.id, token);
-			},
-			provideFollowups: (session, token) => {
-				return this._proxy.$provideFollowups(handle, session.id, token);
-			},
-			removeRequest: (session, requestId) => {
-				return this._proxy.$removeRequest(handle, session.id, requestId);
-			}
 		});
 
 		this._providerRegistrations.set(handle, unreg);
 	}
 
-	async $acceptResponseProgress(handle: number, sessionId: number, progress: IChatResponseProgressDto, responsePartHandle?: number): Promise<number | void> {
-		const id = `${handle}_${sessionId}`;
-
-		if ('placeholder' in progress) {
-			const responsePartId = `${id}_${++this._responsePartHandlePool}`;
-			const deferredContentPromise = new DeferredPromise<string | IMarkdownString | { treeData: IChatResponseProgressFileTreeData }>();
-			this._activeResponsePartPromises.set(responsePartId, deferredContentPromise);
-			this._activeRequestProgressCallbacks.get(id)?.({ ...progress, resolvedContent: deferredContentPromise.p });
-			return this._responsePartHandlePool;
-		} else if (responsePartHandle) {
-			// Complete an existing deferred promise with resolved content
-			const responsePartId = `${id}_${responsePartHandle}`;
-			const deferredContentPromise = this._activeResponsePartPromises.get(responsePartId);
-			if (deferredContentPromise && isCompleteInteractiveProgressTreeData(progress)) {
-				const withRevivedUris = revive<{ treeData: IChatResponseProgressFileTreeData }>(progress);
-				deferredContentPromise.complete(withRevivedUris);
-				this._activeResponsePartPromises.delete(responsePartId);
-			} else if (deferredContentPromise && 'content' in progress) {
-				deferredContentPromise.complete(progress.content);
-				this._activeResponsePartPromises.delete(responsePartId);
-			}
-			return;
-		}
-
-		// No need to support standalone tree data that's not attached to a placeholder in API
-		if (isCompleteInteractiveProgressTreeData(progress)) {
-			return;
-		}
-
-		// TS won't let us change the type of `progress`
-		let revivedProgress: IChatProgress;
-		if ('documents' in progress) {
-			revivedProgress = { documents: revive(progress.documents) };
-		} else if ('reference' in progress) {
-			revivedProgress = revive<{ reference: UriComponents | ILocationDto }>(progress);
-		} else if ('inlineReference' in progress) {
-			revivedProgress = revive<{ inlineReference: UriComponents | ILocationDto; name?: string }>(progress);
-		} else {
-			revivedProgress = progress;
-		}
-
-		this._activeRequestProgressCallbacks.get(id)?.(revivedProgress);
-	}
-
 	async $acceptChatState(sessionId: number, state: any): Promise<void> {
 		this._stateEmitters.get(sessionId)?.fire(state);
 	}