@vscode/chat-lib 0.3.0 → 0.3.1-0

package/dist/src/_internal/extension/xtab/node/xtabProvider.js

@@ -93,6 +93,19 @@ const xtabCustomDiffPatchResponseHandler_1 = require("./xtabCustomDiffPatchRespo
 const xtabEndpoint_1 = require("./xtabEndpoint");
 const xtabNextCursorPredictor_1 = require("./xtabNextCursorPredictor");
 const xtabUtils_1 = require("./xtabUtils");
+var RetryState;
+(function (RetryState) {
+    class NotRetrying {
+        static { this.INSTANCE = new NotRetrying(); }
+    }
+    RetryState.NotRetrying = NotRetrying;
+    class Retrying {
+        constructor(reason) {
+            this.reason = reason;
+        }
+    }
+    RetryState.Retrying = Retrying;
+})(RetryState || (RetryState = {}));
 let XtabProvider = class XtabProvider {
     static { XtabProvider_1 = this; }
     static { this.ID = configurationService_1.XTabProviderId; }
@@ -109,7 +122,6 @@ let XtabProvider = class XtabProvider {
         this.langDiagService = langDiagService;
         this.ignoreService = ignoreService;
         this.ID = XtabProvider_1.ID;
-        this.dependsOnSelection = true;
         this.showNextEditPreference = "always" /* ShowNextEditPreference.Always */;
         this.forceUseDefaultModel = false;
         this.userInteractionMonitor = new userInteractionMonitor_1.UserInteractionMonitor(this.configService, this.expService);
@@ -121,47 +133,7 @@ let XtabProvider = class XtabProvider {
     handleRejection() {
         this.userInteractionMonitor.handleRejection();
     }
-    provideNextEdit(request, pushEdit, tracer, logContext, cancellationToken) {
-        const filteringPushEdit = (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, tracer, logContext, cancellationToken);
-    }
-    filterEdit(activeDoc, edits) {
-        const filters = [
-            (edits) => importFiltering_1.IgnoreImportChangesAspect.filterEdit(activeDoc, edits),
-            (edits) => statelessNextEditProviders_1.IgnoreEmptyLineAndLeadingTrailingWhitespaceChanges.filterEdit(activeDoc, edits),
-        ];
-        if (!this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.InlineEditsAllowWhitespaceOnlyChanges, this.expService)) {
-            filters.push((edits) => statelessNextEditProviders_1.IgnoreWhitespaceOnlyChanges.filterEdit(activeDoc, edits));
-        }
-        const undoInsertionFiltering = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsUndoInsertionFiltering, this.expService);
-        if (undoInsertionFiltering !== undefined) {
-            let filter;
-            switch (undoInsertionFiltering) {
-                case 'v1':
-                    filter = statelessNextEditProviders_1.editWouldDeleteWhatWasJustInserted;
-                    break;
-                case 'v2':
-                    filter = statelessNextEditProviders_1.editWouldDeleteWhatWasJustInserted2;
-                    break;
-                default:
-                    (0, assert_1.assertNever)(undoInsertionFiltering);
-            }
-            filters.push((edits) => filter(activeDoc, new lineEdit_1.LineEdit(edits)) ? [] : edits);
-        }
-        return filters.reduce((acc, filter) => filter(acc), edits);
-    }
-    async _provideNextEdit(request, pushEdit, tracer, logContext, cancellationToken) {
+    async provideNextEdit(request, pushEdit, tracer, logContext, cancellationToken) {
         const telemetry = new statelessNextEditProvider_1.StatelessNextEditTelemetryBuilder(request);
         logContext.setProviderStartTime();
         try {
@@ -169,7 +141,31 @@ let XtabProvider = class XtabProvider {
                 return statelessNextEditProvider_1.StatelessNextEditResult.noEdit(new statelessNextEditProvider_1.NoNextEditReason.ActiveDocumentHasNoEdits(), telemetry);
             }
             const delaySession = this.userInteractionMonitor.createDelaySession(request.providerRequestStartDateTime);
-            const nextEditResult = await this.doGetNextEdit(request, pushEdit, delaySession, tracer, logContext, cancellationToken, telemetry, 0 /* RetryState.NotRetrying */);
+            const iterator = this.doGetNextEdit(request, delaySession, tracer, logContext, cancellationToken, telemetry, RetryState.NotRetrying.INSTANCE);
+            let res = await iterator.next(); // for-async-await loop doesn't work because we need to access the final return value
+            let nextEditResult;
+            if (res.done) {
+                // stream already ended, so we can just return the final reason
+                nextEditResult = result_1.Result.error(res.value);
+                pushEdit(nextEditResult);
+            }
+            else {
+                // stream is not done yet, so we push the first edit and then continue streaming in the background
+                nextEditResult = result_1.Result.ok(undefined);
+                (async () => {
+                    let nEdits = 0;
+                    while (!res.done) {
+                        nEdits++;
+                        pushEdit(result_1.Result.ok(res.value));
+                        res = await iterator.next();
+                    }
+                    pushEdit(result_1.Result.error(res.value));
+                })().catch((err) => {
+                    const error = errors.fromUnknown(err);
+                    logContext.addLog(`Error while streaming further edits: ${errors.fromUnknown(err)}`);
+                    pushEdit(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.Unexpected(error)));
+                });
+            }
             if (nextEditResult.isError() && nextEditResult.err instanceof statelessNextEditProvider_1.NoNextEditReason.GotCancelled) {
                 logContext.setIsSkipped();
             }
@@ -182,14 +178,14 @@ let XtabProvider = class XtabProvider {
             logContext.setProviderEndTime();
         }
     }
-    async doGetNextEdit(request, pushEdit, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, retryState) {
-        return this.doGetNextEditWithSelection(request, (0, nearbyCursorInlineEditProvider_1.getOrDeduceSelectionFromLastEdit)(request.getActiveDocument()), pushEdit, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, retryState);
+    doGetNextEdit(request, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, retryState) {
+        return this.doGetNextEditWithSelection(request, (0, nearbyCursorInlineEditProvider_1.getOrDeduceSelectionFromLastEdit)(request.getActiveDocument()), delaySession, tracer, logContext, cancellationToken, telemetryBuilder, retryState);
     }
-    async doGetNextEditWithSelection(request, selection, pushEdit, delaySession, parentTracer, logContext, cancellationToken, telemetryBuilder, retryState) {
+    async *doGetNextEditWithSelection(request, selection, delaySession, parentTracer, logContext, cancellationToken, telemetryBuilder, retryState) {
         const tracer = parentTracer.sub(['XtabProvider', 'doGetNextEditWithSelection']);
         const activeDocument = request.getActiveDocument();
         if (selection === null) {
-            return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.Uncategorized(new Error('NoSelection')));
+            return new statelessNextEditProvider_1.NoNextEditReason.Uncategorized(new Error('NoSelection'));
         }
         const promptOptions = this.determineModelConfiguration(activeDocument);
         const endpoint = this.getEndpoint(promptOptions.modelName);
@@ -209,14 +205,14 @@ let XtabProvider = class XtabProvider {
         }
         telemetryBuilder.setIsCursorAtLineEnd(isCursorAtEndOfLine);
         const areaAroundEditWindowLinesRange = this.computeAreaAroundEditWindowLinesRange(currentDocument);
-        const editWindowLinesRange = this.computeEditWindowLinesRange(currentDocument, request, retryState, tracer, telemetryBuilder);
+        const editWindowLinesRange = this.computeEditWindowLinesRange(currentDocument, request, tracer, telemetryBuilder);
         const cursorOriginalLinesOffset = Math.max(0, currentDocument.cursorLineOffset - editWindowLinesRange.start);
         const editWindowLastLineLength = currentDocument.transformer.getLineLength(editWindowLinesRange.endExclusive);
         const editWindow = currentDocument.transformer.getOffsetRange(new range_1.Range(editWindowLinesRange.start + 1, 1, editWindowLinesRange.endExclusive, editWindowLastLineLength + 1));
         const editWindowLines = currentDocument.lines.slice(editWindowLinesRange.start, editWindowLinesRange.endExclusive);
         const editWindowTokenLimit = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabEditWindowMaxTokens, this.expService);
         if (editWindowTokenLimit !== undefined && (0, promptCrafting_1.countTokensForLines)(editWindowLines, XtabProvider_1.computeTokens) > editWindowTokenLimit) {
-            return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.PromptTooLarge('editWindow'));
+            return new statelessNextEditProvider_1.NoNextEditReason.PromptTooLarge('editWindow');
         }
         // Expected: editWindow.substring(activeDocument.documentAfterEdits.value) === editWindowLines.join('\n')
         const doesIncludeCursorTag = editWindowLines.some(line => line.includes(tags_1.PromptTags.CURSOR));
@@ -228,14 +224,21 @@ let XtabProvider = class XtabProvider {
             }
         });
         if (taggedCurrentFileContentResult.isError()) {
-            return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.PromptTooLarge('currentFile'));
+            return new statelessNextEditProvider_1.NoNextEditReason.PromptTooLarge('currentFile');
         }
         const { clippedTaggedCurrentDoc, areaAroundCodeToEdit } = taggedCurrentFileContentResult.val;
         telemetryBuilder.setNLinesOfCurrentFileInPrompt(clippedTaggedCurrentDoc.lines.length);
