inlineChatIntent.ts

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

import * as l10n from '@vscode/l10n';
import { Raw } from '@vscode/prompt-tsx';
import { BudgetExceededError } from '@vscode/prompt-tsx/dist/base/materialized';
import type * as vscode from 'vscode';
import { IAuthenticationService } from '../../../platform/authentication/common/authentication';
import { CanceledResult, ChatFetchResponseType, ChatLocation, ChatResponse, getErrorDetailsFromChatFetchError } from '../../../platform/chat/common/commonTypes';
import { ConfigKey, IConfigurationService } from '../../../platform/configuration/common/configurationService';
import { IEditSurvivalTrackerService } from '../../../platform/editSurvivalTracking/common/editSurvivalTrackerService';
import { IEndpointProvider } from '../../../platform/endpoint/common/endpointProvider';
import { IOctoKitService } from '../../../platform/github/common/githubService';
import { IIgnoreService } from '../../../platform/ignore/common/ignoreService';
import { ILogService } from '../../../platform/log/common/logService';
import { IChatEndpoint, IMakeChatRequestOptions } from '../../../platform/networking/common/networking';
import { IExperimentationService } from '../../../platform/telemetry/common/nullExperimentationService';
import { ChatResponseStreamImpl } from '../../../util/common/chatResponseStreamImpl';
import { toErrorMessage } from '../../../util/common/errorMessage';
import { isNonEmptyArray } from '../../../util/vs/base/common/arrays';
import { timeout } from '../../../util/vs/base/common/async';
import { CancellationToken } from '../../../util/vs/base/common/cancellation';
import { ResourceSet } from '../../../util/vs/base/common/map';
import { assertType, isDefined } from '../../../util/vs/base/common/types';
import { IInstantiationService } from '../../../util/vs/platform/instantiation/common/instantiation';
import { ChatRequestEditorData, ChatResponseTextEditPart, LanguageModelTextPart, LanguageModelToolResult } from '../../../vscodeTypes';
import { Intent } from '../../common/constants';
import { getAgentTools } from '../../intents/node/agentIntent';
import { ChatVariablesCollection } from '../../prompt/common/chatVariablesCollection';
import { Conversation } from '../../prompt/common/conversation';
import { IToolCall } from '../../prompt/common/intents';
import { ToolCallRound } from '../../prompt/common/toolCallRound';
import { ChatTelemetryBuilder, InlineChatTelemetry } from '../../prompt/node/chatParticipantTelemetry';
import { IDocumentContext } from '../../prompt/node/documentContext';
import { IIntent } from '../../prompt/node/intents';
import { PromptRenderer } from '../../prompts/node/base/promptRenderer';
import { ICompletedToolCallRound, InlineChat2Prompt, LARGE_FILE_LINE_THRESHOLD } from './inlineChatPrompt';
import { ToolName } from '../../tools/common/toolNames';
import { CopilotToolMode } from '../../tools/common/toolsRegistry';
import { isToolValidationError, isValidatedToolInput, IToolsService } from '../../tools/common/toolsService';
import { InlineChatProgressMessages } from './progressMessages';
import { CopilotInteractiveEditorResponse, InteractionOutcome } from '../../inlineChat/node/promptCraftingTypes';


const INLINE_CHAT_EXIT_TOOL_NAME = 'inline_chat_exit';

interface IInlineChatEditResult {
	telemetry: InlineChatTelemetry;
	lastResponse: ChatResponse;
	needsExitTool: boolean;
	errorMessage?: string;
}


export class InlineChatIntent implements IIntent {

	static readonly ID = Intent.InlineChat;



	readonly id = InlineChatIntent.ID;

	readonly locations = [ChatLocation.Editor];

	readonly description: string = '';

	private readonly _progressMessages: InlineChatProgressMessages;

