chat: allow tools to report progress

This adds a `toolProgress` proposed API that allows extensions to report
progress keyed on the `toolInvocationToken`. Internally, when given to a
tool, this now includes the call ID of the tool.

We can use that both from extensions and internally to report progress
for tools, and I hooked this up for MCP servers. Currently only the text
is updated.

Involved some changes in the progress service internally:

- Previously `viewId` was a naked string, I wrapped it in an object to
  make it more identifiable.
- The progress service is in `workbench/services` and directly calls
  into other services to effect progress. In leui of going for a full
  'contribution' model, I made a small `ILanguageModelToolProgressService`
	that it writes state into and that can be read back out. The state
	(an observable) is kept as long as progress is ongoing or this is
	is an observer.

Author: connor4312

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

@@ -394,6 +394,9 @@ const _allApiProposals = {
 	tokenInformation: {
 		proposal: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.tokenInformation.d.ts',
 	},
+	toolProgress: {
+		proposal: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.toolProgress.d.ts',
+	},
 	treeViewActiveItem: {
 		proposal: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.treeViewActiveItem.d.ts',
 	},

src/vs/platform/progress/common/progress.ts

@@ -50,8 +50,12 @@ export const enum ProgressLocation {
 	Dialog = 20
 }
 
+export type ProgressLocationDetailed = { viewId: string } | { toolInvocationCallId: string | undefined };
+
+export type ProgressLocationDescriptor = ProgressLocation | ProgressLocationDetailed;
+
 export interface IProgressOptions {
-	readonly location: ProgressLocation | string;
+	readonly location: ProgressLocationDescriptor;
 	readonly title?: string;
 	readonly source?: string | INotificationSource;
 	readonly total?: number;
@@ -81,7 +85,7 @@ export interface IProgressWindowOptions extends IProgressOptions {
 }
 
 export interface IProgressCompositeOptions extends IProgressOptions {
-	readonly location: ProgressLocation.Explorer | ProgressLocation.Extensions | ProgressLocation.Scm | string;
+	readonly location: ProgressLocation.Explorer | ProgressLocation.Extensions | ProgressLocation.Scm | { viewId: string };
 	readonly delay?: number;
 }
 

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

@@ -815,7 +815,7 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 
 				return extHostProgress.withProgress(extension, { location: extHostTypes.ProgressLocation.SourceControl }, (progress, token) => task({ report(n: number) { /*noop*/ } }));
 			},
-			withProgress<R>(options: vscode.ProgressOptions, task: (progress: vscode.Progress<{ message?: string; worked?: number }>, token: vscode.CancellationToken) => Thenable<R>) {
+			withProgress<R>(options: vscode.ProgressOptions | vscode.ProgressOptions2, task: (progress: vscode.Progress<{ message?: string; worked?: number }>, token: vscode.CancellationToken) => Thenable<R>) {
 				return extHostProgress.withProgress(extension, options, task);
 			},
 			createOutputChannel(name: string, options: string | { log: true } | undefined): any {

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

@@ -73,7 +73,7 @@ export class ExtHostLanguageModelTools implements ExtHostLanguageModelToolsShape
 				callId,
 				parameters: options.input,
 				tokenBudget: options.tokenizationOptions?.tokenBudget,
-				context: options.toolInvocationToken as IToolInvocationContext | undefined,
+				context: options.toolInvocationToken ? { ...(options.toolInvocationToken as IToolInvocationContext), callId } : undefined,
 				chatRequestId: isProposedApiEnabled(extension, 'chatParticipantPrivate') ? options.chatRequestId : undefined,
 				chatInteractionId: isProposedApiEnabled(extension, 'chatParticipantPrivate') ? options.chatInteractionId : undefined,
 			}, token);

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

@@ -3,14 +3,15 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { ProgressOptions } from 'vscode';
+import { ProgressOptions, ProgressOptions2 } from 'vscode';
 import { MainThreadProgressShape, ExtHostProgressShape } from './extHost.protocol.js';
 import { ProgressLocation } from './extHostTypeConverters.js';
 import { Progress, IProgressStep } from '../../../platform/progress/common/progress.js';
 import { CancellationTokenSource, CancellationToken } from '../../../base/common/cancellation.js';
 import { throttle } from '../../../base/common/decorators.js';
 import { IExtensionDescription } from '../../../platform/extensions/common/extensions.js';
 import { onUnexpectedExternalError } from '../../../base/common/errors.js';
+import { checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
 
 export class ExtHostProgress implements ExtHostProgressShape {
 
@@ -22,11 +23,15 @@ export class ExtHostProgress implements ExtHostProgressShape {
 		this._proxy = proxy;
 	}
 
-	async withProgress<R>(extension: IExtensionDescription, options: ProgressOptions, task: (progress: Progress<IProgressStep>, token: CancellationToken) => Thenable<R>): Promise<R> {
+	async withProgress<R>(extension: IExtensionDescription, options: ProgressOptions | ProgressOptions2, task: (progress: Progress<IProgressStep>, token: CancellationToken) => Thenable<R>): Promise<R> {
 		const handle = this._handles++;
 		const { title, location, cancellable } = options;
 		const source = { label: extension.displayName || extension.name, id: extension.identifier.value };
 
+		if (typeof location === 'object' && location.hasOwnProperty('toolInvocationToken')) {
+			checkProposedApiEnabled(extension, 'toolProgress');
+		}
+
 		this._proxy.$startProgress(handle, { location: ProgressLocation.from(location), title, source, cancellable }, !extension.isUnderDevelopment ? extension.identifier.value : undefined).catch(onUnexpectedExternalError);
 		return this._withProgress(handle, task, !!cancellable);
 	}

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

@@ -36,14 +36,14 @@ import { EndOfLineSequence, TrackedRangeStickiness } from '../../../editor/commo
 import { ITextEditorOptions } from '../../../platform/editor/common/editor.js';
 import { IExtensionDescription } from '../../../platform/extensions/common/extensions.js';
 import { IMarkerData, IRelatedInformation, MarkerSeverity, MarkerTag } from '../../../platform/markers/common/markers.js';
-import { ProgressLocation as MainProgressLocation } from '../../../platform/progress/common/progress.js';
+import { ProgressLocation as MainProgressLocation, ProgressLocationDescriptor as MainProgressLocationDescriptor } from '../../../platform/progress/common/progress.js';
 import { DEFAULT_EDITOR_ASSOCIATION, SaveReason } from '../../common/editor.js';
 import { IViewBadge } from '../../common/views.js';
 import { IChatAgentRequest, IChatAgentResult } from '../../contrib/chat/common/chatAgents.js';
 import { IChatRequestDraft } from '../../contrib/chat/common/chatEditingService.js';
 import { IChatRequestVariableEntry, isImageVariableEntry } from '../../contrib/chat/common/chatModel.js';
 import { IChatAgentMarkdownContentWithVulnerability, IChatCodeCitation, IChatCommandButton, IChatConfirmation, IChatContentInlineReference, IChatContentReference, IChatExtensionsContent, IChatFollowup, IChatMarkdownContent, IChatMoveMessage, IChatProgressMessage, IChatResponseCodeblockUriPart, IChatTaskDto, IChatTaskResult, IChatTextEdit, IChatTreeData, IChatUserActionEvent, IChatWarningMessage } from '../../contrib/chat/common/chatService.js';
-import { IToolData, IToolResult } from '../../contrib/chat/common/languageModelToolsService.js';
+import { IToolData, IToolInvocationContext, IToolResult } from '../../contrib/chat/common/languageModelToolsService.js';
 import * as chatProvider from '../../contrib/chat/common/languageModels.js';
 import { IChatResponsePromptTsxPart, IChatResponseTextPart } from '../../contrib/chat/common/languageModels.js';
 import { DebugTreeItemCollapsibleState, IDebugVisualizationTreeItem } from '../../contrib/debug/common/debug.js';
@@ -1458,9 +1458,13 @@ export namespace EndOfLine {
 }
 
 export namespace ProgressLocation {
-	export function from(loc: vscode.ProgressLocation | { viewId: string }): MainProgressLocation | string {
+	export function from(loc: vscode.ProgressLocation | { viewId: string } | { toolInvocationToken: object | undefined }): MainProgressLocationDescriptor {
 		if (typeof loc === 'object') {
-			return loc.viewId;
+			if ('toolInvocationToken' in loc) {
+				return { toolInvocationCallId: (loc.toolInvocationToken as IToolInvocationContext).callId };
+			} else {
+				return { viewId: loc.viewId };
+			}
 		}
 
 		switch (loc) {

src/vs/workbench/browser/parts/views/treeView.ts

@@ -692,7 +692,7 @@ abstract class AbstractTreeView extends Disposable implements ITreeView {
 		const actionViewItemProvider = createActionViewItem.bind(undefined, this.instantiationService);
 		const treeMenus = this.treeDisposables.add(this.instantiationService.createInstance(TreeMenus, this.id));
 		this.treeLabels = this.treeDisposables.add(this.instantiationService.createInstance(ResourceLabels, this));
-		const dataSource = this.instantiationService.createInstance(TreeDataSource, this, <T>(task: Promise<T>) => this.progressService.withProgress({ location: this.id }, () => task));
+		const dataSource = this.instantiationService.createInstance(TreeDataSource, this, <T>(task: Promise<T>) => this.progressService.withProgress({ location: { viewId: this.id } }, () => task));
 		const aligner = this.treeDisposables.add(new Aligner(this.themeService));
 		const checkboxStateHandler = this.treeDisposables.add(new CheckboxStateHandler());
 		const renderer = this.treeDisposables.add(this.instantiationService.createInstance(TreeRenderer, this.id, treeMenus, this.treeLabels, actionViewItemProvider, aligner, checkboxStateHandler, () => this.manuallyManageCheckboxes));
@@ -1791,7 +1791,7 @@ export class CustomTreeView extends AbstractTreeView {
 				id: this.id,
 			});
 			this.createTree();
-			this.progressService.withProgress({ location: this.id }, () => this.extensionService.activateByEvent(`onView:${this.id}`))
+			this.progressService.withProgress({ location: { viewId: this.id } }, () => this.extensionService.activateByEvent(`onView:${this.id}`))
 				.then(() => timeout(2000))
 				.then(() => {
 					this.updateMessage();

src/vs/workbench/browser/parts/views/viewPane.ts

@@ -651,8 +651,8 @@ export abstract class ViewPane extends Pane implements IView {
 		return this.progressIndicator;
 	}
 
-	protected getProgressLocation(): string {
-		return this.viewDescriptorService.getViewContainerByViewId(this.id)!.id;
+	protected getProgressLocation(): { viewId: string } {
+		return { viewId: this.viewDescriptorService.getViewContainerByViewId(this.id)!.id };
 	}
 
 	protected getLocationBasedColors(): IViewPaneLocationColors {

src/vs/workbench/contrib/chat/browser/chatContentParts/chatToolInvocationPart.ts

@@ -9,6 +9,7 @@ import { Codicon } from '../../../../../base/common/codicons.js';
 import { Emitter } from '../../../../../base/common/event.js';
 import { IMarkdownString, MarkdownString } from '../../../../../base/common/htmlContent.js';
 import { Disposable, DisposableStore, IDisposable, thenIfNotDisposed, toDisposable } from '../../../../../base/common/lifecycle.js';
+import { autorunWithStore } from '../../../../../base/common/observable.js';
 import { ThemeIcon } from '../../../../../base/common/themables.js';
 import { URI } from '../../../../../base/common/uri.js';
 import { generateUuid } from '../../../../../base/common/uuid.js';
@@ -22,6 +23,8 @@ import { IContextKeyService } from '../../../../../platform/contextkey/common/co
 import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
 import { IKeybindingService } from '../../../../../platform/keybinding/common/keybinding.js';
 import { IMarkerData, IMarkerService, MarkerSeverity } from '../../../../../platform/markers/common/markers.js';
+import { IProgressService } from '../../../../../platform/progress/common/progress.js';
+import { ILanguageModelToolProgressService } from '../../../../services/progress/browser/languageModelToolProgressService.js';
 import { ChatContextKeys } from '../../common/chatContextKeys.js';
 import { IChatMarkdownContent, IChatProgressMessage, IChatTerminalToolInvocationData, IChatToolInvocation, IChatToolInvocationSerialized } from '../../common/chatService.js';
 import { IChatRendererContent } from '../../common/chatViewModel.js';
@@ -64,6 +67,7 @@ export class ChatToolInvocationPart extends Disposable implements IChatContentPa
 		codeBlockModelCollection: CodeBlockModelCollection,
 		codeBlockStartIndex: number,
 		@IInstantiationService instantiationService: IInstantiationService,
+		@IProgressService progressService: IProgressService,
 	) {
 		super();
 
@@ -140,6 +144,7 @@ class ChatToolInvocationSubPart extends Disposable {
 		@ILanguageModelToolsService private readonly languageModelToolsService: ILanguageModelToolsService,
 		@ICommandService private readonly commandService: ICommandService,
 		@IMarkerService private readonly markerService: IMarkerService,
+		@ILanguageModelToolProgressService private readonly languageModelToolProgressService: ILanguageModelToolProgressService,
 	) {
 		super();
 
@@ -454,27 +459,37 @@ class ChatToolInvocationSubPart extends Disposable {
 	}
 
 	private createProgressPart(): HTMLElement {
-		let content: IMarkdownString;
 		if (this.toolInvocation.isComplete && this.toolInvocation.isConfirmed !== false && this.toolInvocation.pastTenseMessage) {
-			content = typeof this.toolInvocation.pastTenseMessage === 'string' ?
-				new MarkdownString().appendText(this.toolInvocation.pastTenseMessage) :
-				this.toolInvocation.pastTenseMessage;
+			const part = this.renderProgressContent(this.toolInvocation.pastTenseMessage);
+			this._register(part);
+			return part.domNode;
 		} else {
-			content = typeof this.toolInvocation.invocationMessage === 'string' ?
-				new MarkdownString().appendText(this.toolInvocation.invocationMessage + '…') :
-				MarkdownString.lift(this.toolInvocation.invocationMessage).appendText('…');
+			const container = document.createElement('div');
+			const progressObservable = this._register(this.languageModelToolProgressService.listenForProgress(this.toolInvocation.toolCallId));
+			this._register(autorunWithStore((reader, store) => {
+				const progress = progressObservable.object.read(reader);
+				const part = store.add(this.renderProgressContent(progress?.message || this.toolInvocation.invocationMessage));
+				dom.reset(container, part.domNode);
+			}));
+			return container;
+		}
+	}
+
+	private renderProgressContent(content: IMarkdownString | string) {
+		if (typeof content === 'string') {
+			content = new MarkdownString().appendText(content);
 		}
 
 		const progressMessage: IChatProgressMessage = {
 			kind: 'progressMessage',
 			content
 		};
+
 		const iconOverride = !this.toolInvocation.isConfirmed ?
 			Codicon.error :
 			this.toolInvocation.isComplete ?
 				Codicon.check : undefined;
-		const progressPart = this._register(this.instantiationService.createInstance(ChatProgressContentPart, progressMessage, this.renderer, this.context, undefined, true, iconOverride));
-		return progressPart.domNode;
+		return this.instantiationService.createInstance(ChatProgressContentPart, progressMessage, this.renderer, this.context, undefined, true, iconOverride);
 	}
 
 	private createTerminalMarkdownProgressPart(toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized, terminalData: IChatTerminalToolInvocationData): HTMLElement {

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

@@ -83,6 +83,7 @@ export interface IToolInvocation {
 
 export interface IToolInvocationContext {
 	sessionId: string;
+	callId: string | undefined;
 }
 
 export function isToolInvocationContext(obj: any): obj is IToolInvocationContext {