-        const aggressivenessLevel = this.userInteractionMonitor.getAggressivenessLevel();
+        const { aggressivenessLevel, userHappinessScore } = this.userInteractionMonitor.getAggressivenessLevel();
+        // Log aggressiveness level and user happiness score when using XtabAggressiveness prompting strategy
+        if (promptOptions.promptingStrategy === xtabPromptOptions_1.PromptingStrategy.XtabAggressiveness) {
+            telemetryBuilder.setXtabAggressivenessLevel(aggressivenessLevel);
+            if (userHappinessScore !== undefined) {
+                telemetryBuilder.setXtabUserHappinessScore(userHappinessScore);
+            }
+        }
         const langCtx = await this.getAndProcessLanguageContext(request, delaySession, activeDocument, cursorPosition, promptOptions, tracer, logContext, cancellationToken);
         if (cancellationToken.isCancellationRequested) {
-            return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.GotCancelled('afterLanguageContextAwait'));
+            return new statelessNextEditProvider_1.NoNextEditReason.GotCancelled('afterLanguageContextAwait');
         }
         const lintErrors = promptOptions.lintOptions ? new lintErrors_1.LintErrors(promptOptions.lintOptions, activeDocument.id, currentDocument, this.langDiagService) : undefined;
         const promptPieces = new promptCrafting_1.PromptPieces(currentDocument, editWindowLinesRange, areaAroundEditWindowLinesRange, activeDocument, request.xtabEditHistory, clippedTaggedCurrentDoc.lines, areaAroundCodeToEdit, langCtx, aggressivenessLevel, lintErrors, XtabProvider_1.computeTokens, promptOptions);