	constructor(
		@IInstantiationService private readonly _instantiationService: IInstantiationService,
		@IEndpointProvider private readonly _endpointProvider: IEndpointProvider,
		@IAuthenticationService private readonly _authenticationService: IAuthenticationService,
		@ILogService private readonly _logService: ILogService,
		@IToolsService private readonly _toolsService: IToolsService,
		@IIgnoreService private readonly _ignoreService: IIgnoreService,
		@IEditSurvivalTrackerService private readonly _editSurvivalTrackerService: IEditSurvivalTrackerService,
		@IOctoKitService private readonly _octoKitService: IOctoKitService,
	) {
		this._progressMessages = this._instantiationService.createInstance(InlineChatProgressMessages);
	}

	async handleRequest(conversation: Conversation, request: vscode.ChatRequest, stream: vscode.ChatResponseStream, token: CancellationToken, documentContext: IDocumentContext | undefined, _agentName: string, _location: ChatLocation, chatTelemetry: ChatTelemetryBuilder): Promise<vscode.ChatResult> {

		assertType(request.location2 instanceof ChatRequestEditorData);
		assertType(documentContext);

		if (await this._ignoreService.isCopilotIgnored(request.location2.document.uri, token)) {
			return {
				errorDetails: {
					message: l10n.t('inlineChat.ignored', 'Copilot is disabled for this file.'),
				}
			};
		}

		const endpoint = await this._endpointProvider.getChatEndpoint(request);

		if (!endpoint.supportsToolCalls) {
			return {
				errorDetails: {
					message: l10n.t('inlineChat.model', '{0} cannot be used for inline chat', endpoint.name),
				}
			};
		}


		const editSurvivalTracker = this._editSurvivalTrackerService.initialize(request.location2.document);

		stream = ChatResponseStreamImpl.spy(stream, part => {
			if (part instanceof ChatResponseTextEditPart) {
				editSurvivalTracker.collectAIEdits(part.edits);
			}
		});

		// Start generating contextual message immediately
		const contextualMessagePromise = this._progressMessages.getContextualMessage(request.prompt, documentContext, token);

		// Show progress message after ~1 second delay (unless request completes first)
		timeout(1000, token).then(async () => {
			const message = await contextualMessagePromise;
			stream.progress(message);
		});

		let result: IInlineChatEditResult;
		try {
			const inlineToolLoop = this._instantiationService.createInstance(InlineChatToolCalling, this);

			result = await inlineToolLoop.run(endpoint, conversation, request, stream, token, documentContext, chatTelemetry);
		} catch (err) {
			this._logService.error(err, 'InlineChatIntent: prompt rendering failed');
			return {
				errorDetails: {
					message: err instanceof BudgetExceededError
						? l10n.t('Sorry, this document is too large for inline chat.')
						: toErrorMessage(err),
				}
			};
		}

		if (token.isCancellationRequested) {
			return CanceledResult;
		}

		if (result.needsExitTool) {
			this._logService.warn('[InlineChat], BAIL_OUT because of needsExitTool');
			// BAILOUT: when no edits were emitted, invoke the exit tool manually
			await this._toolsService.invokeTool(INLINE_CHAT_EXIT_TOOL_NAME, {
				toolInvocationToken: request.toolInvocationToken, input: {
					response: result.lastResponse.type === ChatFetchResponseType.Success ? result.lastResponse.value : undefined,
				}
			}, token);
		}


		// store metadata for telemetry sending
		const turn = conversation.getLatestTurn();
		turn.setMetadata(new CopilotInteractiveEditorResponse(
			undefined,
			{ ...documentContext, query: request.prompt, intent: this },
			result.telemetry.telemetryMessageId, result.telemetry, editSurvivalTracker
		));

		if (result.errorMessage) {
			return {
				errorDetails: {
					message: result.errorMessage,
				}
			};
		}

		if (result.lastResponse.type !== ChatFetchResponseType.Success) {
			const outageStatus = await this._octoKitService.getGitHubOutageStatus();
			const details = getErrorDetailsFromChatFetchError(result.lastResponse, (await this._authenticationService.getCopilotToken()).copilotPlan, outageStatus);
			return {
				errorDetails: {
					message: details.message,
					responseIsFiltered: details.responseIsFiltered
				}
			};
		}

		return {};
	}

	invoke(): Promise<never> {
		throw new TypeError();
	}
}

