prepare for not having a "real" inline chat provider (microsoft#210069)

* prepare for not having a "real" inline chat provider

- add location to provideWelcomeMessage
- add dynamic/fake inline chat provider for editor agents
- fix inline content widget when not having a message

* fix tests

Author: jrieken

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

@@ -120,8 +120,8 @@ export class MainThreadChatAgents2 extends Disposable implements MainThreadChatA
 
 				return this._proxy.$provideFollowups(request, handle, result, { history }, token);
 			},
-			provideWelcomeMessage: (token: CancellationToken) => {
-				return this._proxy.$provideWelcomeMessage(handle, token);
+			provideWelcomeMessage: (location: ChatAgentLocation, token: CancellationToken) => {
+				return this._proxy.$provideWelcomeMessage(handle, location, token);
 			},
 			provideSampleQuestions: (location: ChatAgentLocation, token: CancellationToken) => {
 				return this._proxy.$provideSampleQuestions(handle, location, token);

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

@@ -1246,7 +1246,7 @@ export interface ExtHostChatAgentsShape2 {
 	$acceptFeedback(handle: number, result: IChatAgentResult, vote: InteractiveSessionVoteDirection, reportIssue?: boolean): void;
 	$acceptAction(handle: number, result: IChatAgentResult, action: IChatUserActionEvent): void;
 	$invokeCompletionProvider(handle: number, query: string, token: CancellationToken): Promise<IChatAgentCompletionItem[]>;
-	$provideWelcomeMessage(handle: number, token: CancellationToken): Promise<(string | IMarkdownString)[] | undefined>;
+	$provideWelcomeMessage(handle: number, location: ChatAgentLocation, token: CancellationToken): Promise<(string | IMarkdownString)[] | undefined>;
 	$provideSampleQuestions(handle: number, location: ChatAgentLocation, token: CancellationToken): Promise<IChatFollowup[] | undefined>;
 	$releaseSession(sessionId: string): void;
 }

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

@@ -375,13 +375,13 @@ export class ExtHostChatAgents2 implements ExtHostChatAgentsShape2 {
 		return items.map(typeConvert.ChatAgentCompletionItem.from);
 	}
 
-	async $provideWelcomeMessage(handle: number, token: CancellationToken): Promise<(string | IMarkdownString)[] | undefined> {
+	async $provideWelcomeMessage(handle: number, location: ChatAgentLocation, token: CancellationToken): Promise<(string | IMarkdownString)[] | undefined> {
 		const agent = this._agents.get(handle);
 		if (!agent) {
 			return;
 		}
 
-		return await agent.provideWelcomeMessage(token);
+		return await agent.provideWelcomeMessage(typeConvert.ChatLocation.to(location), token);
 	}
 
 	async $provideSampleQuestions(handle: number, location: ChatAgentLocation, token: CancellationToken): Promise<IChatFollowup[] | undefined> {
@@ -453,11 +453,11 @@ class ExtHostChatAgent {
 			.filter(f => !(f && 'message' in f));
 	}
 
-	async provideWelcomeMessage(token: CancellationToken): Promise<(string | IMarkdownString)[] | undefined> {
+	async provideWelcomeMessage(location: vscode.ChatLocation, token: CancellationToken): Promise<(string | IMarkdownString)[] | undefined> {
 		if (!this._welcomeMessageProvider) {
 			return [];
 		}
-		const content = await this._welcomeMessageProvider.provideWelcomeMessage(token);
+		const content = await this._welcomeMessageProvider.provideWelcomeMessage(location, token);
 		if (!content) {
 			return [];
 		}

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

@@ -194,8 +194,8 @@ export class ChatExtensionPointHandler implements IWorkbenchContribution {
 					}
 
 					const store = new DisposableStore();
-					if (providerDescriptor.isDefault) {
-						store.add(this.registerDefaultParticipant(providerDescriptor));
+					if (providerDescriptor.isDefault && (!providerDescriptor.locations || providerDescriptor.locations?.includes(ChatAgentLocation.Panel))) {
+						store.add(this.registerDefaultParticipantView(providerDescriptor));
 					}
 
 					store.add(this._chatAgentService.registerAgent(
@@ -218,7 +218,7 @@ export class ChatExtensionPointHandler implements IWorkbenchContribution {
 						} satisfies IChatAgentData));
 
 					this._participantRegistrationDisposables.set(
-						getParticipantKey(extension.description.identifier, providerDescriptor.name),
+						getParticipantKey(extension.description.identifier, providerDescriptor.id),
 						store
 					);
 				}
@@ -250,7 +250,7 @@ export class ChatExtensionPointHandler implements IWorkbenchContribution {
 		return viewContainer;
 	}
 
-	private registerDefaultParticipant(defaultParticipantDescriptor: IRawChatParticipantContribution): IDisposable {
+	private registerDefaultParticipantView(defaultParticipantDescriptor: IRawChatParticipantContribution): IDisposable {
 		// Register View
 		const viewDescriptor: IViewDescriptor[] = [{
 			id: CHAT_VIEW_ID,

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

@@ -138,7 +138,7 @@ class InputEditorDecorations extends Disposable {
 					},
 					renderOptions: {
 						after: {
-							contentText: viewModel.inputPlaceholder ?? defaultAgent?.description ?? '',
+							contentText: viewModel.inputPlaceholder || (defaultAgent?.description ?? ''),
 							color: this.getPlaceholderColor()
 						}
 					}

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

@@ -63,7 +63,7 @@ export interface IChatAgentData {
 export interface IChatAgentImplementation {
 	invoke(request: IChatAgentRequest, progress: (part: IChatProgress) => void, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatAgentResult>;
 	provideFollowups?(request: IChatAgentRequest, result: IChatAgentResult, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatFollowup[]>;
-	provideWelcomeMessage?(token: CancellationToken): ProviderResult<(string | IMarkdownString)[] | undefined>;
+	provideWelcomeMessage?(location: ChatAgentLocation, token: CancellationToken): ProviderResult<(string | IMarkdownString)[] | undefined>;
 	provideSampleQuestions?(location: ChatAgentLocation, token: CancellationToken): ProviderResult<IChatFollowup[] | undefined>;
 }
 
@@ -335,9 +335,9 @@ export class MergedChatAgent implements IChatAgent {
 		return [];
 	}
 
-	provideWelcomeMessage(token: CancellationToken): ProviderResult<(string | IMarkdownString)[] | undefined> {
+	provideWelcomeMessage(location: ChatAgentLocation, token: CancellationToken): ProviderResult<(string | IMarkdownString)[] | undefined> {
 		if (this.impl.provideWelcomeMessage) {
-			return this.impl.provideWelcomeMessage(token);
+			return this.impl.provideWelcomeMessage(location, token);
 		}
 
 		return undefined;

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

@@ -350,7 +350,7 @@ export class ChatService extends Disposable implements IChatService {
 				// Should have been registered during activation above!
 				throw new ErrorNoTelemetry('No default agent registered');
 			}
-			const welcomeMessage = model.welcomeMessage ? undefined : await defaultAgent.provideWelcomeMessage?.(token) ?? undefined;
+			const welcomeMessage = model.welcomeMessage ? undefined : await defaultAgent.provideWelcomeMessage?.(model.initialLocation, token) ?? undefined;
 			const welcomeModel = welcomeMessage && this.instantiationService.createInstance(
 				ChatWelcomeMessageModel,
 				welcomeMessage.map(item => typeof item === 'string' ? new MarkdownString(item) : item),

src/vs/workbench/contrib/chat/test/common/voiceChat.test.ts

@@ -34,7 +34,7 @@ suite('VoiceChat', () => {
 			this.name = id;
 		}
 		invoke(request: IChatAgentRequest, progress: (part: IChatProgress) => void, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatAgentResult> { throw new Error('Method not implemented.'); }
-		provideWelcomeMessage?(token: CancellationToken): ProviderResult<(string | IMarkdownString)[] | undefined> { throw new Error('Method not implemented.'); }
+		provideWelcomeMessage?(location: ChatAgentLocation, token: CancellationToken): ProviderResult<(string | IMarkdownString)[] | undefined> { throw new Error('Method not implemented.'); }
 		metadata = {};
 	}
 

src/vs/workbench/contrib/inlineChat/browser/inlineChatContentWidget.ts

@@ -132,9 +132,9 @@ export class InlineChatContentWidget implements IContentWidget {
 	beforeRender(): IDimension | null {
 
 		const maxHeight = this._widget.input.inputEditor.getOption(EditorOption.lineHeight) * 5;
-		const inputEditorHeight = this._widget.inputEditor.getContentHeight();
+		const inputEditorHeight = this._widget.contentHeight;
 
-		this._widget.inputEditor.layout(new dom.Dimension(360, Math.min(maxHeight, inputEditorHeight)));
+		this._widget.layout(Math.min(maxHeight, inputEditorHeight), 360);
 
 		// const actualHeight = this._widget.inputPartHeight;
 		// return new dom.Dimension(width, actualHeight);
@@ -194,9 +194,11 @@ export class InlineChatContentWidget implements IContentWidget {
 	}
 
 	private _updateMessage(message: string) {
-		this._messageContainer.classList.toggle('hidden', !message);
-		const renderedMessage = renderLabelWithIcons(message);
-		dom.reset(this._messageContainer, ...renderedMessage);
+		if (message) {
+			const renderedMessage = renderLabelWithIcons(message);
+			dom.reset(this._messageContainer, ...renderedMessage);
+		}
+		this._messageContainer.style.display = message ? 'inherit' : 'none';
 		this._editor.layoutContentWidget(this);
 	}
 }

src/vs/workbench/contrib/inlineChat/browser/inlineChatSessionServiceImpl.ts

@@ -5,38 +5,41 @@
 import { coalesceInPlace, isNonEmptyArray } from 'vs/base/common/arrays';
 import { raceCancellation } from 'vs/base/common/async';
 import { CancellationToken } from 'vs/base/common/cancellation';
-import { Codicon } from 'vs/base/common/codicons';
 import { CancellationError } from 'vs/base/common/errors';
 import { Emitter, Event } from 'vs/base/common/event';
 import { MarkdownString } from 'vs/base/common/htmlContent';
 import { Iterable } from 'vs/base/common/iterator';
-import { DisposableStore, IDisposable, MutableDisposable, toDisposable } from 'vs/base/common/lifecycle';
+import { DisposableMap, DisposableStore, IDisposable, MutableDisposable, toDisposable } from 'vs/base/common/lifecycle';
 import { LRUCache } from 'vs/base/common/map';
 import { Schemas } from 'vs/base/common/network';
 import { URI } from 'vs/base/common/uri';
 import { generateUuid } from 'vs/base/common/uuid';
 import { IActiveCodeEditor, ICodeEditor } from 'vs/editor/browser/editorBrowser';
-import { Range } from 'vs/editor/common/core/range';
-import { TextEdit } from 'vs/editor/common/languages';
+import { IRange, Range } from 'vs/editor/common/core/range';
+import { TextEdit, WorkspaceEdit } from 'vs/editor/common/languages';
 import { ITextModel, IValidEditOperation } from 'vs/editor/common/model';
 import { createTextBufferFactoryFromSnapshot } from 'vs/editor/common/model/textModel';
 import { IEditorWorkerService } from 'vs/editor/common/services/editorWorker';
 import { IModelService } from 'vs/editor/common/services/model';
 import { ITextModelService } from 'vs/editor/common/services/resolverService';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { ILogService } from 'vs/platform/log/common/log';
-import { Progress } from 'vs/platform/progress/common/progress';
+import { IProgress, Progress } from 'vs/platform/progress/common/progress';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 import { DEFAULT_EDITOR_ASSOCIATION } from 'vs/workbench/common/editor';
-import { ChatAgentLocation, IChatAgentCommand, IChatAgentData, IChatAgentHistoryEntry, IChatAgentImplementation, IChatAgentRequest, IChatAgentResult, IChatAgentService } from 'vs/workbench/contrib/chat/common/chatAgents';
+import { ChatAgentLocation, IChatAgent, IChatAgentCommand, IChatAgentData, IChatAgentHistoryEntry, IChatAgentImplementation, IChatAgentRequest, IChatAgentResult, IChatAgentService } from 'vs/workbench/contrib/chat/common/chatAgents';
 import { IChatFollowup, IChatProgress, IChatService, InteractiveSessionVoteDirection } from 'vs/workbench/contrib/chat/common/chatService';
-import { EditMode, IInlineChatBulkEditResponse, IInlineChatProgressItem, IInlineChatRequest, IInlineChatResponse, IInlineChatService, IInlineChatSession, InlineChatResponseFeedbackKind, InlineChatResponseType } from 'vs/workbench/contrib/inlineChat/common/inlineChat';
+import { EditMode, IInlineChatBulkEditResponse, IInlineChatProgressItem, IInlineChatRequest, IInlineChatResponse, IInlineChatService, IInlineChatSession, IInlineChatSessionProvider, IInlineChatSlashCommand, InlineChatResponseFeedbackKind, InlineChatResponseType } from 'vs/workbench/contrib/inlineChat/common/inlineChat';
 import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
-import { nullExtensionDescription } from 'vs/workbench/services/extensions/common/extensions';
 import { UntitledTextEditorInput } from 'vs/workbench/services/untitled/common/untitledTextEditorInput';
 import { EmptyResponse, ErrorResponse, HunkData, ReplyResponse, Session, SessionExchange, SessionWholeRange, StashedSession, TelemetryData, TelemetryDataClassification } from './inlineChatSession';
 import { IInlineChatSessionEndEvent, IInlineChatSessionEvent, IInlineChatSessionService, ISessionKeyComputer, Recording } from './inlineChatSessionService';
 import { IChatVariablesService } from 'vs/workbench/contrib/chat/common/chatVariables';
+import { ISelection } from 'vs/editor/common/core/selection';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+import { nullExtensionDescription } from 'vs/workbench/services/extensions/common/extensions';
+import { Codicon } from 'vs/base/common/codicons';
+import { isEqual } from 'vs/base/common/resources';
 
 class BridgeAgent implements IChatAgentImplementation {
 
@@ -186,7 +189,7 @@ class BridgeAgent implements IChatAgentImplementation {
 		return chatFollowups;
 	}
 
-	provideWelcomeMessage(token: CancellationToken): string[] {
+	provideWelcomeMessage(location: ChatAgentLocation, token: CancellationToken): string[] {
 		// without this provideSampleQuestions is not called
 		return [];
 	}
@@ -227,6 +230,17 @@ export class InlineChatError extends Error {
 const _bridgeAgentId = 'brigde.editor';
 const _inlineChatContext = '_inlineChatContext';
 
+class InlineChatContext {
+
+	static readonly variableName = '_inlineChatContext';
+
+	constructor(
+		readonly uri: URI,
+		readonly selection: ISelection,
+		readonly wholeRange: IRange,
+	) { }
+}
+
 export class InlineChatSessionServiceImpl implements IInlineChatSessionService {
 
 	declare _serviceBrand: undefined;
@@ -265,6 +279,37 @@ export class InlineChatSessionServiceImpl implements IInlineChatSessionService {
 		@IChatVariablesService chatVariableService: IChatVariablesService,
 	) {
 
+		const fakeProviders = this._store.add(new DisposableMap<string, IDisposable>());
+
+		this._store.add(this._chatAgentService.onDidChangeAgents(() => {
+
+			const providersNow = new Set<string>();
+
+			for (const agent of this._chatAgentService.getActivatedAgents()) {
+				if (agent.id === _bridgeAgentId) {
+					// not interesting
+					continue;
+				}
+				if (!agent.locations.includes(ChatAgentLocation.Editor) || !agent.isDefault) {
+					// not interesting
+					continue;
+				}
+				providersNow.add(agent.id);
+
+				if (!fakeProviders.has(agent.id)) {
+					fakeProviders.set(agent.id, _inlineChatService.addProvider(_instaService.createInstance(AgentInlineChatProvider, agent)));
+					this._logService.info(`ADDED inline chat provider for agent ${agent.id}`);
+				}
+			}
+
+			for (const [id] of fakeProviders) {
+				if (!providersNow.has(id)) {
+					fakeProviders.deleteAndDispose(id);
+					this._logService.info(`REMOVED inline chat provider for agent ${id}`);
+				}
+			}
+		}));
+
 		// MARK: register fake chat agent
 		const addOrRemoveBridgeAgent = () => {
 			const that = this;
@@ -339,10 +384,7 @@ export class InlineChatSessionServiceImpl implements IInlineChatSessionService {
 					if (data.session.chatModel === model) {
 						return [{
 							level: 'full',
-							value: JSON.stringify({
-								selection: data.editor.getSelection(),
-								wholeRange: data.session.wholeRange.trackedInitialRange
-							})
+							value: JSON.stringify(new InlineChatContext(data.session.textModelN.uri, data.editor.getSelection()!, data.session.wholeRange.trackedInitialRange))
 						}];
 					}
 				}
@@ -360,7 +402,21 @@ export class InlineChatSessionServiceImpl implements IInlineChatSessionService {
 
 	async createSession(editor: IActiveCodeEditor, options: { editMode: EditMode; wholeRange?: Range }, token: CancellationToken): Promise<Session | undefined> {
 
-		const provider = Iterable.first(this._inlineChatService.getAllProvider());
+		const agent = this._chatAgentService.getDefaultAgent(ChatAgentLocation.Editor);
+		let provider: IInlineChatSessionProvider | undefined;
+		if (agent) {
+			for (const candidate of this._inlineChatService.getAllProvider()) {
+				if (candidate instanceof AgentInlineChatProvider && candidate.agent === agent) {
+					provider = candidate;
+					break;
+				}
+			}
+		}
+
+		if (!provider) {
+			provider = Iterable.first(this._inlineChatService.getAllProvider());
+		}
+
 		if (!provider) {
 			this._logService.trace('[IE] NO provider found');
 			return undefined;
@@ -684,3 +740,92 @@ export class InlineChatSessionServiceImpl implements IInlineChatSessionService {
 		return this._recordings;
 	}
 }
+
+export class AgentInlineChatProvider implements IInlineChatSessionProvider {
+
+	readonly extensionId: ExtensionIdentifier;
+	readonly label: string;
+	readonly supportIssueReporting?: boolean | undefined;
+
+	constructor(
+		readonly agent: IChatAgent,
+		@IChatAgentService private readonly _chatAgentService: IChatAgentService,
+	) {
+		this.label = agent.name;
+		this.extensionId = agent.extensionId;
+		this.supportIssueReporting = agent.metadata.supportIssueReporting;
+	}
+
+	async prepareInlineChatSession(model: ITextModel, range: ISelection, token: CancellationToken): Promise<IInlineChatSession> {
+
+		// TODO@jrieken have a good welcome message
+		// const welcomeMessage = await this.agent.provideWelcomeMessage?.(ChatAgentLocation.Editor, token);
+		// const message =  welcomeMessage?.filter(candidate => typeof candidate === 'string').join(''),
+
+		return {
+			id: Math.random(),
+			wholeRange: new Range(range.selectionStartLineNumber, range.selectionStartColumn, range.positionLineNumber, range.positionColumn),
+			placeholder: this.agent.description,
+			slashCommands: this.agent.slashCommands.map(agentCommand => {
+				return {
+					command: agentCommand.name,
+					detail: agentCommand.description,
+					refer: agentCommand.name === 'explain' // TODO@jrieken @joyceerhl this should be cleaned up
+				} satisfies IInlineChatSlashCommand;
+			})
+		};
+	}
+
+	async provideResponse(item: IInlineChatSession, request: IInlineChatRequest, progress: IProgress<IInlineChatProgressItem>, token: CancellationToken): Promise<IInlineChatResponse> {
+
+		const workspaceEdit: WorkspaceEdit = { edits: [] };
+
+		await this._chatAgentService.invokeAgent(this.agent.id, {
+			sessionId: String(item.id),
+			requestId: request.requestId,
+			agentId: this.agent.id,
+			message: request.prompt,
+			location: ChatAgentLocation.Editor,
+			variables: {
+				variables: [{
+					name: InlineChatContext.variableName,
+					values: [{
+						level: 'full',
+						value: JSON.stringify(new InlineChatContext(request.previewDocument, request.selection, request.wholeRange))
+					}]
+				}]
+			}
+		}, part => {
+
+			if (part.kind === 'markdownContent') {
+				progress.report({ markdownFragment: part.content.value });
+			} else if (part.kind === 'agentDetection') {
+				progress.report({ slashCommand: part.command?.name });
+			} else if (part.kind === 'textEdit') {
+
+				if (isEqual(request.previewDocument, part.uri)) {
+					progress.report({ edits: part.edits });
+				} else {
+					for (const textEdit of part.edits) {
+						workspaceEdit.edits.push({ resource: part.uri, textEdit, versionId: undefined });
+					}
+				}
+			}
+
+		}, [], token);
+
+		return {
+			type: InlineChatResponseType.BulkEdit,
+			id: Math.random(),
+			edits: workspaceEdit
+		};
+	}
+
+	// handleInlineChatResponseFeedback?(session: IInlineChatSession, response: IInlineChatResponse, kind: InlineChatResponseFeedbackKind): void {
+	// 	throw new Error('Method not implemented.');
+	// }
+
+	// provideFollowups?(session: IInlineChatSession, response: IInlineChatResponse, token: CancellationToken): ProviderResult<IInlineChatFollowup[]> {
+	// 	throw new Error('Method not implemented.');
+	// }
+}