@@ -251,20 +254,19 @@ let XtabProvider = class XtabProvider {
         const HARD_CHAR_LIMIT = 30000 * 4; // 30K tokens, assuming 4 chars per token -- we use approximation here because counting tokens exactly is time-consuming
         const promptCharCount = (0, xtabUtils_1.charCount)(messages);
         if (promptCharCount > HARD_CHAR_LIMIT) {
-            return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.PromptTooLarge('final'));
+            return new statelessNextEditProvider_1.NoNextEditReason.PromptTooLarge('final');
         }
         await this.debounce(delaySession, retryState, tracer, telemetryBuilder);
         if (cancellationToken.isCancellationRequested) {
-            return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.GotCancelled('afterDebounce'));
+            return new statelessNextEditProvider_1.NoNextEditReason.GotCancelled('afterDebounce');
         }
         request.fetchIssued = true;
         const cursorLineOffset = cursorPosition.column;
-        this.streamEdits(request, pushEdit, endpoint, messages, editWindow, editWindowLines, cursorOriginalLinesOffset, cursorLineOffset, editWindowLinesRange, promptPieces, prediction, {
+        return yield* this.streamEditsWithFiltering(request, endpoint, messages, editWindow, editWindowLines, cursorOriginalLinesOffset, cursorLineOffset, editWindowLinesRange, promptPieces, prediction, {
             shouldRemoveCursorTagFromResponse,
             responseFormat,
             retryState,
         }, delaySession, tracer, telemetryBuilder, logContext, cancellationToken);
-        return result_1.Result.ok(undefined);
     }
     getAndProcessLanguageContext(request, delaySession, activeDocument, cursorPosition, promptOptions, tracer, logContext, cancellationToken) {
         const recordingEnabled = this.configService.getConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsLogContextRecorderEnabled);
@@ -347,7 +349,34 @@ let XtabProvider = class XtabProvider {
             return undefined;
         }
     }