class InlineChatToolCalling {

	private static readonly _EDIT_TOOLS = new Set<string>([
		ToolName.ApplyPatch,
		ToolName.EditFile,
		ToolName.ReplaceString,
		ToolName.MultiReplaceString,
	]);

	constructor(
		private readonly _intent: InlineChatIntent,
		@IInstantiationService private readonly _instantiationService: IInstantiationService,
		@ILogService private readonly _logService: ILogService,
		@IToolsService private readonly _toolsService: IToolsService,
		@IConfigurationService private readonly _configurationService: IConfigurationService,
		@IExperimentationService private readonly _experimentationService: IExperimentationService,
	) { }

	async run(endpoint: IChatEndpoint, conversation: Conversation, request: vscode.ChatRequest, stream: vscode.ChatResponseStream, token: CancellationToken, documentContext: IDocumentContext, chatTelemetry: ChatTelemetryBuilder): Promise<IInlineChatEditResult> {
		assertType(request.location2 instanceof ChatRequestEditorData);
		assertType(documentContext);

		const isLargeFile = documentContext.document.lineCount > LARGE_FILE_LINE_THRESHOLD;
		const availableTools = await this._getAvailableTools(request, endpoint, isLargeFile);

		const previousRounds: ICompletedToolCallRound[] = [];
		let failedEditCount = 0;
		const toolCallRounds: ToolCallRound[] = [];
		let readOnlyRounds = 0;
		let telemetry: InlineChatTelemetry;
		let lastResponse: ChatResponse;
		let lastInteractionOutcome: InteractionOutcome;

		while (true) {

			const renderer = PromptRenderer.create(this._instantiationService, endpoint, InlineChat2Prompt, {
				request,
				previousRounds,
				hasFailedEdits: failedEditCount > 0,
				snapshotAtRequest: documentContext.document,
				data: request.location2,
				exitToolName: INLINE_CHAT_EXIT_TOOL_NAME,
				isLargeFile,
				readToolName: isLargeFile ? ToolName.ReadFile : undefined,
			});

			const renderResult = await renderer.render(undefined, token, { trace: true });

			const toolTokenCount = availableTools.length > 0 ? await endpoint.acquireTokenizer().countToolTokens(availableTools) : 0;
			telemetry = chatTelemetry.makeRequest(this._intent, ChatLocation.Editor, conversation, renderResult.messages, renderResult.tokenCount, renderResult.references, endpoint, [], availableTools.length, toolTokenCount);

			stream = ChatResponseStreamImpl.spy(stream, part => {
				if (part instanceof ChatResponseTextEditPart) {
					telemetry.markEmittedEdits(part.uri, part.edits);
				}
			});


			const result = await this._makeRequestAndRunTools(endpoint, request, stream, renderResult.messages, availableTools, telemetry, token);

			lastInteractionOutcome = new InteractionOutcome(telemetry.editCount > 0 ? 'inlineEdit' : 'none', []);
			lastResponse = result.fetchResult;

			// telemetry
			{
				const responseText = lastResponse.type === ChatFetchResponseType.Success ? lastResponse.value : '';
				telemetry.sendTelemetry(
					lastResponse.requestId, lastResponse.type, responseText,
					lastInteractionOutcome,
					result.toolCalls
				);

				toolCallRounds.push(ToolCallRound.create({
					response: responseText,
					toolCalls: result.toolCalls,
					toolInputRetry: failedEditCount
				}));
			}

			if (result.toolCalls.length === 0) {
				// BAILOUT: when no tools have been used
				break;
			}

			// Build a completed round from all tool calls in their original order
			const roundCalls: [IToolCall, vscode.ExtendedLanguageModelToolResult][] = [];
			for (const toolCall of result.toolCalls) {
				const toolResult = result.allCallResults.get(toolCall.id);
				if (toolResult) {
					roundCalls.push([toolCall, toolResult]);
				}
			}
			previousRounds.push({ calls: roundCalls });

			// Check if this round was read-only (only read_file calls, no edit tool calls)
			const hasEditToolCalls = result.toolCalls.some(tc => tc.name !== ToolName.ReadFile);

			if (!hasEditToolCalls) {
				// Read-only round: the model used read_file to gather more context.
				// Continue the loop so it can make edits with the new info.
				readOnlyRounds++;
				if (readOnlyRounds > 9) {
					this._logService.warn('Aborting inline chat edit: too many read-only rounds');
					break;
				}
				continue;
			}

			if (result.failedEdits.length === 0 || token.isCancellationRequested) {
				// DONE
				break;
			}

			failedEditCount += result.failedEdits.length;
			if (failedEditCount > 5) {
				// TOO MANY FAILED ATTEMPTS
				this._logService.error(`Aborting inline chat edit: too many failed edit attempts`);
				break;
			}
		}

		telemetry.sendToolCallingTelemetry(toolCallRounds, availableTools, token.isCancellationRequested ? 'cancelled' : lastResponse.type);

		const needsExitTool = lastResponse.type === ChatFetchResponseType.Success
			&& (toolCallRounds.length === 0 || (toolCallRounds.length > 0 && toolCallRounds[toolCallRounds.length - 1].toolCalls.length === 0));

		if (!needsExitTool && failedEditCount > 0 && telemetry.editCount === 0 && lastResponse.type === ChatFetchResponseType.Success) {
			return {
				lastResponse,
				telemetry,
				needsExitTool: false,
				errorMessage: l10n.t('Failed to edit the file. The requested change could not be applied.'),
			};
		}

		return { lastResponse, telemetry, needsExitTool };
	}

