@vscode/chat-lib 0.0.1 → 0.0.3

package/src/_internal/extension/xtab/node/xtabProvider.ts

@@ -1,976 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { Raw } from '@vscode/prompt-tsx';
-import { FetchStreamSource } from '../../../platform/chat/common/chatMLFetcher';
-import { ChatFetchError, ChatFetchResponseType, ChatLocation } from '../../../platform/chat/common/commonTypes';
-import { toTextParts } from '../../../platform/chat/common/globalStringUtils';
-import { ConfigKey, IConfigurationService, XTabProviderId } from '../../../platform/configuration/common/configurationService';
-import { IDiffService } from '../../../platform/diff/common/diffService';
-import { createProxyXtabEndpoint } from '../../../platform/endpoint/node/proxyXtabEndpoint';
-import { IIgnoreService } from '../../../platform/ignore/common/ignoreService';
-import { Copilot } from '../../../platform/inlineCompletions/common/api';
-import { LanguageContextEntry, LanguageContextResponse } from '../../../platform/inlineEdits/common/dataTypes/languageContext';
-import { LanguageId } from '../../../platform/inlineEdits/common/dataTypes/languageId';
-import * as xtabPromptOptions from '../../../platform/inlineEdits/common/dataTypes/xtabPromptOptions';
-import { LanguageContextLanguages, LanguageContextOptions } from '../../../platform/inlineEdits/common/dataTypes/xtabPromptOptions';
-import { InlineEditRequestLogContext } from '../../../platform/inlineEdits/common/inlineEditLogContext';
-import { ResponseProcessor } from '../../../platform/inlineEdits/common/responseProcessor';
-import { IStatelessNextEditProvider, NoNextEditReason, PushEdit, ShowNextEditPreference, StatelessNextEditDocument, StatelessNextEditRequest, StatelessNextEditResult, StatelessNextEditTelemetryBuilder } from '../../../platform/inlineEdits/common/statelessNextEditProvider';
-import { IgnoreEmptyLineAndLeadingTrailingWhitespaceChanges, IgnoreWhitespaceOnlyChanges } from '../../../platform/inlineEdits/common/statelessNextEditProviders';
-import { ILanguageContextProviderService } from '../../../platform/languageContextProvider/common/languageContextProviderService';
-import { ILanguageDiagnosticsService } from '../../../platform/languages/common/languageDiagnosticsService';
-import { ContextKind, SnippetContext } from '../../../platform/languageServer/common/languageContextService';
-import { ILogService } from '../../../platform/log/common/logService';
-import { OptionalChatRequestParams, Prediction } from '../../../platform/networking/common/fetch';
-import { IChatEndpoint } from '../../../platform/networking/common/networking';
-import { ISimulationTestContext } from '../../../platform/simulationTestContext/common/simulationTestContext';
-import { IExperimentationService } from '../../../platform/telemetry/common/nullExperimentationService';
-import { IWorkspaceService } from '../../../platform/workspace/common/workspaceService';
-import { raceFilter } from '../../../util/common/async';
-import * as errors from '../../../util/common/errors';
-import { Result } from '../../../util/common/result';
-import { createTracer, ITracer } from '../../../util/common/tracing';
-import { AsyncIterableObject, DeferredPromise, raceTimeout, timeout } from '../../../util/vs/base/common/async';
-import { CancellationToken } from '../../../util/vs/base/common/cancellation';
-import { StopWatch } from '../../../util/vs/base/common/stopwatch';
-import { LineEdit, LineReplacement } from '../../../util/vs/editor/common/core/edits/lineEdit';
-import { StringEdit, StringReplacement } from '../../../util/vs/editor/common/core/edits/stringEdit';
-import { Position } from '../../../util/vs/editor/common/core/position';
-import { Range } from '../../../util/vs/editor/common/core/range';
-import { LineRange } from '../../../util/vs/editor/common/core/ranges/lineRange';
-import { OffsetRange } from '../../../util/vs/editor/common/core/ranges/offsetRange';
-import { IInstantiationService } from '../../../util/vs/platform/instantiation/common/instantiation';
-import { Position as VscodePosition } from '../../../util/common/test/shims/vscodeTypesShim';
-import { Delayer, DelaySession } from '../../inlineEdits/common/delayer';
-import { editWouldDeleteWhatWasJustInserted } from '../../inlineEdits/common/ghNearbyNesProvider';
-import { getOrDeduceSelectionFromLastEdit } from '../../inlineEdits/common/nearbyCursorInlineEditProvider';
-import { IgnoreImportChangesAspect } from '../../inlineEdits/node/importFiltering';
-import { AREA_AROUND_END_TAG, AREA_AROUND_START_TAG, CODE_TO_EDIT_END_TAG, CODE_TO_EDIT_START_TAG, createTaggedCurrentFileContentUsingPagedClipping, CURSOR_TAG, getUserPrompt, N_LINES_ABOVE, N_LINES_AS_CONTEXT, N_LINES_BELOW, nes41Miniv3SystemPrompt, simplifiedPrompt, systemPromptTemplate, unifiedModelSystemPrompt, xtab275SystemPrompt } from '../common/promptCrafting';
-import { XtabEndpoint } from './xtabEndpoint';
-import { linesWithBackticksRemoved, toLines } from './xtabUtils';
-
-export const IGNORE_TEXT_BEFORE = /```[^\n]*\n/;
-
-namespace ResponseTags {
-	export const NO_CHANGE = {
-		start: '<NO_CHANGE>'
-	};
-	export const EDIT = {
-		start: '<EDIT>',
-		end: '</EDIT>'
-	};
-	export const INSERT = {
-		start: '<INSERT>',
-		end: '</INSERT>'
-	};
-}
-
-const enum RetryState {
-	NotRetrying,
-	RetryingWithExpandedWindow
-}
-
-export class XtabProvider implements IStatelessNextEditProvider {
-
-	public static readonly ID = XTabProviderId;
-
-	public readonly ID = XtabProvider.ID;
-
-	public readonly dependsOnSelection = true;
-	public readonly showNextEditPreference = ShowNextEditPreference.Always;
-
-	private readonly tracer: ITracer;
-	private readonly delayer: Delayer;
-
-	private forceUseDefaultModel: boolean = false;
-
-	constructor(
-		@ISimulationTestContext private readonly simulationCtx: ISimulationTestContext,
-		@IInstantiationService private readonly instaService: IInstantiationService,
-		@IWorkspaceService private readonly workspaceService: IWorkspaceService,
-		@IDiffService private readonly diffService: IDiffService,
-		@IConfigurationService private readonly configService: IConfigurationService,
-		@IExperimentationService private readonly expService: IExperimentationService,
-		@ILogService private readonly logService: ILogService,
-		@ILanguageContextProviderService private readonly langCtxService: ILanguageContextProviderService,
-		@ILanguageDiagnosticsService private readonly langDiagService: ILanguageDiagnosticsService,
-		@IIgnoreService private readonly ignoreService: IIgnoreService,
-	) {
-		this.delayer = new Delayer(this.configService, this.expService);
-		this.tracer = createTracer(['NES', 'XtabProvider'], (s) => this.logService.trace(s));
-	}
-
-	public handleAcceptance(): void {
-		this.delayer.handleAcceptance();
-	}
-
-	public handleRejection(): void {
-		this.delayer.handleRejection();
-	}
-
-	public provideNextEdit(request: StatelessNextEditRequest, pushEdit: PushEdit, logContext: InlineEditRequestLogContext, cancellationToken: CancellationToken): Promise<StatelessNextEditResult> {
-		const filteringPushEdit: PushEdit = (result) => {
-			if (result.isError()) {
-				pushEdit(result);
-				return;
-			}
-			const { edit } = result.val;
-			const filteredEdits = this.filterEdit(request.getActiveDocument(), [edit]);
-			if (filteredEdits.length === 0) { // do not invoke pushEdit
-				return;
-			}
-			pushEdit(result);
-		};
-
-		return this._provideNextEdit(request, filteringPushEdit, logContext, cancellationToken);
-	}
-
-	private filterEdit(activeDoc: StatelessNextEditDocument, edits: readonly LineReplacement[]): readonly LineReplacement[] {
-		type EditFilter = (edits: readonly LineReplacement[]) => readonly LineReplacement[];
-
-		const filters: EditFilter[] = [
-			(edits) => IgnoreImportChangesAspect.filterEdit(activeDoc, edits),
-			(edits) => IgnoreEmptyLineAndLeadingTrailingWhitespaceChanges.filterEdit(activeDoc, edits),
-		];
-
-		if (!this.configService.getExperimentBasedConfig(ConfigKey.InlineEditsAllowWhitespaceOnlyChanges, this.expService)) {
-			filters.push((edits) => IgnoreWhitespaceOnlyChanges.filterEdit(activeDoc, edits));
-		}
-
-		return filters.reduce((acc, filter) => filter(acc), edits);
-	}
-
-	public async _provideNextEdit(request: StatelessNextEditRequest, pushEdit: PushEdit, logContext: InlineEditRequestLogContext, cancellationToken: CancellationToken): Promise<StatelessNextEditResult> {
-		const telemetry = new StatelessNextEditTelemetryBuilder(request);
-
-		logContext.setProviderStartTime();
-		try {
-			if (request.xtabEditHistory.length === 0) {
-				return StatelessNextEditResult.noEdit(new NoNextEditReason.ActiveDocumentHasNoEdits(), telemetry);
-			}
-
-			const delaySession = this.delayer.createDelaySession(request.providerRequestStartDateTime);
-
-			const nextEditResult = await this.doGetNextEdit(request, pushEdit, delaySession, logContext, cancellationToken, telemetry, RetryState.NotRetrying);
-
-			if (nextEditResult.isError() && nextEditResult.err instanceof NoNextEditReason.GotCancelled) {
-				logContext.setIsSkipped();
-			}
-
-			if (nextEditResult.isOk()) {
-				await this.enforceArtificialDelay(delaySession, telemetry);
-			}
-
-			return new StatelessNextEditResult(nextEditResult, telemetry.build(nextEditResult));
-		} catch (err: unknown) {
-			return StatelessNextEditResult.noEdit(new NoNextEditReason.Unexpected(errors.fromUnknown(err)), telemetry);
-		} finally {
-			logContext.setProviderEndTime();
-		}
-	}
-
-	private async doGetNextEdit(
-		request: StatelessNextEditRequest,
-		pushEdit: PushEdit,
-		delaySession: DelaySession,
-		logContext: InlineEditRequestLogContext,
-		cancellationToken: CancellationToken,
-		telemetryBuilder: StatelessNextEditTelemetryBuilder,
-		retryState: RetryState,
-	): Promise<Result<void, NoNextEditReason>> {
-
-		const tracer = this.tracer.sub('doGetNextEdit');
-
-		const activeDocument = request.getActiveDocument();
-
-		const selection = getOrDeduceSelectionFromLastEdit(activeDocument);
-
-		if (selection === null) {
-			return Result.error(new NoNextEditReason.Uncategorized(new Error('NoSelection')));
-		}
-
-		const endpoint = this.getEndpoint();
-		logContext.setEndpointInfo(typeof endpoint.urlOrRequestMetadata === 'string' ? endpoint.urlOrRequestMetadata : JSON.stringify(endpoint.urlOrRequestMetadata.type), endpoint.model);
-		telemetryBuilder.setModelName(endpoint.model);
-
-		const computeTokens = (s: string) => Math.floor(s.length / 4);
-
-		const cursorPosition = new Position(selection.endLineNumber, selection.endColumn);
-
-		const cursorOffset = activeDocument.documentAfterEdits.getTransformer().getOffset(cursorPosition);
-
-		const currentFileContent = activeDocument.documentAfterEdits;
-		const currentFileContentLines = currentFileContent.getLines();
-
-		const cursorLineIdx = cursorPosition.lineNumber - 1 /* to convert to 0-based */;
-
-		const cursorLine = currentFileContentLines[cursorLineIdx];
-		const isCursorAtEndOfLine = cursorPosition.column === cursorLine.trimEnd().length;
-		if (isCursorAtEndOfLine) {
-			delaySession.setExtraDebounce(this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsExtraDebounceEndOfLine, this.expService));
-		}
-		telemetryBuilder.setIsCursorAtLineEnd(isCursorAtEndOfLine);
-
-		const areaAroundEditWindowLinesRange = this.computeAreaAroundEditWindowLinesRange(currentFileContentLines, cursorLineIdx);
-
-		const editWindowLinesRange = this.computeEditWindowLinesRange(currentFileContentLines, cursorLineIdx, request, retryState);
-
-		const cursorOriginalLinesOffset = Math.max(0, cursorLineIdx - editWindowLinesRange.start);
-		const editWindowLastLineLength = activeDocument.documentAfterEdits.getTransformer().getLineLength(editWindowLinesRange.endExclusive);
-		const editWindow = activeDocument.documentAfterEdits.getTransformer().getOffsetRange(new Range(editWindowLinesRange.start + 1, 1, editWindowLinesRange.endExclusive, editWindowLastLineLength + 1));
-
-		const editWindowLines = currentFileContentLines.slice(editWindowLinesRange.start, editWindowLinesRange.endExclusive);
-
-		// Expected: editWindow.substring(activeDocument.documentAfterEdits.value) === editWindowLines.join('\n')
-
-		const doesIncludeCursorTag = editWindowLines.some(line => line.includes(CURSOR_TAG));
-		const shouldRemoveCursorTagFromResponse = !doesIncludeCursorTag; // we'd like to remove the tag only if the original edit-window didn't include the tag
-
-		const addCursorTagEdit = StringEdit.single(StringReplacement.insert(cursorOffset, CURSOR_TAG));
-		const contentWithCursor = addCursorTagEdit.applyOnText(currentFileContent);
-		const contentWithCursorLines = contentWithCursor.getLines();
-
-		const editWindowWithCursorLines = contentWithCursorLines.slice(editWindowLinesRange.start, editWindowLinesRange.endExclusive);
-
-		const areaAroundCodeToEdit = [
-			AREA_AROUND_START_TAG,
-			...contentWithCursorLines.slice(areaAroundEditWindowLinesRange.start, editWindowLinesRange.start),
-			CODE_TO_EDIT_START_TAG,
-			...editWindowWithCursorLines,
-			CODE_TO_EDIT_END_TAG,
-			...contentWithCursorLines.slice(editWindowLinesRange.endExclusive, areaAroundEditWindowLinesRange.endExclusive),
-			AREA_AROUND_END_TAG
-		].join('\n');
-
-		let promptOptions: xtabPromptOptions.PromptOptions;
-
-		if (this.forceUseDefaultModel) {
-			promptOptions = xtabPromptOptions.DEFAULT_OPTIONS;
-		} else {
-			const promptingStrategy = this.determinePromptingStrategy({
-				isXtabUnifiedModel: this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabUseUnifiedModel, this.expService),
-				isCodexV21NesUnified: this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabCodexV21NesUnified, this.expService),
-				useSimplifiedPrompt: this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabProviderUseSimplifiedPrompt, this.expService),
-				useXtab275Prompting: this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabProviderUseXtab275Prompting, this.expService),
-				useNes41Miniv3Prompting: this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabUseNes41Miniv3Prompting, this.expService),
-			});
-			promptOptions = {
-				promptingStrategy,
-				currentFile: {
-					maxTokens: this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabCurrentFileMaxTokens, this.expService),
-					includeTags: promptingStrategy !== xtabPromptOptions.PromptingStrategy.UnifiedModel /* unified model doesn't use tags in current file */ && this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabIncludeTagsInCurrentFile, this.expService),
-					prioritizeAboveCursor: this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabPrioritizeAboveCursor, this.expService)
-				},
-				pagedClipping: {
-					pageSize: this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabPageSize, this.expService)
-				},
-				recentlyViewedDocuments: {
-					nDocuments: this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabNRecentlyViewedDocuments, this.expService),
-					maxTokens: this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabRecentlyViewedDocumentsMaxTokens, this.expService),
-					includeViewedFiles: this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabIncludeViewedFiles, this.expService),
-				},
-				languageContext: this.determineLanguageContextOptions(activeDocument.languageId, {
-					enabled: this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabLanguageContextEnabled, this.expService),
-					enabledLanguages: this.configService.getConfig(ConfigKey.Internal.InlineEditsXtabLanguageContextEnabledLanguages),
-					maxTokens: this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabLanguageContextMaxTokens, this.expService),
-				}),
-				diffHistory: {
-					nEntries: this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabDiffNEntries, this.expService),
-					maxTokens: this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabDiffMaxTokens, this.expService),
-					onlyForDocsInPrompt: this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabDiffOnlyForDocsInPrompt, this.expService),
-					useRelativePaths: this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabDiffUseRelativePaths, this.expService),
-				}
-			};
-		}
-
-		const areaAroundCodeToEditForCurrentFile = promptOptions.currentFile.includeTags
-			? areaAroundCodeToEdit
-			: [
-				...contentWithCursorLines.slice(areaAroundEditWindowLinesRange.start, editWindowLinesRange.start),
-				...editWindowLines,
-				...contentWithCursorLines.slice(editWindowLinesRange.endExclusive, areaAroundEditWindowLinesRange.endExclusive),
-			].join('\n');
-		const { taggedCurrentFileContent, nLines: nLinesCurrentFile } = createTaggedCurrentFileContentUsingPagedClipping(
-			currentFileContentLines,
-			areaAroundCodeToEditForCurrentFile,
-			areaAroundEditWindowLinesRange,
-			computeTokens,
-			promptOptions.pagedClipping.pageSize,
-			promptOptions.currentFile,
-		);
-		telemetryBuilder.setNLinesOfCurrentFileInPrompt(nLinesCurrentFile);
-
-		const recordingEnabled = this.configService.getConfig<boolean>(ConfigKey.Internal.InlineEditsLogContextRecorderEnabled);
-
-		let langCtx: LanguageContextResponse | undefined;
-		if (promptOptions.languageContext.enabled || recordingEnabled) {
-			const langCtxPromise = this.getLanguageContext(request, delaySession, activeDocument, cursorPosition, logContext, cancellationToken, promptOptions);
-
-			if (promptOptions.languageContext.enabled) {
-				langCtx = await langCtxPromise;
-			}
-
-			if (recordingEnabled) {
-				logContext.setFileDiagnostics(this.langDiagService.getAllDiagnostics());
-				langCtxPromise.then(langCtxs => {
-					if (langCtxs) {
-						logContext.setLanguageContext(langCtxs);
-					}
-				});
-			}
-		}
-
-		const userPrompt = getUserPrompt(request, taggedCurrentFileContent, areaAroundCodeToEdit, langCtx, computeTokens, promptOptions);
-
-		const prediction = this.getPredictedOutput(editWindowLines, promptOptions.promptingStrategy);
-
-		const messages = [
-			{
-				role: Raw.ChatRole.System,
-				content: toTextParts(this.pickSystemPrompt(promptOptions.promptingStrategy))
-			},
-			{ role: Raw.ChatRole.User, content: toTextParts(userPrompt) }
-		] satisfies Raw.ChatMessage[];
-
-		logContext.setPrompt(messages);
-		telemetryBuilder.setPrompt(messages);
-
-		await this.debounce(delaySession, telemetryBuilder);
-		if (cancellationToken.isCancellationRequested) {
-			return Result.error(new NoNextEditReason.GotCancelled('afterDebounce'));
-		}
-
-		request.fetchIssued = true;
-
-		const cursorLineOffset = cursorPosition.column;
-		this.streamEdits(
-			request,
-			pushEdit,
-			endpoint,
-			messages,
-			editWindow,
-			editWindowLines,
-			cursorOriginalLinesOffset,
-			cursorLineOffset,
-			editWindowLinesRange,
-			prediction,
-			{
-				shouldRemoveCursorTagFromResponse,
-				promptingStrategy: promptOptions.promptingStrategy,
-				retryState,
-			},
-			delaySession,
-			tracer,
-			telemetryBuilder,
-			logContext,
-			cancellationToken
-		);
-		return Result.ok<void>(undefined);
-	}
-
-	private async getLanguageContext(
-		request: StatelessNextEditRequest,
-		delaySession: DelaySession,
-		activeDocument: StatelessNextEditDocument,
-		cursorPosition: Position,
-		logContext: InlineEditRequestLogContext,
-		cancellationToken: CancellationToken,
-		promptOptions: xtabPromptOptions.PromptOptions
-	): Promise<LanguageContextResponse | undefined> {
-		try {
-			const textDoc = this.workspaceService.textDocuments.find(doc => doc.uri.toString() === activeDocument.id.uri);
-			if (textDoc === undefined) {
-				return undefined;
-			}
-
-			const providers = this.langCtxService.getContextProviders(textDoc);
-			if (providers.length < 1) {
-				return undefined;
-			}
-
-			const debounceTime = delaySession.getDebounceTime();
-
-			const cursorPositionVscode = new VscodePosition(cursorPosition.lineNumber - 1, cursorPosition.column - 1);
-
-			const ctxRequest: Copilot.ResolveRequest = {
-				opportunityId: request.opportunityId,
-				completionId: request.id,
-				documentContext: {
-					uri: textDoc.uri.toString(),
-					languageId: textDoc.languageId,
-					version: textDoc.version,
-					offset: textDoc.offsetAt(cursorPositionVscode)
-				},
-				activeExperiments: new Map(),
-				timeBudget: debounceTime,
-				timeoutEnd: Date.now() + debounceTime,
-				source: 'nes',
-			};
-
-			const isSnippetIgnored = async (item: SnippetContext): Promise<boolean> => {
-				const uris = [item.uri, ...(item.additionalUris ?? [])];
-				const isIgnored = await raceFilter(uris.map(uri => this.ignoreService.isCopilotIgnored(uri)), r => r);
-				return !!isIgnored;
-			};
-
-			const langCtxItems: LanguageContextEntry[] = [];
-			const getContextPromise = async () => {
-				const ctxIter = this.langCtxService.getContextItems(textDoc, ctxRequest, cancellationToken);
-				for await (const item of ctxIter) {
-					if (item.kind === ContextKind.Snippet && await isSnippetIgnored(item)) {
-						// If the snippet is ignored, we don't want to include it in the context
-						continue;
-					}
-					langCtxItems.push({ context: item, timeStamp: Date.now(), onTimeout: false });
-				}
-			};
-
-			const start = Date.now();
-			await raceTimeout(getContextPromise(), debounceTime);
-			const end = Date.now();
-
-			const langCtxOnTimeout = this.langCtxService.getContextItemsOnTimeout(textDoc, ctxRequest);
-			for (const item of langCtxOnTimeout) {
-				if (item.kind === ContextKind.Snippet && await isSnippetIgnored(item)) {
-					// If the snippet is ignored, we don't want to include it in the context
-					continue;
-				}
-				langCtxItems.push({ context: item, timeStamp: end, onTimeout: true });
-			}
-
-			return { start, end, items: langCtxItems };
-
-		} catch (error: unknown) {
-			logContext.setError(errors.fromUnknown(error));
-			this.tracer.trace(`Failed to fetch language context: ${error}`);
-			return undefined;
-		}
-	}
-
-	public async streamEdits(
-		request: StatelessNextEditRequest,
-		pushEdit: PushEdit,
-		endpoint: IChatEndpoint,
-		messages: Raw.ChatMessage[],
-		editWindow: OffsetRange,
-		editWindowLines: string[],
-		cursorOriginalLinesOffset: number,
-		cursorLineOffset: number, // cursor offset within the line it's in; 1-based
-		editWindowLineRange: OffsetRange,
-		prediction: Prediction | undefined,
-		opts: {
-			promptingStrategy: xtabPromptOptions.PromptingStrategy | undefined;
-			shouldRemoveCursorTagFromResponse: boolean;
-			retryState: RetryState;
-		},
-		delaySession: DelaySession,
-		parentTracer: ITracer,
-		telemetryBuilder: StatelessNextEditTelemetryBuilder,
-		logContext: InlineEditRequestLogContext,
-		cancellationToken: CancellationToken,
-	) {
-		const tracer = parentTracer.sub('streamEdits');
-
-		const fetchStreamSource = new FetchStreamSource();
-
-		const fetchRequestStopWatch = new StopWatch();
-
-		let responseSoFar = '';
-
-		let chatResponseFailure: ChatFetchError | undefined;
-
-		let ttft: number | undefined;
-
-		const firstTokenReceived = new DeferredPromise<void>();
-
-		telemetryBuilder.setFetchStartedAt();
-		logContext.setFetchStartTime();
-
-		// we must not await this promise because we want to stream edits as they come in
-		const fetchResultPromise = endpoint.makeChatRequest(
-			XtabProvider.ID,
-			messages,
-			async (text, _, delta) => {
-				if (!firstTokenReceived.isSettled) {
-					firstTokenReceived.complete();
-				}
-				if (ttft === undefined) {
-					ttft = fetchRequestStopWatch.elapsed();
-					logContext.addLog(`TTFT ${ttft} ms`);
-				}
-
-				fetchStreamSource.update(text, delta);
-				responseSoFar = text;
-				logContext.setResponse(responseSoFar);
-				return undefined;
-			},
-			cancellationToken,
-			ChatLocation.Other,
-			undefined,
-			{
-				temperature: 0,
-				// max_tokens: 256, // `max_tokens` is not supported along with `prediction` - https://platform.openai.com/docs/guides/predicted-outputs#limitations
-				stream: true,
-				prediction,
-			} satisfies OptionalChatRequestParams,
-			undefined,
-			{
-				requestId: request.id,
-			}
-		);
-
-		telemetryBuilder.setResponse(fetchResultPromise.then((response) => ({ response, ttft })));
-		logContext.setFullResponse(fetchResultPromise.then((response) => response.type === ChatFetchResponseType.Success ? response.value : undefined));
-
-		const fetchRes = await Promise.race([firstTokenReceived.p, fetchResultPromise]);
-		if (fetchRes && fetchRes.type !== ChatFetchResponseType.Success) {
-			if (fetchRes.type === ChatFetchResponseType.NotFound &&
-				!this.forceUseDefaultModel // if we haven't already forced using the default model; otherwise, this could cause an infinite loop
-			) {
-				this.forceUseDefaultModel = true;
-				return this.doGetNextEdit(request, pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, opts.retryState); // use the same retry state
-			}
-			pushEdit(Result.error(XtabProvider.mapChatFetcherErrorToNoNextEditReason(fetchRes)));
-			return;
-		}
-
-		fetchResultPromise
-			.then((response) => {
-				// this's a way to signal the edit-pushing code to know if the request failed and
-				// 	it shouldn't push edits constructed from an erroneous response
-				chatResponseFailure = response.type !== ChatFetchResponseType.Success ? response : undefined;
-			})
-			.catch((err: unknown) => {
-				// in principle this shouldn't happen because ChatMLFetcher's fetchOne should not throw
-				logContext.setError(errors.fromUnknown(err));
-				logContext.addLog(`ChatMLFetcher fetch call threw -- this's UNEXPECTED!`);
-
-				// Properly handle the error by pushing it as a result
-				pushEdit(Result.error(new NoNextEditReason.Unexpected(errors.fromUnknown(err))));
-			}).finally(() => {
-				logContext.setFetchEndTime();
-
-				if (!firstTokenReceived.isSettled) {
-					firstTokenReceived.complete();
-				}
-
-				fetchStreamSource.resolve();
-
-				logContext.setResponse(responseSoFar);
-			});
-
-		const llmLinesStream = toLines(fetchStreamSource.stream);
-
-		// logging of times
-		// removal of cursor tag if option is set
-		const linesStream = (() => {
-			let i = 0;
-			return llmLinesStream.map((v) => {
-
-				const trace = `Line ${i++} emitted with latency ${fetchRequestStopWatch.elapsed()} ms`;
-				logContext.addLog(trace);
-				tracer.trace(trace);
-
-				return opts.shouldRemoveCursorTagFromResponse
-					? v.replaceAll(CURSOR_TAG, '')
-					: v;
-			});
-		})();
-
-		let cleanedLinesStream: AsyncIterableObject<string>;
-
-		if (opts.promptingStrategy === xtabPromptOptions.PromptingStrategy.Xtab275) {
-			cleanedLinesStream = linesStream;
-		} else if (
-			opts.promptingStrategy === xtabPromptOptions.PromptingStrategy.UnifiedModel ||
-			opts.promptingStrategy === xtabPromptOptions.PromptingStrategy.Codexv21NesUnified ||
-			opts.promptingStrategy === xtabPromptOptions.PromptingStrategy.Nes41Miniv3
-		) {
-			const linesIter = linesStream[Symbol.asyncIterator]();
-			const firstLine = await linesIter.next();
-
-			if (chatResponseFailure !== undefined) { // handle fetch failure
-				pushEdit(Result.error(new NoNextEditReason.Unexpected(errors.fromUnknown(chatResponseFailure))));
-				return;
-			}
-
-			if (firstLine.done) { // no lines in response -- unexpected case but take as no suggestions
-				pushEdit(Result.error(new NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow)));
-				return;
-			}
-
-			const trimmedLines = firstLine.value.trim();
-
-			if (trimmedLines === ResponseTags.NO_CHANGE.start) {
-				this.pushNoSuggestionsOrRetry(request, editWindow, pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, opts.retryState);
-				return;
-			}
-
-			if (trimmedLines === ResponseTags.INSERT.start) {
-				const lineWithCursorContinued = await linesIter.next();
-				if (lineWithCursorContinued.done || lineWithCursorContinued.value.includes(ResponseTags.INSERT.end)) {
-					pushEdit(Result.error(new NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow)));
-					return;
-				}
-				const edit = new LineReplacement(
-					new LineRange(editWindowLineRange.start + cursorOriginalLinesOffset + 1 /* 0-based to 1-based */, editWindowLineRange.start + cursorOriginalLinesOffset + 2),
-					[editWindowLines[cursorOriginalLinesOffset].slice(0, cursorLineOffset - 1) + lineWithCursorContinued.value + editWindowLines[cursorOriginalLinesOffset].slice(cursorLineOffset - 1)]
-				);
-				pushEdit(Result.ok({ edit, window: editWindow }));
-
-				const lines: string[] = [];
-				let v = await linesIter.next();
-				while (!v.done) {
-					if (v.value.includes(ResponseTags.INSERT.end)) {
-						break;
-					} else {
-						lines.push(v.value);
-					}
-					v = await linesIter.next();
-				}
-
-				const line = editWindowLineRange.start + cursorOriginalLinesOffset + 2;
-				pushEdit(Result.ok({
-					edit: new LineReplacement(
-						new LineRange(line, line),
-						lines
-					),
-					window: editWindow
-				}));
-
-				pushEdit(Result.error(new NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow)));
-				return;
-			}
-
-			if (trimmedLines === ResponseTags.EDIT.start) {
-				cleanedLinesStream = new AsyncIterableObject(async (emitter) => {
-					let v = await linesIter.next();
-					while (!v.done) {
-						if (v.value.includes(ResponseTags.EDIT.end)) {
-							return;
-						}
-						emitter.emitOne(v.value);
-						v = await linesIter.next();
-					}
-				});
-			} else {
-				pushEdit(Result.error(new NoNextEditReason.Unexpected(new Error(`unexpected tag ${trimmedLines}`))));
-				return;
-			}
-		} else {
-			cleanedLinesStream = linesWithBackticksRemoved(linesStream);
-		}
-
-		const diffOptions: ResponseProcessor.DiffParams = {
-			emitFastCursorLineChange: this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabProviderEmitFastCursorLineChange, this.expService),
-			nLinesToConverge: this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabNNonSignificantLinesToConverge, this.expService),
-			nSignificantLinesToConverge: this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabNSignificantLinesToConverge, this.expService),
-		};
-
-		(async () => {
-			let i = 0;
-			let hasBeenDelayed = false;
-			try {
-				for await (const edit of ResponseProcessor.diff(editWindowLines, cleanedLinesStream, cursorOriginalLinesOffset, diffOptions)) {
-
-					const singleLineEdits: LineReplacement[] = [];
-					if (edit.lineRange.startLineNumber === edit.lineRange.endLineNumberExclusive || // we don't want to run diff on insertion
-						edit.newLines.length === 0 || // we don't want to run diff on deletion
-						edit.lineRange.endLineNumberExclusive - edit.lineRange.startLineNumber === 1 && edit.newLines.length === 1 // we want to run diff on single line edits
-					) {
-						const singleLineEdit = new LineReplacement(new LineRange(edit.lineRange.startLineNumber + editWindowLineRange.start, edit.lineRange.endLineNumberExclusive + editWindowLineRange.start), edit.newLines);
-						singleLineEdits.push(singleLineEdit);
-					} else {
-						const affectedOriginalLines = editWindowLines.slice(edit.lineRange.startLineNumber - 1, edit.lineRange.endLineNumberExclusive - 1).join('\n');
-
-						const diffResult = await this.diffService.computeDiff(affectedOriginalLines, edit.newLines.join('\n'), {
-							ignoreTrimWhitespace: false,
-							maxComputationTimeMs: 0,
-							computeMoves: false
-						});
-
-						const translateByNLines = editWindowLineRange.start + edit.lineRange.startLineNumber;
-						for (const change of diffResult.changes) {
-							const singleLineEdit = new LineReplacement(
-								new LineRange(
-									translateByNLines + change.original.startLineNumber - 1,
-									translateByNLines + change.original.endLineNumberExclusive - 1
-								),
-								edit.newLines.slice(change.modified.startLineNumber - 1, change.modified.endLineNumberExclusive - 1)
-							);
-							singleLineEdits.push(singleLineEdit);
-						}
-					}
-
-					if (chatResponseFailure) { // do not emit edits if chat response failed
-						break;
-					}
-
-					logContext.setResponse(responseSoFar);
-
-					for (const singleLineEdit of singleLineEdits) {
-						const lineEdit = new LineEdit([singleLineEdit]);
-
-						if (editWouldDeleteWhatWasJustInserted(request.getActiveDocument(), lineEdit)) {
-							this.trace(`filtering edit because it would undo previous insertion: ${singleLineEdit.toString()}`, logContext, tracer);
-							i++;
-							continue;
-						}
-
-						this.trace(`pushing edit #${i}:\n${singleLineEdit.toString()}`, logContext, tracer);
-
-						if (!hasBeenDelayed) { // delay only the first one
-							hasBeenDelayed = true;
-							await this.enforceArtificialDelay(delaySession, telemetryBuilder);
-						}
-
-						pushEdit(Result.ok({ edit: singleLineEdit, window: editWindow }));
-						i++;
-					}
-				}
-
-				if (chatResponseFailure) {
-					pushEdit(Result.error(XtabProvider.mapChatFetcherErrorToNoNextEditReason(chatResponseFailure)));
-					return;
-				}
-
-				const hadEdits = i > 0;
-				if (hadEdits) {
-					pushEdit(Result.error(new NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow)));
-				} else {
-					this.pushNoSuggestionsOrRetry(request, editWindow, pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, opts.retryState);
-				}
-
-			} catch (err) {
-				logContext.setError(err);
-				// Properly handle the error by pushing it as a result
-				pushEdit(Result.error(new NoNextEditReason.Unexpected(errors.fromUnknown(err))));
-			}
-		})();
-	}
-
-	private pushNoSuggestionsOrRetry(
-		request: StatelessNextEditRequest,
-		editWindow: OffsetRange,
-		pushEdit: PushEdit,
-		delaySession: DelaySession,
-		logContext: InlineEditRequestLogContext,
-		cancellationToken: CancellationToken,
-		telemetryBuilder: StatelessNextEditTelemetryBuilder,
-		retryState: RetryState,
-	) {
-		const allowRetryWithExpandedWindow = this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabProviderRetryWithNMoreLinesBelow, this.expService);
-
-		// if allowed to retry and not retrying already, flip the retry state and try again
-		if (allowRetryWithExpandedWindow && retryState === RetryState.NotRetrying && request.expandedEditWindowNLines === undefined) {
-			this.doGetNextEdit(request, pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, RetryState.RetryingWithExpandedWindow);
-			return;
-		}
-
-		pushEdit(Result.error(new NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow)));
-		return;
-	}
-
-	private computeAreaAroundEditWindowLinesRange(currentDocLines: string[], cursorLine: number): OffsetRange {
-		const areaAroundStart = Math.max(0, cursorLine - N_LINES_AS_CONTEXT);
-		const areaAroundEndExcl = Math.min(currentDocLines.length, cursorLine + N_LINES_AS_CONTEXT + 1);
-
-		return new OffsetRange(areaAroundStart, areaAroundEndExcl);
-	}
-
-	private computeEditWindowLinesRange(currentDocLines: string[], cursorLine: number, request: StatelessNextEditRequest, retryState: RetryState): OffsetRange {
-		let nLinesAbove: number;
-		{
-			const useVaryingLinesAbove = this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabProviderUseVaryingLinesAbove, this.expService);
-
-			if (useVaryingLinesAbove) {
-				nLinesAbove = 0; // default
-
-				for (let i = 0; i < 8; ++i) {
-					const lineIdx = cursorLine - i;
-					if (lineIdx < 0) {
-						break;
-					}
-					if (currentDocLines[lineIdx].trim() !== '') {
-						nLinesAbove = i;
-						break;
-					}
-				}
-			} else {
-				nLinesAbove = (this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabProviderNLinesAbove, this.expService)
-					?? N_LINES_ABOVE);
-			}
-		}
-
-		let nLinesBelow;
-
-		if (request.expandedEditWindowNLines !== undefined) {
-			this.tracer.trace(`Using expanded nLinesBelow: ${request.expandedEditWindowNLines}`);
-			nLinesBelow = request.expandedEditWindowNLines;
-		} else {
-			const overriddenNLinesBelow = this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabProviderNLinesBelow, this.expService);
-			if (overriddenNLinesBelow !== undefined) {
-				this.tracer.trace(`Using overridden nLinesBelow: ${overriddenNLinesBelow}`);
-				nLinesBelow = overriddenNLinesBelow;
-			} else {
-				this.tracer.trace(`Using default nLinesBelow: ${N_LINES_BELOW}`);
-				nLinesBelow = N_LINES_BELOW; // default
-			}
-		}
-
-		if (retryState === RetryState.RetryingWithExpandedWindow) {
-			nLinesBelow += this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabProviderRetryWithNMoreLinesBelow, this.expService) ?? 0;
-		}
-
-		const codeToEditStart = Math.max(0, cursorLine - nLinesAbove);
-		const codeToEditEndExcl = Math.min(currentDocLines.length, cursorLine + nLinesBelow + 1);
-
-		return new OffsetRange(codeToEditStart, codeToEditEndExcl);
-	}
-
-
-	public static getBacktickSection(text: string): string {
-		const textTrimmedStart = text.replace(/^\`\`\`[a-zA-Z]*\r?\n/, '');
-		const textTrimmedEnd = textTrimmedStart.replace(/(\r?\n)\`\`\`$/, '');
-		return textTrimmedEnd;
-	}
-
-	private static mapChatFetcherErrorToNoNextEditReason(fetchError: ChatFetchError): NoNextEditReason {
-		switch (fetchError.type) {
-			case ChatFetchResponseType.Canceled:
-				return new NoNextEditReason.GotCancelled('afterFetchCall');
-			case ChatFetchResponseType.OffTopic:
-			case ChatFetchResponseType.Filtered:
-			case ChatFetchResponseType.PromptFiltered:
-			case ChatFetchResponseType.Length:
-			case ChatFetchResponseType.RateLimited:
-			case ChatFetchResponseType.QuotaExceeded:
-			case ChatFetchResponseType.ExtensionBlocked:
-			case ChatFetchResponseType.AgentUnauthorized:
-			case ChatFetchResponseType.AgentFailedDependency:
-			case ChatFetchResponseType.InvalidStatefulMarker:
-				return new NoNextEditReason.Uncategorized(errors.fromUnknown(fetchError));
-			case ChatFetchResponseType.BadRequest:
-			case ChatFetchResponseType.NotFound:
-			case ChatFetchResponseType.Failed:
-			case ChatFetchResponseType.NetworkError:
-			case ChatFetchResponseType.Unknown:
-				return new NoNextEditReason.FetchFailure(errors.fromUnknown(fetchError));
-		}
-	}
-
-	private determinePromptingStrategy({ isXtabUnifiedModel, isCodexV21NesUnified, useSimplifiedPrompt, useXtab275Prompting, useNes41Miniv3Prompting }: { isXtabUnifiedModel: boolean; isCodexV21NesUnified: boolean; useSimplifiedPrompt: boolean; useXtab275Prompting: boolean; useNes41Miniv3Prompting: boolean }): xtabPromptOptions.PromptingStrategy | undefined {
-		if (isXtabUnifiedModel) {
-			return xtabPromptOptions.PromptingStrategy.UnifiedModel;
-		} else if (isCodexV21NesUnified) {
-			return xtabPromptOptions.PromptingStrategy.Codexv21NesUnified;
-		} else if (useSimplifiedPrompt) {
-			return xtabPromptOptions.PromptingStrategy.SimplifiedSystemPrompt;
-		} else if (useXtab275Prompting) {
-			return xtabPromptOptions.PromptingStrategy.Xtab275;
-		} else if (useNes41Miniv3Prompting) {
-			return xtabPromptOptions.PromptingStrategy.Nes41Miniv3;
-		} else {
-			return undefined;
-		}
-	}
-
-	private pickSystemPrompt(promptingStrategy: xtabPromptOptions.PromptingStrategy | undefined): string {
-		switch (promptingStrategy) {
-			case xtabPromptOptions.PromptingStrategy.UnifiedModel:
-				return unifiedModelSystemPrompt;
-			case xtabPromptOptions.PromptingStrategy.Codexv21NesUnified:
-			case xtabPromptOptions.PromptingStrategy.SimplifiedSystemPrompt:
-				return simplifiedPrompt;
-			case xtabPromptOptions.PromptingStrategy.Xtab275:
-				return xtab275SystemPrompt;
-			case xtabPromptOptions.PromptingStrategy.Nes41Miniv3:
-				return nes41Miniv3SystemPrompt;
-			default:
-				return systemPromptTemplate;
-		}
-	}
-
-	private determineLanguageContextOptions(languageId: LanguageId, { enabled, enabledLanguages, maxTokens }: { enabled: boolean; enabledLanguages: LanguageContextLanguages; maxTokens: number }): LanguageContextOptions {
-		// Some languages are
-		if (languageId in enabledLanguages) {
-			return { enabled: enabledLanguages[languageId], maxTokens };
-		}
-
-		return { enabled, maxTokens };
-	}
-
-	private getEndpoint() {
-		const url = this.configService.getConfig(ConfigKey.Internal.InlineEditsXtabProviderUrl);
-		const apiKey = this.configService.getConfig(ConfigKey.Internal.InlineEditsXtabProviderApiKey);
-		const hasOverriddenUrlAndApiKey = url !== undefined && apiKey !== undefined;
-
-		const configuredModelName = this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabProviderModelName, this.expService);
-
-		if (hasOverriddenUrlAndApiKey) {
-			return this.instaService.createInstance(XtabEndpoint, url, apiKey, configuredModelName);
-		}
-
-		const modelName = this.forceUseDefaultModel
-			? undefined
-			: this.configService.getExperimentBasedConfig(ConfigKey.Internal.InlineEditsXtabProviderModelName, this.expService);
-
-		return createProxyXtabEndpoint(this.instaService, modelName);
-	}
-
-	private getPredictedOutput(editWindowLines: string[], promptingStrategy: xtabPromptOptions.PromptingStrategy | undefined): Prediction | undefined {
-		return this.configService.getConfig(ConfigKey.Internal.InlineEditsXtabProviderUsePrediction)
-			? {
-				type: 'content',
-				content: XtabProvider.getPredictionContents(editWindowLines, promptingStrategy)
-			}
-			: undefined;
-	}
-
-	private static getPredictionContents(editWindowLines: readonly string[], promptingStrategy: xtabPromptOptions.PromptingStrategy | undefined): string {
-		if (promptingStrategy === xtabPromptOptions.PromptingStrategy.UnifiedModel ||
-			promptingStrategy === xtabPromptOptions.PromptingStrategy.Codexv21NesUnified ||
-			promptingStrategy === xtabPromptOptions.PromptingStrategy.Nes41Miniv3
-		) {
-			return ['<EDIT>', ...editWindowLines, '</EDIT>'].join('\n');
-		} else if (promptingStrategy === xtabPromptOptions.PromptingStrategy.Xtab275) {
-			return editWindowLines.join('\n');
-		} else {
-			return ['```', ...editWindowLines, '```'].join('\n');
-		}
-	}
-
-	private async debounce(delaySession: DelaySession, telemetry: StatelessNextEditTelemetryBuilder) {
-		if (this.simulationCtx.isInSimulationTests) {
-			return;
-		}
-		const debounceTime = delaySession.getDebounceTime();
-
-		this.tracer.trace(`Debouncing for ${debounceTime} ms`);
-		telemetry.setDebounceTime(debounceTime);
-
-		await timeout(debounceTime);
-	}
-
-	private async enforceArtificialDelay(delaySession: DelaySession, telemetry: StatelessNextEditTelemetryBuilder) {
-		if (this.simulationCtx.isInSimulationTests) {
-			return;
-		}
-		const artificialDelay = delaySession.getArtificialDelay();
-
-		this.tracer.trace(`Enforcing artificial delay of ${artificialDelay} ms`);
-		telemetry.setArtificialDelay(artificialDelay);
-
-		if (artificialDelay > 0) {
-			await timeout(artificialDelay);
-		}
-	}
-
-	private trace(msg: string, logContext: InlineEditRequestLogContext, tracer: ITracer) {
-		tracer.trace(msg);
-		logContext.addLog(msg);
-	}
-}