-    async streamEdits(request, pushEdit, endpoint, messages, editWindow, editWindowLines, cursorOriginalLinesOffset, cursorLineOffset, // cursor offset within the line it's in; 1-based
+    async *streamEditsWithFiltering(request, endpoint, messages, editWindow, editWindowLines, cursorOriginalLinesOffset, cursorLineOffset, // cursor offset within the line it's in; 1-based
+    editWindowLineRange, promptPieces, prediction, opts, delaySession, parentTracer, telemetryBuilder, logContext, cancellationToken) {
+        const tracer = parentTracer.sub('streamEditsWithFiltering');
+        const iterator = this.streamEdits(request, endpoint, messages, editWindow, editWindowLines, cursorOriginalLinesOffset, cursorLineOffset, editWindowLineRange, promptPieces, prediction, opts, delaySession, tracer, telemetryBuilder, logContext, cancellationToken);
+        let nEdits = 0;
+        let r = await iterator.next();
+        while (!r.done) {
+            const edit = r.value.edit;
+            const filteredEdits = this.filterEdit(request.getActiveDocument(), [edit]);
+            const isFilteredOut = filteredEdits.length === 0;
+            if (isFilteredOut) {
+                tracer.trace(`Filtered out an edit: ${edit.toString()}`);
+            }
+            else {
+                tracer.trace(`Yielding an edit: ${edit.toString()}`);
+                yield r.value;
+                nEdits++;
+            }
+            r = await iterator.next();
+        }
+        if (nEdits === 0 &&
+            r.value instanceof statelessNextEditProvider_1.NoNextEditReason.NoSuggestions // only retry if there was no error, cancellation, etc.
+        ) {
+            return yield* this.doGetNextEditsWithCursorJump(request, editWindow, promptPieces, delaySession, parentTracer, logContext, cancellationToken, telemetryBuilder, opts.retryState);
+        }
+        return r.value;
+    }
+    async *streamEdits(request, endpoint, messages, editWindow, editWindowLines, cursorOriginalLinesOffset, cursorLineOffset, // cursor offset within the line it's in; 1-based
     editWindowLineRange, promptPieces, prediction, opts, delaySession, parentTracer, telemetryBuilder, logContext, cancellationToken) {
         const tracer = parentTracer.sub('streamEdits');
         const useFetcher = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.NextEditSuggestionsFetcher, this.expService) || undefined;
@@ -397,10 +426,9 @@ let XtabProvider = class XtabProvider {
                 !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, tracer, logContext, cancellationToken, telemetryBuilder, opts.retryState); // use the same retry state
+                return yield* this.doGetNextEdit(request, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, opts.retryState); // use the same retry state
             }
-            pushEdit(result_1.Result.error(XtabProvider_1.mapChatFetcherErrorToNoNextEditReason(fetchRes)));
-            return;
+            return XtabProvider_1.mapChatFetcherErrorToNoNextEditReason(fetchRes);
         }
         fetchResultPromise
             .then((response) => {
@@ -412,8 +440,6 @@ let XtabProvider = class XtabProvider {
             // 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_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.Unexpected(errors.fromUnknown(err))));
         }).finally(() => {
             logContext.setFetchEndTime();
             if (!firstTokenReceived.isSettled) {
@@ -435,37 +461,34 @@ let XtabProvider = class XtabProvider {
                     : v;
             });
         })();
+        const isFromCursorJump = opts.retryState instanceof RetryState.Retrying && opts.retryState.reason === 'cursorJump';
         let cleanedLinesStream;
         if (opts.responseFormat === xtabPromptOptions.ResponseFormat.EditWindowOnly) {
             cleanedLinesStream = linesStream;
         }
         else if (opts.responseFormat === xtabPromptOptions.ResponseFormat.CustomDiffPatch) {
-            return xtabCustomDiffPatchResponseHandler_1.XtabCustomDiffPatchResponseHandler.handleResponse(pushEdit, linesStream, request.documentBeforeEdits, editWindow);
+            return yield* xtabCustomDiffPatchResponseHandler_1.XtabCustomDiffPatchResponseHandler.handleResponse(linesStream, request.documentBeforeEdits, editWindow);
         }
         else if (opts.responseFormat === xtabPromptOptions.ResponseFormat.UnifiedWithXml) {
             const linesIter = linesStream[Symbol.asyncIterator]();
             const firstLine = await linesIter.next();
             if (chatResponseFailure !== undefined) { // handle fetch failure
-                pushEdit(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.Unexpected(errors.fromUnknown(chatResponseFailure))));
-                return;
+                return new statelessNextEditProvider_1.NoNextEditReason.Unexpected(errors.fromUnknown(chatResponseFailure));
             }
             if (firstLine.done) { // no lines in response -- unexpected case but take as no suggestions
-                pushEdit(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow)));
-                return;
+                return new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow);
             }
             const trimmedLines = firstLine.value.trim();
             if (trimmedLines === tags_1.ResponseTags.NO_CHANGE.start) {
-                await this.pushNoSuggestionsOrRetry(request, editWindow, promptPieces, pushEdit, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, opts.retryState);
-                return;
+                return yield* this.doGetNextEditsWithCursorJump(request, editWindow, promptPieces, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, opts.retryState);
             }
             if (trimmedLines === tags_1.ResponseTags.INSERT.start) {
                 const lineWithCursorContinued = await linesIter.next();
                 if (lineWithCursorContinued.done || lineWithCursorContinued.value.includes(tags_1.ResponseTags.INSERT.end)) {
-                    pushEdit(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow)));
-                    return;
+                    return new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow);
                 }
                 const edit = new lineEdit_1.LineReplacement(new lineRange_1.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_1.Result.ok({ edit, window: editWindow }));