	private async _makeRequestAndRunTools(endpoint: IChatEndpoint, request: vscode.ChatRequest, stream: vscode.ChatResponseStream, messages: Raw.ChatMessage[], inlineChatTools: vscode.LanguageModelToolInformation[], telemetry: InlineChatTelemetry, token: CancellationToken) {

		const requestOptions: IMakeChatRequestOptions['requestOptions'] = {
			tool_choice: 'auto',
			// Inline chat only uses internal tools with known-good schemas,
			// skip expensive normalizeToolSchema validation
			tools: inlineChatTools.map(tool => ({
				type: 'function' as const,
				function: {
					name: tool.name,
					description: tool.description,
					parameters: tool.inputSchema && Object.keys(tool.inputSchema).length ? tool.inputSchema : undefined
				},
			})),
		};

		const toolCalls: IToolCall[] = [];
		const failedEdits: [IToolCall, vscode.ExtendedLanguageModelToolResult][] = [];
		const allCallResults = new Map<string, vscode.ExtendedLanguageModelToolResult>();

		const toolExecutions: Promise<unknown>[] = [];

		const fetchResult = await endpoint.makeChatRequest2({
			debugName: 'InlineChat2Intent',
			messages,
			userInitiatedRequest: true,
			location: ChatLocation.Editor,
			requestOptions,
			modelCapabilities: {
				enableThinking: this._configurationService.getExperimentBasedConfig(ConfigKey.Advanced.InlineChatEnableThinking, this._experimentationService),
				reasoningEffort: typeof request.modelConfiguration?.reasoningEffort === 'string'
					? request.modelConfiguration.reasoningEffort
					: this._configurationService.getExperimentBasedConfig(ConfigKey.Advanced.InlineChatReasoningEffort, this._experimentationService),
			},
			telemetryProperties: {
				messageId: telemetry.telemetryMessageId,
				conversationId: telemetry.sessionId,
				messageSource: this._intent.id
			},
			finishedCb: async (_text, _index, delta) => {

				telemetry.markReceivedToken();

				if (!isNonEmptyArray(delta.copilotToolCalls)) {
					return undefined;
				}

				const exitToolCall = delta.copilotToolCalls.find(candidate => candidate.name === INLINE_CHAT_EXIT_TOOL_NAME);
				const copilotToolCalls = exitToolCall ? [exitToolCall] : delta.copilotToolCalls;

				for (const toolCall of copilotToolCalls) {

					toolCalls.push(toolCall);

					const validationResult = this._toolsService.validateToolInput(toolCall.name, toolCall.arguments);

					if (isToolValidationError(validationResult)) {
						this._logService.warn(`Tool ${toolCall.name} invocation failed validation: ${validationResult}`);
						const errorResult = new LanguageModelToolResult([new LanguageModelTextPart(validationResult.error)]);
						allCallResults.set(toolCall.id, errorResult);
						failedEdits.push([toolCall, errorResult]);
						continue;
					}

					toolExecutions.push((async () => {
						try {
							let input = isValidatedToolInput(validationResult)
								? validationResult.inputObj
								: JSON.parse(toolCall.arguments);

							const copilotTool = this._toolsService.getCopilotTool(toolCall.name as ToolName);
							if (copilotTool?.resolveInput) {
								input = await copilotTool.resolveInput(input, {
									request,
									stream,
									query: request.prompt,
									chatVariables: new ChatVariablesCollection([...request.references]),
									history: [],
									allowedEditUris: request.location2 instanceof ChatRequestEditorData ? new ResourceSet([request.location2.document.uri]) : undefined,
								}, CopilotToolMode.FullContext);
							}

							const result = await this._toolsService.invokeToolWithEndpoint(toolCall.name, {
								input,
								toolInvocationToken: request.toolInvocationToken,
								// Split on `__vscode` so it's the chat stream id
								// TODO @lramos15 - This is a gross hack
								chatStreamToolCallId: toolCall.id.split('__vscode')[0],
							}, endpoint, token) as vscode.ExtendedLanguageModelToolResult;

							allCallResults.set(toolCall.id, result);

							if (result.hasError) {
								failedEdits.push([toolCall, result]);
								stream.progress(l10n.t('Looking not yet good, trying again...'));
							}

							this._logService.trace(`Tool ${toolCall.name} invocation result: ${JSON.stringify(result)}`);

						} catch (err) {
							this._logService.error(err, `Tool ${toolCall.name} invocation failed`);
							const errorResult = new LanguageModelToolResult([new LanguageModelTextPart(toErrorMessage(err))]);
							allCallResults.set(toolCall.id, errorResult);
							failedEdits.push([toolCall, errorResult]);
						}
					})());
				}

				return undefined;
			}
		}, token);

		await Promise.allSettled(toolExecutions);

		return { fetchResult, toolCalls, failedEdits, allCallResults };
	}