+                yield { edit, isFromCursorJump, window: editWindow };
                 const lines = [];
                 let v = await linesIter.next();
                 while (!v.done) {
@@ -478,12 +501,12 @@ let XtabProvider = class XtabProvider {
                     v = await linesIter.next();
                 }
                 const line = editWindowLineRange.start + cursorOriginalLinesOffset + 2;
-                pushEdit(result_1.Result.ok({
+                yield {
                     edit: new lineEdit_1.LineReplacement(new lineRange_1.LineRange(line, line), lines),
+                    isFromCursorJump,
                     window: editWindow
-                }));
-                pushEdit(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow)));
-                return;
+                };
+                return new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow);
             }
             if (trimmedLines === tags_1.ResponseTags.EDIT.start) {
                 cleanedLinesStream = new async_2.AsyncIterableObject(async (emitter) => {
@@ -498,8 +521,7 @@ let XtabProvider = class XtabProvider {
                 });
             }
             else {
-                pushEdit(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.Unexpected(new Error(`unexpected tag ${trimmedLines}`))));
-                return;
+                return new statelessNextEditProvider_1.NoNextEditReason.Unexpected(new Error(`unexpected tag ${trimmedLines}`));
             }
         }
         else if (opts.responseFormat === xtabPromptOptions.ResponseFormat.CodeBlock) {
@@ -514,129 +536,110 @@ let XtabProvider = class XtabProvider {
             nSignificantLinesToConverge: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabNSignificantLinesToConverge, this.expService),
         };
         tracer.trace(`starting to diff stream against edit window lines with latency ${fetchRequestStopWatch.elapsed()} ms`);
-        (async () => {
-            let i = 0;
-            let hasBeenDelayed = false;
-            try {
-                for await (const edit of responseProcessor_1.ResponseProcessor.diff(editWindowLines, cleanedLinesStream, cursorOriginalLinesOffset, diffOptions)) {
-                    tracer.trace(`ResponseProcessor streamed edit #${i} with latency ${fetchRequestStopWatch.elapsed()} ms`);
-                    const singleLineEdits = [];
-                    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 lineEdit_1.LineReplacement(new lineRange_1.LineRange(edit.lineRange.startLineNumber + editWindowLineRange.start, edit.lineRange.endLineNumberExclusive + editWindowLineRange.start), edit.newLines);
+        let i = 0;
+        let hasBeenDelayed = false;
+        try {
+            for await (const edit of responseProcessor_1.ResponseProcessor.diff(editWindowLines, cleanedLinesStream, cursorOriginalLinesOffset, diffOptions)) {
+                tracer.trace(`ResponseProcessor streamed edit #${i} with latency ${fetchRequestStopWatch.elapsed()} ms`);
+                const singleLineEdits = [];
+                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 lineEdit_1.LineReplacement(new lineRange_1.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
+                    });
+                    tracer.trace(`Ran diff for #${i} with latency ${fetchRequestStopWatch.elapsed()} ms`);
+                    const translateByNLines = editWindowLineRange.start + edit.lineRange.startLineNumber;
+                    for (const change of diffResult.changes) {
+                        const singleLineEdit = new lineEdit_1.LineReplacement(new lineRange_1.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);
                     }
-                    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
-                        });
-                        tracer.trace(`Ran diff for #${i} with latency ${fetchRequestStopWatch.elapsed()} ms`);
-                        const translateByNLines = editWindowLineRange.start + edit.lineRange.startLineNumber;
-                        for (const change of diffResult.changes) {
-                            const singleLineEdit = new lineEdit_1.LineReplacement(new lineRange_1.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) {
-                        tracer.trace(`pushing edit #${i}:\n${singleLineEdit.toString()}`);
-                        if (!hasBeenDelayed) { // delay only the first one
-                            hasBeenDelayed = true;
-                            const artificialDelay = this.determineArtificialDelayMs(delaySession, tracer, telemetryBuilder);
-                            if (artificialDelay) {
-                                await (0, async_2.timeout)(artificialDelay);
-                                tracer.trace(`Artificial delay of ${artificialDelay} ms completed`);
-                                if (cancellationToken.isCancellationRequested) {
-                                    pushEdit(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.GotCancelled('afterArtificialDelay')));
-                                    return;
-                                }
+                }
+                if (chatResponseFailure) { // do not emit edits if chat response failed
+                    break;
+                }
+                logContext.setResponse(responseSoFar);
+                for (const singleLineEdit of singleLineEdits) {
+                    tracer.trace(`extracting edit #${i}: ${singleLineEdit.toString()}`);
+                    if (!hasBeenDelayed) { // delay only the first one
+                        hasBeenDelayed = true;
+                        const artificialDelay = this.determineArtificialDelayMs(delaySession, tracer, telemetryBuilder);
+                        if (artificialDelay) {
+                            await (0, async_2.timeout)(artificialDelay);
+                            tracer.trace(`Artificial delay of ${artificialDelay} ms completed`);
+                            if (cancellationToken.isCancellationRequested) {
+                                return new statelessNextEditProvider_1.NoNextEditReason.GotCancelled('afterArtificialDelay');
                             }
                         }
-                        pushEdit(result_1.Result.ok({ edit: singleLineEdit, window: editWindow }));
-                        i++;
                     }
-                }
-                if (chatResponseFailure) {
-                    pushEdit(result_1.Result.error(XtabProvider_1.mapChatFetcherErrorToNoNextEditReason(chatResponseFailure)));
-                    return;
-                }
-                const hadEdits = i > 0;
-                if (hadEdits) {
-                    pushEdit(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow)));
-                }
-                else {
-                    await this.pushNoSuggestionsOrRetry(request, editWindow, promptPieces, pushEdit, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, opts.retryState);
+                    yield { edit: singleLineEdit, isFromCursorJump, window: editWindow };
+                    i++;
                 }
             }
-            catch (err) {
-                logContext.setError(err);
-                // Properly handle the error by pushing it as a result
-                pushEdit(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.Unexpected(errors.fromUnknown(err))));
+            if (chatResponseFailure) {
+                return XtabProvider_1.mapChatFetcherErrorToNoNextEditReason(chatResponseFailure);
             }
-        })();
-    }
-    async pushNoSuggestionsOrRetry(request, editWindow, promptPieces, pushEdit, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, retryState) {
-        const allowRetryWithExpandedWindow = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderRetryWithNMoreLinesBelow, this.expService);
-        // if allowed to retry and not retrying already, flip the retry state and try again
-        if (allowRetryWithExpandedWindow && retryState === 0 /* RetryState.NotRetrying */ && request.expandedEditWindowNLines === undefined) {
-            this.doGetNextEdit(request, pushEdit, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, 1 /* RetryState.Retrying */);
-            return;
+            return new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow);
+        }
+        catch (err) {
+            logContext.setError(err);
+            // Properly handle the error by pushing it as a result
+            return new statelessNextEditProvider_1.NoNextEditReason.Unexpected(errors.fromUnknown(err));
         }
+    }
+    async *doGetNextEditsWithCursorJump(request, editWindow, promptPieces, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, retryState) {
+        const noSuggestions = new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow);
         const nextCursorLinePrediction = this.nextCursorPredictor.determineEnablement();
-        if (nextCursorLinePrediction !== undefined && retryState === 0 /* RetryState.NotRetrying */) {
-            const nextCursorLineR = await this.nextCursorPredictor.predictNextCursorPosition(promptPieces, tracer);
-            if (cancellationToken.isCancellationRequested) {
-                pushEdit(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow)));
-                return;
+        if (nextCursorLinePrediction === undefined || retryState instanceof RetryState.Retrying) {
+            return noSuggestions;
+        }
+        const nextCursorLineR = await this.nextCursorPredictor.predictNextCursorPosition(promptPieces, tracer, telemetryBuilder, cancellationToken);
+        if (cancellationToken.isCancellationRequested) {
+            return new statelessNextEditProvider_1.NoNextEditReason.GotCancelled('afterNextCursorPredictionFetch');
+        }
+        if (nextCursorLineR.isError()) {
+            tracer.trace(`Predicted next cursor line error: ${nextCursorLineR.err.message}`);
+            telemetryBuilder.setNextCursorLineError(nextCursorLineR.err.message);
+            return noSuggestions;
+        }
+        const nextCursorLineZeroBased = nextCursorLineR.val;
+        const lineDistanceFromCursorLine = nextCursorLineZeroBased - promptPieces.currentDocument.cursorLineOffset;
+        telemetryBuilder.setNextCursorLineDistance(lineDistanceFromCursorLine);
+        tracer.trace(`Predicted next cursor line: ${nextCursorLineZeroBased}`);
+        if (nextCursorLineZeroBased >= promptPieces.currentDocument.lines.length) { // >= because the line index is zero-based
+            tracer.trace(`Predicted next cursor line error: exceedsDocumentLines`);
+            telemetryBuilder.setNextCursorLineError('exceedsDocumentLines');
+            return noSuggestions;
+        }
+        if (promptPieces.editWindowLinesRange.contains(nextCursorLineZeroBased)) {
+            tracer.trace(`Predicted next cursor line error: withinEditWindow`);
+            telemetryBuilder.setNextCursorLineError('withinEditWindow');
+            return noSuggestions;
+        }
+        const nextCursorLineOneBased = nextCursorLineZeroBased + 1;
+        const nextCursorLine = promptPieces.activeDoc.documentAfterEditsLines.at(nextCursorLineZeroBased);
+        const nextCursorColumn = (nextCursorLine?.length ?? 0) + 1;
+        switch (nextCursorLinePrediction) {
+            case nextCursorLinePrediction_1.NextCursorLinePrediction.Jump: {
+                const nextCursorPosition = new position_1.Position(nextCursorLineOneBased, nextCursorColumn);
+                return new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow, nextCursorPosition);
             }