	private async _getAvailableTools(request: vscode.ChatRequest, model: IChatEndpoint, isLargeFile: boolean): Promise<vscode.LanguageModelToolInformation[]> {
		assertType(request.location2 instanceof ChatRequestEditorData);


		const enabledTools = new Set(InlineChatToolCalling._EDIT_TOOLS);
		if (!request.location2.selection.isEmpty) {
			// only used the multi-replace when there is no selection
			enabledTools.delete(ToolName.MultiReplaceString);
		}

		// ALWAYS enable editing tools (only) and ignore what the client did send
		const fakeRequest: vscode.ChatRequest = {
			...request,
			tools: new Map(
				Array.from(enabledTools)
					.map(t => this._toolsService.getTool(t))
					.filter(isDefined)
					.map(tool => [tool, true])
			),
		};

		const agentTools = await this._instantiationService.invokeFunction(getAgentTools, fakeRequest, model);
		let editTools = agentTools.filter(tool => enabledTools.has(tool.name));

		if (editTools.length === 0) {
			this._logService.error('MISSING inline chat edit tools');
			throw new Error('MISSING inline chat edit tools');
		}

		// EditFile is a poor performer, prefer other edit tools when available
		if (editTools.length > 1) {
			editTools = editTools.filter(tool => tool.name !== ToolName.EditFile);
		}
		// const result = [exitTool, ...editTools];
		const result = [...editTools];

		// For large files, also include the read tool so the model can read more of the file
		if (isLargeFile) {
			const readTool = this._toolsService.getTool(ToolName.ReadFile);
			if (readTool) {
				result.push(readTool);
			} else {
				this._logService.error('MISSING inline chat read tool for large file');
				throw new Error('MISSING inline chat read tool for large file');
			}
		}

		return result;
	}
}