-            if (nextCursorLineR.isError()) {
-                tracer.trace(`Predicted next cursor line error: ${nextCursorLineR.err.message}`);
-                telemetryBuilder.setNextCursorLineError(nextCursorLineR.err.message);
+            case nextCursorLinePrediction_1.NextCursorLinePrediction.OnlyWithEdit: {
+                const v = this.doGetNextEditWithSelection(request, new range_1.Range(nextCursorLineOneBased, nextCursorColumn, nextCursorLineOneBased, nextCursorColumn), delaySession, tracer, logContext, cancellationToken, telemetryBuilder, new RetryState.Retrying('cursorJump'));
+                return yield* v;
             }
-            else {
-                const nextCursorLineZeroBased = nextCursorLineR.val;
-                const lineDistanceFromCursorLine = nextCursorLineZeroBased - promptPieces.currentDocument.cursorLineOffset;
-                telemetryBuilder.setNextCursorLineDistance(lineDistanceFromCursorLine);
-                tracer.trace(`Predicted next cursor line: ${nextCursorLineZeroBased}`);
-                if (nextCursorLineZeroBased >= promptPieces.currentDocument.lines.length) { // >= because the line index is zero-based
-                    tracer.trace(`Predicted next cursor line error: exceedsDocumentLines`);
-                    telemetryBuilder.setNextCursorLineError('exceedsDocumentLines');
-                }
-                else if (promptPieces.editWindowLinesRange.contains(nextCursorLineZeroBased)) {
-                    tracer.trace(`Predicted next cursor line error: withinEditWindow`);
-                    telemetryBuilder.setNextCursorLineError('withinEditWindow');
-                }
-                else {
-                    const nextCursorLineOneBased = nextCursorLineZeroBased + 1;
-                    const nextCursorLine = promptPieces.activeDoc.documentAfterEditsLines.at(nextCursorLineZeroBased);
-                    const nextCursorColumn = (nextCursorLine?.length ?? 0) + 1;
-                    switch (nextCursorLinePrediction) {
-                        case nextCursorLinePrediction_1.NextCursorLinePrediction.Jump: {
-                            const nextCursorPosition = new position_1.Position(nextCursorLineOneBased, nextCursorColumn);
-                            pushEdit(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow, nextCursorPosition)));
-                            return;
-                        }
-                        case nextCursorLinePrediction_1.NextCursorLinePrediction.OnlyWithEdit: {
-                            this.doGetNextEditWithSelection(request, new range_1.Range(nextCursorLineOneBased, nextCursorColumn, nextCursorLineOneBased, nextCursorColumn), pushEdit, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, 1 /* RetryState.Retrying */);
-                            return;
-                        }
-                        default: {
-                            (0, assert_1.assertNever)(nextCursorLinePrediction);
-                        }
-                    }
-                }
+            default: {
+                (0, assert_1.assertNever)(nextCursorLinePrediction);
             }
         }
-        pushEdit(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow)));
-        return;
     }
     computeAreaAroundEditWindowLinesRange(currentDocument) {
         const cursorLine = currentDocument.cursorLineOffset;
@@ -644,7 +647,7 @@ let XtabProvider = class XtabProvider {
         const areaAroundEndExcl = Math.min(currentDocument.lines.length, cursorLine + promptCrafting_1.N_LINES_AS_CONTEXT + 1);
         return new offsetRange_1.OffsetRange(areaAroundStart, areaAroundEndExcl);
     }
-    computeEditWindowLinesRange(currentDocument, request, retryState, tracer, telemetry) {
+    computeEditWindowLinesRange(currentDocument, request, tracer, telemetry) {
         const currentDocLines = currentDocument.lines;
         const cursorLineOffset = currentDocument.cursorLineOffset;
         let nLinesAbove;
@@ -684,9 +687,6 @@ let XtabProvider = class XtabProvider {
                 nLinesBelow = promptCrafting_1.N_LINES_BELOW; // default
             }
         }
-        if (retryState === 1 /* RetryState.Retrying */) {
-            nLinesBelow += this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderRetryWithNMoreLinesBelow, this.expService) ?? 0;
-        }
         let codeToEditStart = Math.max(0, cursorLineOffset - nLinesAbove);
         let codeToEditEndExcl = Math.min(currentDocLines.length, cursorLineOffset + nLinesBelow + 1);
         const maxMergeConflictLines = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabMaxMergeConflictLines, this.expService);
@@ -756,11 +756,13 @@ let XtabProvider = class XtabProvider {
                 nDocuments: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabNRecentlyViewedDocuments, this.expService),
                 maxTokens: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabRecentlyViewedDocumentsMaxTokens, this.expService),
                 includeViewedFiles: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabIncludeViewedFiles, this.expService),
+                includeLineNumbers: false, // Line numbers are only used for next cursor prediction
             },
             languageContext: this.determineLanguageContextOptions(activeDocument.languageId, {
                 enabled: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabLanguageContextEnabled, this.expService),
                 enabledLanguages: this.configService.getConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabLanguageContextEnabledLanguages),
-                enabledDiagnostics: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Advanced.DiagnosticsContextProvider, this.expService),
+                enableAllContextProviders: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Advanced.DiagnosticsContextProvider, this.expService)
+                    || this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Advanced.ChatSessionContextProvider, this.expService),
                 maxTokens: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabLanguageContextMaxTokens, this.expService),
                 traitPosition: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabLanguageContextTraitsPosition, this.expService),
             }),
@@ -812,11 +814,11 @@ let XtabProvider = class XtabProvider {
                 (0, assert_1.assertNever)(promptingStrategy);
         }
     }
-    determineLanguageContextOptions(languageId, { enabled, enabledLanguages, maxTokens, enabledDiagnostics: diagnosticsEnabled, traitPosition }) {
+    determineLanguageContextOptions(languageId, { enabled, enabledLanguages, maxTokens, enableAllContextProviders, traitPosition }) {
         if (languageId in enabledLanguages) {
             return { enabled: enabledLanguages[languageId], maxTokens, traitPosition };
         }
-        if (diagnosticsEnabled) {
+        if (enableAllContextProviders) {
             return { enabled: true, maxTokens, traitPosition };
         }
         return { enabled, maxTokens, traitPosition };
@@ -861,7 +863,7 @@ let XtabProvider = class XtabProvider {
         if (this.simulationCtx.isInSimulationTests) {
             return;
         }
-        if (retryState === 1 /* RetryState.Retrying */) {
+        if (retryState instanceof RetryState.Retrying) {
             tracer.trace('Skipping debounce on retry');
             return;
         }
@@ -882,6 +884,31 @@ let XtabProvider = class XtabProvider {
         telemetry.setArtificialDelay(artificialDelay);
         return artificialDelay;
     }
+    filterEdit(activeDoc, edits) {
+        const filters = [
+            (edits) => importFiltering_1.IgnoreImportChangesAspect.filterEdit(activeDoc, edits),
+            (edits) => statelessNextEditProviders_1.IgnoreEmptyLineAndLeadingTrailingWhitespaceChanges.filterEdit(activeDoc, edits),
+        ];
+        if (!this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.InlineEditsAllowWhitespaceOnlyChanges, this.expService)) {
+            filters.push((edits) => statelessNextEditProviders_1.IgnoreWhitespaceOnlyChanges.filterEdit(activeDoc, edits));
+        }
+        const undoInsertionFiltering = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsUndoInsertionFiltering, this.expService);
+        if (undoInsertionFiltering !== undefined) {
+            let filter;
+            switch (undoInsertionFiltering) {
+                case 'v1':
+                    filter = statelessNextEditProviders_1.editWouldDeleteWhatWasJustInserted;
+                    break;
+                case 'v2':
+                    filter = statelessNextEditProviders_1.editWouldDeleteWhatWasJustInserted2;
+                    break;
+                default:
+                    (0, assert_1.assertNever)(undoInsertionFiltering);
+            }
+            filters.push((edits) => filter(activeDoc, new lineEdit_1.LineEdit(edits)) ? [] : edits);
+        }
+        return filters.reduce((acc, filter) => filter(acc), edits);
+    }
 };
 exports.XtabProvider = XtabProvider;
 exports.XtabProvider = XtabProvider = XtabProvider_1 = __decorate([