@vscode/chat-lib 0.4.0 → 0.4.1-1

package/dist/src/_internal/extension/inlineEdits/node/nextEditProvider.js

@@ -47,12 +47,17 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NextEditFetchRequest = exports.NextEditProvider = void 0;
+const path_1 = require("path");
 const configurationService_1 = require("../../../platform/configuration/common/configurationService");
 const edit_1 = require("../../../platform/inlineEdits/common/dataTypes/edit");
 const rootedLineEdit_1 = require("../../../platform/inlineEdits/common/dataTypes/rootedLineEdit");
+const xtabPromptOptions_1 = require("../../../platform/inlineEdits/common/dataTypes/xtabPromptOptions");
+const inlineEditLogContext_1 = require("../../../platform/inlineEdits/common/inlineEditLogContext");
 const statelessNextEditProvider_1 = require("../../../platform/inlineEdits/common/statelessNextEditProvider");
 const observable_1 = require("../../../platform/inlineEdits/common/utils/observable");
 const logService_1 = require("../../../platform/log/common/logService");
+const capturingToken_1 = require("../../../platform/requestLogger/common/capturingToken");
+const requestLogger_1 = require("../../../platform/requestLogger/node/requestLogger");
 const snippyService_1 = require("../../../platform/snippy/common/snippyService");
 const nullExperimentationService_1 = require("../../../platform/telemetry/common/nullExperimentationService");
 const errors = __importStar(require("../../../util/common/errors"));
@@ -68,11 +73,40 @@ const types_1 = require("../../../util/vs/base/common/types");
 const uuid_1 = require("../../../util/vs/base/common/uuid");
 const lineEdit_1 = require("../../../util/vs/editor/common/core/edits/lineEdit");
 const stringEdit_1 = require("../../../util/vs/editor/common/core/edits/stringEdit");
+const position_1 = require("../../../util/vs/editor/common/core/position");
 const offsetRange_1 = require("../../../util/vs/editor/common/core/ranges/offsetRange");
+const abstractText_1 = require("../../../util/vs/editor/common/core/text/abstractText");
 const editRebase_1 = require("../common/editRebase");
 const rejectionCollector_1 = require("../common/rejectionCollector");
 const nextEditCache_1 = require("./nextEditCache");
 const nextEditResult_1 = require("./nextEditResult");
+/**
+ * Computes a reduced window range that encompasses both the original window (shrunk by one line
+ * on each end) and the full line where the cursor is located.
+ *
+ * This ensures the cache invalidation window always includes the cursor's line while trimming
+ * the edges of the original window.
+ */
+function computeReducedWindow(window, activeDocSelection, documentBeforeEdits) {
+    if (!activeDocSelection) {
+        return window;
+    }
+    const cursorOffset = activeDocSelection.endExclusive;
+    const t = documentBeforeEdits.getTransformer();
+    const cursorPosition = t.getPosition(cursorOffset);
+    const lineOffset = t.getOffset(cursorPosition.with(undefined, 1));
+    const lineEndOffset = t.getOffset(cursorPosition.with(undefined, t.getLineLength(cursorPosition.lineNumber) + 1));
+    const reducedOffset = t.getOffset(t.getPosition(window.start).delta(1));
+    const reducedEndPosition = t.getPosition(window.endExclusive).delta(-2);
+    const reducedEndOffset = t.getOffset(reducedEndPosition.column > 1 ? reducedEndPosition.with(undefined, t.getLineLength(reducedEndPosition.lineNumber) + 1) : reducedEndPosition);
+    return new offsetRange_1.OffsetRange(Math.min(reducedOffset, lineOffset), Math.max(reducedEndOffset, lineEndOffset));
+}
+function convertLineEditToEdit(nextLineEdit, projectedDocuments, docId) {
+    const doc = projectedDocuments.find(d => d.nextEditDoc.id === docId);
+    const rootedLineEdit = new rootedLineEdit_1.RootedLineEdit(doc.documentAfterEdits, nextLineEdit);
+    const suggestedEdit = rootedLineEdit.toEdit();
+    return suggestedEdit;
+}
 let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
     get lastRejectionTime() {
         return this._lastRejectionTime;
@@ -80,7 +114,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
     get lastTriggerTime() {
         return this._lastTriggerTime;
     }
-    constructor(_workspace, _statelessNextEditProvider, _historyContextProvider, _xtabHistoryTracker, _debugRecorder, _configService, _snippyService, _logService, _expService) {
+    constructor(_workspace, _statelessNextEditProvider, _historyContextProvider, _xtabHistoryTracker, _debugRecorder, _configService, _snippyService, _logService, _expService, _requestLogger) {
         super();
         this._workspace = _workspace;
         this._statelessNextEditProvider = _statelessNextEditProvider;
@@ -91,10 +125,19 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         this._snippyService = _snippyService;
         this._logService = _logService;
         this._expService = _expService;
+        this._requestLogger = _requestLogger;
         this.ID = this._statelessNextEditProvider.ID;
         this._rejectionCollector = this._register(new rejectionCollector_1.RejectionCollector(this._workspace, this._logService));
         this._pendingStatelessNextEditRequest = null;
+        /**
+         * Tracks a speculative request for the post-edit document state.
+         * When a suggestion is shown, we speculatively fetch the next edit as if the user had already accepted.
+         * This allows reusing the in-flight request when the user actually accepts the suggestion.
+         */
+        this._speculativePendingRequest = null;
         this._lastShownTime = 0;
+        /** The requestId of the last shown suggestion. We store only the requestId (not the object) to avoid preventing garbage collection. */
+        this._lastShownSuggestionId = undefined;
         this._lastRejectionTime = 0;
         this._lastTriggerTime = 0;
         this._shouldExpandEditWindow = false;
@@ -152,7 +195,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         const documentAtInvocationTime = doc.value.get();
         const selections = doc.selection.get();
         const nesConfigs = this.determineNesConfigs(telemetryBuilder, logContext);
-        const cachedEdit = this._nextEditCache.lookupNextEdit(docId, documentAtInvocationTime, selections, nesConfigs);
+        const cachedEdit = this._nextEditCache.lookupNextEdit(docId, documentAtInvocationTime, selections);
         if (cachedEdit?.rejected) {
             logger.trace('cached edit was previously rejected');
             telemetryBuilder.setStatus('previouslyRejectedCache');
@@ -251,7 +294,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
             telemetryBuilder.setStatus(`noEdit:gotCancelled`);
             return emptyResult;
         }
-        if (this._rejectionCollector.isRejected(targetDocumentId, edit.actualEdit) || currentDocument && this._nextEditCache.isRejectedNextEdit(targetDocumentId, currentDocument, edit.actualEdit, nesConfigs)) {
+        if (this._rejectionCollector.isRejected(targetDocumentId, edit.actualEdit) || currentDocument && this._nextEditCache.isRejectedNextEdit(targetDocumentId, currentDocument, edit.actualEdit)) {
             logger.trace('edit was previously rejected');
             telemetryBuilder.setStatus('previouslyRejected');
             telemetryBuilder.setWasPreviouslyRejected();
@@ -260,8 +303,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         logContext.setResult(rootedLineEdit_1.RootedLineEdit.fromEdit(new edit_1.RootedEdit(documentAtInvocationTime, new stringEdit_1.StringEdit([edit.actualEdit]))));
         (0, assert_1.assert)(currentDocument !== undefined, 'should be defined if edit is defined');
         telemetryBuilder.setStatus('notAccepted'); // Acceptance pending.
-        const showRangePreference = this._statelessNextEditProvider.showNextEditPreference ?? "aroundEdit" /* ShowNextEditPreference.AroundEdit */;
-        const nextEditResult = new nextEditResult_1.NextEditResult(logContext.requestId, req, { edit: edit.actualEdit, isFromCursorJump: edit.isFromCursorJump, showRangePreference, documentBeforeEdits: currentDocument, targetDocumentId });
+        const nextEditResult = new nextEditResult_1.NextEditResult(logContext.requestId, req, { edit: edit.actualEdit, isFromCursorJump: edit.isFromCursorJump, documentBeforeEdits: currentDocument, targetDocumentId });
         telemetryBuilder.setHasNextEdit(true);
         const delay = this.computeMinimumResponseDelay({ triggerTime, isRebasedCachedEdit, isSubsequentCachedEdit, enforceCacheDelay: context.enforceCacheDelay }, logger);
         if (delay > 0) {
@@ -278,6 +320,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
     determineNesConfigs(telemetryBuilder, logContext) {
         const nesConfigs = {
             isAsyncCompletions: this._configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsAsyncCompletions, this._expService),
+            isEagerBackupRequest: this._configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsEagerBackupRequest, this._expService),
         };
         telemetryBuilder.setNESConfigs({ ...nesConfigs });
         logContext.addCodeblockToLog(JSON.stringify(nesConfigs, null, '\t'));
@@ -308,21 +351,75 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         const selectionAtInvocationTime = doc.selection.get();
         const logContext = req.log;
         logContext.setRecentEdit(historyContext);
+        // Check if we can reuse the regular pending request
         const pendingRequestStillCurrent = documentAtInvocationTime.value === this._pendingStatelessNextEditRequest?.documentBeforeEdits.value;
         const existingNextEditRequest = (pendingRequestStillCurrent || nesConfigs.isAsyncCompletions) && !this._pendingStatelessNextEditRequest?.cancellationTokenSource.token.isCancellationRequested
             && this._pendingStatelessNextEditRequest || undefined;
-        if (existingNextEditRequest) {
+        // Check if we can reuse the speculative pending request (from when a suggestion was shown)
+        const speculativeRequestMatches = this._speculativePendingRequest?.postEditContent === documentAtInvocationTime.value
+            && !this._speculativePendingRequest.request.cancellationTokenSource.token.isCancellationRequested;
+        const speculativeRequest = speculativeRequestMatches ? this._speculativePendingRequest?.request : undefined;
+        // Prefer speculative request if it matches (it was specifically created for this post-edit state)
+        const requestToReuse = speculativeRequest ?? existingNextEditRequest;
+        if (requestToReuse) {
             // Nice! No need to make another request, we can reuse the result from a pending request.
-            const nextEditResult = await this._joinNextEditRequest(existingNextEditRequest, telemetryBuilder, logContext, cancellationToken);
-            if (pendingRequestStillCurrent) {
+            if (speculativeRequest) {
+                logger.trace(`reusing speculative pending request (opportunityId=${speculativeRequest.opportunityId}, headerRequestId=${speculativeRequest.headerRequestId})`);
+                // Clear the speculative request since we're using it
+                this._speculativePendingRequest = null;
+            }
+            const requestStillCurrent = speculativeRequest
+                ? speculativeRequestMatches // For speculative, we already checked it matches
+                : pendingRequestStillCurrent;
+            if (requestStillCurrent) {
+                const nextEditResult = await this._joinNextEditRequest(requestToReuse, telemetryBuilder, logContext, cancellationToken);
                 telemetryBuilder.setStatelessNextEditTelemetry(nextEditResult.telemetry);
-                return nextEditResult.nextEdit.isError() ? nextEditResult.nextEdit : existingNextEditRequest.firstEdit.p;
+                return nextEditResult.nextEdit.isError() ? nextEditResult.nextEdit : requestToReuse.firstEdit.p;
+            }
+            else if (nesConfigs.isEagerBackupRequest) {
+                // The pending request is stale (document diverged). Start a backup request
+                // in parallel so that if rebase fails, we already have a head start.
+                logger.trace('starting eager backup request in parallel with rebase attempt');
+                // _executeNewNextEditRequest cancels the current _pendingStatelessNextEditRequest,
+                // but we're still trying to join+rebase requestToReuse. Temporarily clear the
+                // pending field so the stale request isn't cancelled prematurely.
+                this._pendingStatelessNextEditRequest = null;
+                const backupPromise = this._executeNewNextEditRequest(req, doc, historyContext, nesConfigs, shouldExpandEditWindow, logger, telemetryBuilder, cancellationToken);
+                const cancelBackupRequest = () => {
+                    void backupPromise
+                        .then(r => r.nextEditRequest.cancellationTokenSource.cancel())
+                        .catch(() => undefined);
+                };
+                // Simultaneously attempt to join + rebase the stale request
+                const nextEditResult = await this._joinNextEditRequest(requestToReuse, telemetryBuilder, logContext, cancellationToken);
+                const cacheResult = await requestToReuse.firstEdit.p;
+                if (cacheResult.isOk() && cacheResult.val.edit) {
+                    const rebasedCachedEdit = this._nextEditCache.tryRebaseCacheEntry(cacheResult.val, documentAtInvocationTime, selectionAtInvocationTime);
+                    if (rebasedCachedEdit) {
+                        logger.trace('rebase succeeded, cancelling eager backup request');
+                        cancelBackupRequest();
+                        telemetryBuilder.setStatelessNextEditTelemetry(nextEditResult.telemetry);
+                        return result_1.Result.ok(rebasedCachedEdit);
+                    }
+                }
+                if (cancellationToken.isCancellationRequested) {
+                    logger.trace('cancelled after rebase failed (eager backup path)');
+                    cancelBackupRequest();
+                    telemetryBuilder.setStatelessNextEditTelemetry(nextEditResult.telemetry);
+                    return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.GotCancelled('afterFailedRebase'));
+                }
+                // Rebase failed — use the backup request that's already been running in parallel
+                logger.trace('rebase failed, using eager backup request');
+                const backupRes = await backupPromise;
+                telemetryBuilder.setStatelessNextEditTelemetry(backupRes.nextEditResult.telemetry);
+                return backupRes.nextEditResult.nextEdit.isError() ? backupRes.nextEditResult.nextEdit : backupRes.nextEditRequest.firstEdit.p;
             }
             else {
+                const nextEditResult = await this._joinNextEditRequest(requestToReuse, telemetryBuilder, logContext, cancellationToken);
                 // Needs rebasing.
-                const cacheResult = await existingNextEditRequest.firstEdit.p;
+                const cacheResult = await requestToReuse.firstEdit.p;
                 if (cacheResult.isOk() && cacheResult.val.edit) {
-                    const rebasedCachedEdit = this._nextEditCache.tryRebaseCacheEntry(cacheResult.val, documentAtInvocationTime, selectionAtInvocationTime, nesConfigs);
+                    const rebasedCachedEdit = this._nextEditCache.tryRebaseCacheEntry(cacheResult.val, documentAtInvocationTime, selectionAtInvocationTime);
                     if (rebasedCachedEdit) {
                         telemetryBuilder.setStatelessNextEditTelemetry(nextEditResult.telemetry);
                         return result_1.Result.ok(rebasedCachedEdit);
@@ -334,14 +431,14 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
                     return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.GotCancelled('afterFailedRebase'));
                 }
                 // Rebase failed (or result had error). Check if there is a new pending request. Otherwise continue with a new request below.
-                const pendingRequestStillCurrent = documentAtInvocationTime.value === this._pendingStatelessNextEditRequest?.documentBeforeEdits.value;
-                const existingNextEditRequest2 = pendingRequestStillCurrent && !this._pendingStatelessNextEditRequest?.cancellationTokenSource.token.isCancellationRequested
+                const pendingRequestStillCurrent2 = documentAtInvocationTime.value === this._pendingStatelessNextEditRequest?.documentBeforeEdits.value;
+                const existingNextEditRequest2 = pendingRequestStillCurrent2 && !this._pendingStatelessNextEditRequest?.cancellationTokenSource.token.isCancellationRequested
                     && this._pendingStatelessNextEditRequest || undefined;
                 if (existingNextEditRequest2) {
                     logger.trace('reusing 2nd existing next edit request after rebase failed');
-                    const nextEditResult = await this._joinNextEditRequest(existingNextEditRequest2, telemetryBuilder, logContext, cancellationToken);
-                    telemetryBuilder.setStatelessNextEditTelemetry(nextEditResult.telemetry);
-                    return nextEditResult.nextEdit.isError() ? nextEditResult.nextEdit : existingNextEditRequest2.firstEdit.p;
+                    const nextEditResult2 = await this._joinNextEditRequest(existingNextEditRequest2, telemetryBuilder, logContext, cancellationToken);
+                    telemetryBuilder.setStatelessNextEditTelemetry(nextEditResult2.telemetry);
+                    return nextEditResult2.nextEdit.isError() ? nextEditResult2.nextEdit : existingNextEditRequest2.firstEdit.p;
                 }
                 logger.trace('creating new next edit request after rebase failed');
             }
@@ -354,7 +451,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
     }
     async _joinNextEditRequest(nextEditRequest, telemetryBuilder, logContext, cancellationToken) {
         // TODO: Will the telemetry look alright in this case?
-        telemetryBuilder.setHeaderRequestId(nextEditRequest.id);
+        telemetryBuilder.setHeaderRequestId(nextEditRequest.headerRequestId);
         telemetryBuilder.setIsFromCache();
         telemetryBuilder.setRequest(nextEditRequest);
         logContext.setRequestInput(nextEditRequest);
@@ -376,12 +473,6 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         const activeDocSelection = doc.selection.get()[0];
         const projectedDocuments = historyContext.documents.map(doc => this._processDoc(doc));
         const xtabEditHistory = this._xtabHistoryTracker.getHistory();
-        function convertLineEditToEdit(nextLineEdit, docId) {
-            const doc = projectedDocuments.find(d => d.nextEditDoc.id === docId);
-            const rootedLineEdit = new rootedLineEdit_1.RootedLineEdit(doc.documentAfterEdits, nextLineEdit);
-            const suggestedEdit = rootedLineEdit.toEdit();
-            return suggestedEdit;
-        }
         const firstEdit = new async_1.DeferredPromise();
         const nLinesEditWindow = (shouldExpandEditWindow
             ? this._configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsAutoExpandEditWindowLines, this._expService)
@@ -420,117 +511,132 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
                 }
             });
         }) : undefined);
-        const createPushEdit = () => {
-            let ithEdit = -1;
-            const statePerDoc = new cache_1.CachedFunction((id) => {
-                const doc = projectedDocuments.find(d => d.nextEditDoc.id === id);
-                if (!doc) {
-                    throw new errors_1.BugIndicatingError();
-                }
-                return {
-                    docContents: doc.documentAfterEdits,
-                    editsSoFar: stringEdit_1.StringEdit.empty,
-                    nextEdits: [],
-                    docId: id,
-                };
-            });
-            const pushEdit = (result) => {
-                const myLogger = logger.createSubLogger('pushEdit');
-                ++ithEdit;
-                myLogger.trace(`processing edit #${ithEdit} (starts at 0)`);
-                if (result.isError()) { // either error or stream of edits ended
-                    // if there was a request made, and it ended without any edits, reset shouldExpandEditWindow
-                    if (ithEdit === 0 && result.err instanceof statelessNextEditProvider_1.NoNextEditReason.NoSuggestions) {
-                        myLogger.trace('resetting shouldExpandEditWindow to false due to NoSuggestions');
-                        this._shouldExpandEditWindow = false;
-                    }
-                    if (statePerDoc.get(curDocId).nextEdits.length) {
-                        myLogger.trace(`${statePerDoc.get(curDocId).nextEdits.length} edits returned`);
-                    }
-                    else {
-                        myLogger.trace(`no edit, reason: ${result.err.kind}`);
-                        if (result.err instanceof statelessNextEditProvider_1.NoNextEditReason.NoSuggestions) {
-                            const { documentBeforeEdits, window } = result.err;
-                            let reducedWindow = window;
-                            if (activeDocSelection && window) {
-                                const cursorOffset = activeDocSelection.endExclusive;
-                                const t = documentBeforeEdits.getTransformer();
-                                const cursorPosition = t.getPosition(cursorOffset);
-                                const lineOffset = t.getOffset(cursorPosition.with(undefined, 1));
-                                const lineEndOffset = t.getOffset(cursorPosition.with(undefined, t.getLineLength(cursorPosition.lineNumber) + 1));
-                                const reducedOffset = t.getOffset(t.getPosition(window.start).delta(1));
-                                const reducedEndPosition = t.getPosition(window.endExclusive).delta(-2);
-                                const reducedEndOffset = t.getOffset(reducedEndPosition.column > 1 ? reducedEndPosition.with(undefined, t.getLineLength(reducedEndPosition.lineNumber) + 1) : reducedEndPosition);
-                                reducedWindow = new offsetRange_1.OffsetRange(Math.min(reducedOffset, lineOffset), Math.max(reducedEndOffset, lineEndOffset));
-                            }
-                            this._nextEditCache.setNoNextEdit(curDocId, documentBeforeEdits, reducedWindow, req);
-                        }
-                    }
-                    {
-                        disp.dispose();
-                        removeFromPending();
-                    }
-                    if (!firstEdit.isSettled) {
-                        firstEdit.complete(result);
-                    }
-                    return;
+        const statePerDoc = new cache_1.CachedFunction((id) => {
+            const doc = projectedDocuments.find(d => d.nextEditDoc.id === id);
+            if (!doc) {
+                throw new errors_1.BugIndicatingError();
+            }
+            return {
+                docContents: doc.documentAfterEdits,
+                editsSoFar: stringEdit_1.StringEdit.empty,
+                nextEdits: [],
+                docId: id,
+            };
+        });
+        const editStream = this._statelessNextEditProvider.provideNextEdit(nextEditRequest, logger, logContext, nextEditRequest.cancellationTokenSource.token);
+        let ithEdit = -1;
+        const processEdit = (streamedEdit, telemetry) => {
+            ++ithEdit;
+            const myLogger = logger.createSubLogger('processEdit');
+            myLogger.trace(`processing edit #${ithEdit} (starts at 0)`);
+            // reset shouldExpandEditWindow to false when we get any edit
+            myLogger.trace('resetting shouldExpandEditWindow to false due to receiving an edit');
+            this._shouldExpandEditWindow = false;
+            const targetDocState = statePerDoc.get(streamedEdit.targetDocument ?? curDocId);
+            const singleLineEdit = streamedEdit.edit;
+            const lineEdit = new lineEdit_1.LineEdit([singleLineEdit]);
+            const edit = convertLineEditToEdit(lineEdit, projectedDocuments, targetDocState.docId);
+            const rebasedEdit = edit.tryRebase(targetDocState.editsSoFar);
+            if (rebasedEdit === undefined) {
+                myLogger.trace(`edit ${ithEdit} is undefined after rebasing`);
+                if (!firstEdit.isSettled) {
+                    firstEdit.complete(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.Uncategorized(new Error('Rebased edit is undefined'))));
                 }
-                // reset shouldExpandEditWindow to false when we get any edit
-                myLogger.trace('resetting shouldExpandEditWindow to false due to receiving an edit');
+                return undefined;
+            }
+            targetDocState.editsSoFar = targetDocState.editsSoFar.compose(rebasedEdit);
+            let cachedEdit;
+            if (rebasedEdit.replacements.length === 0) {
+                myLogger.trace(`WARNING: ${ithEdit} has no edits`);
+            }
+            else if (rebasedEdit.replacements.length > 1) {
+                myLogger.trace(`WARNING: ${ithEdit} has ${rebasedEdit.replacements.length} edits, but expected only 1`);
+            }
+            else {
+                // populate the cache
+                const nextEditReplacement = rebasedEdit.replacements[0];
+                targetDocState.nextEdits.push(nextEditReplacement);
+                cachedEdit = this._nextEditCache.setKthNextEdit(targetDocState.docId, targetDocState.docContents, ithEdit === 0 ? streamedEdit.window : undefined, nextEditReplacement, ithEdit, ithEdit === 0 ? targetDocState.nextEdits : undefined, ithEdit === 0 ? nextEditRequest.intermediateUserEdit : undefined, req, { isFromCursorJump: streamedEdit.isFromCursorJump, originalEditWindow: streamedEdit.originalWindow });
+                myLogger.trace(`populated cache for ${ithEdit}`);
+            }
+            if (!firstEdit.isSettled) {
+                myLogger.trace('resolving firstEdit promise');
+                logContext.setResult(new rootedLineEdit_1.RootedLineEdit(targetDocState.docContents, lineEdit)); // this's correct without rebasing because this's the first edit
+                firstEdit.complete(cachedEdit ? result_1.Result.ok(cachedEdit) : result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.Unexpected(new Error('No cached edit'))));
+            }
+            targetDocState.docContents = rebasedEdit.applyOnText(targetDocState.docContents);
+            return cachedEdit;
+        };
+        const handleStreamEnd = (completionReason, lastTelemetry) => {
+            const myLogger = logger.createSubLogger('streamEnd');
+            // if there was a request made, and it ended without any edits, reset shouldExpandEditWindow
+            const hadNoEdits = ithEdit === -1;
+            if (hadNoEdits && completionReason instanceof statelessNextEditProvider_1.NoNextEditReason.NoSuggestions) {
+                myLogger.trace('resetting shouldExpandEditWindow to false due to NoSuggestions');
                 this._shouldExpandEditWindow = false;
-                const targetDocState = statePerDoc.get(result.val.targetDocument ?? curDocId);
-                const singleLineEdit = result.val.edit;
-                const lineEdit = new lineEdit_1.LineEdit([singleLineEdit]);
-                const edit = convertLineEditToEdit(lineEdit, targetDocState.docId);
-                const rebasedEdit = edit.tryRebase(targetDocState.editsSoFar);
-                if (rebasedEdit === undefined) {
-                    myLogger.trace(`edit ${ithEdit} is undefined after rebasing`);
-                    if (!firstEdit.isSettled) {
-                        firstEdit.complete(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.Uncategorized(new Error('Rebased edit is undefined'))));
-                    }
-                    return;
-                }
-                targetDocState.editsSoFar = targetDocState.editsSoFar.compose(rebasedEdit);
-                let cachedEdit;
-                if (rebasedEdit.replacements.length === 0) {
-                    myLogger.trace(`WARNING: ${ithEdit} has no edits`);
-                }
-                else if (rebasedEdit.replacements.length > 1) {
-                    myLogger.trace(`WARNING: ${ithEdit} has ${rebasedEdit.replacements.length} edits, but expected only 1`);
-                }
-                else {
-                    // populate the cache
-                    const nextEdit = rebasedEdit.replacements[0];
-                    targetDocState.nextEdits.push(nextEdit);
-                    cachedEdit = this._nextEditCache.setKthNextEdit(targetDocState.docId, targetDocState.docContents, ithEdit === 0 ? result.val.window : undefined, nextEdit, ithEdit, ithEdit === 0 ? targetDocState.nextEdits : undefined, ithEdit === 0 ? nextEditRequest.intermediateUserEdit : undefined, req, { isFromCursorJump: result.val.isFromCursorJump });
-                    myLogger.trace(`populated cache for ${ithEdit}`);
-                }
-                if (!firstEdit.isSettled) {
-                    myLogger.trace('resolving firstEdit promise');
-                    logContext.setResult(new rootedLineEdit_1.RootedLineEdit(targetDocState.docContents, lineEdit)); // this's correct without rebasing because this's the first edit
-                    firstEdit.complete(cachedEdit ? result_1.Result.ok(cachedEdit) : result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.Unexpected(new Error('No cached edit'))));
+            }
+            if (statePerDoc.get(curDocId).nextEdits.length) {
+                myLogger.trace(`${statePerDoc.get(curDocId).nextEdits.length} edits returned`);
+            }
+            else {
+                myLogger.trace(`no edit, reason: ${completionReason.kind}`);
+                if (completionReason instanceof statelessNextEditProvider_1.NoNextEditReason.NoSuggestions) {
+                    const { documentBeforeEdits, window } = completionReason;
+                    const reducedWindow = window ? computeReducedWindow(window, activeDocSelection, documentBeforeEdits) : undefined;
+                    this._nextEditCache.setNoNextEdit(curDocId, documentBeforeEdits, reducedWindow, req);
                 }
-                targetDocState.docContents = rebasedEdit.applyOnText(targetDocState.docContents);
-            };
-            return pushEdit;
+            }
+            if (!firstEdit.isSettled) {
+                firstEdit.complete(result_1.Result.error(completionReason));
+            }
+            const resultForTelemetry = statePerDoc.get(curDocId).nextEdits.length > 0
+                ? result_1.Result.ok(undefined)
+                : result_1.Result.error(completionReason);
+            const result = new statelessNextEditProvider_1.StatelessNextEditResult(resultForTelemetry, lastTelemetry);
+            nextEditRequest.setResult(result);
+            disp.dispose();
+            removeFromPending();
+            return result;
         };
-        const pushEdit = createPushEdit();
         try {
-            nextEditResult = await this._statelessNextEditProvider.provideNextEdit(nextEditRequest, pushEdit, logger, logContext, nextEditRequest.cancellationTokenSource.token);
-            nextEditRequest.setResult(nextEditResult);
+            let res = await editStream.next();
+            if (res.done) {
+                // Stream ended immediately without any edits
+                const completionReason = res.value.v;
+                nextEditResult = handleStreamEnd(completionReason, res.value.telemetryBuilder);
+            }
+            else {
+                // Process first edit synchronously
+                const firstStreamedEdit = res.value.v;
+                const firstTelemetry = res.value.telemetryBuilder;
+                processEdit(firstStreamedEdit, firstTelemetry);
+                // Continue streaming remaining edits in the background (unawaited)
+                (async () => {
+                    try {
+                        res = await editStream.next();
+                        while (!res.done) {
+                            const streamedEdit = res.value.v;
+                            processEdit(streamedEdit, res.value.telemetryBuilder);
+                            res = await editStream.next();
+                        }
+                        // Stream completed
+                        const completionReason = res.value.v;
+                        handleStreamEnd(completionReason, res.value.telemetryBuilder);
+                    }
+                    catch (err) {
+                        logger.trace(`Error while streaming further edits: ${errors.toString(err)}`);
+                        const errorReason = new statelessNextEditProvider_1.NoNextEditReason.Unexpected(errors.fromUnknown(err));
+                        handleStreamEnd(errorReason, firstTelemetry);
+                    }
+                })();
+                // Return early with streaming result
+                nextEditResult = statelessNextEditProvider_1.StatelessNextEditResult.streaming(new statelessNextEditProvider_1.StatelessNextEditTelemetryBuilder(nextEditRequest.headerRequestId));
+            }
         }
         catch (err) {
             nextEditRequest.setResultError(err);
             throw err;
         }
-        finally {
-            if (!nextEditResult || nextEditResult.nextEdit.isError()) {
-                // when streaming, we need to keep the response going unless UI cancels it
-                // if we remove it from pending here, when UI cancels, we cannot cancel it because we think that the request has finished
-                disp.dispose();
-                removeFromPending();
-            }
-        }
         return { nextEditRequest, nextEditResult };
     }
     _hookupCancellation(nextEditRequest, cancellationToken, attachedDisposable) {
@@ -596,6 +702,235 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
     }
     handleShown(suggestion) {
         this._lastShownTime = Date.now();
+        this._lastShownSuggestionId = suggestion.requestId;
+        // Trigger speculative request for the post-edit document state
+        const speculativeRequestsEnablement = this._configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsSpeculativeRequests, this._expService);
+        if (speculativeRequestsEnablement === xtabPromptOptions_1.SpeculativeRequestsEnablement.On) {
+            void this._triggerSpeculativeRequest(suggestion);
+        }
+    }
+    async _triggerSpeculativeRequest(suggestion) {
+        const logger = this._logger.createSubLogger('_triggerSpeculativeRequest');
+        const result = suggestion.result;
+        if (!result?.edit) {
+            logger.trace('no edit in suggestion result');
+            return;
+        }
+        const docId = result.targetDocumentId;
+        if (!docId) {
+            logger.trace('no target document ID in suggestion result');
+            return;
+        }
+        // Compute the post-edit document content
+        const postEditContent = result.edit.replace(result.documentBeforeEdits.value);
+        const postEditCursorOffset = result.edit.replaceRange.endExclusive + result.edit.getLengthDelta();
+        const selections = [new offsetRange_1.OffsetRange(postEditCursorOffset, postEditCursorOffset)];
+        const rootedEdit = new edit_1.RootedEdit(result.documentBeforeEdits, new stringEdit_1.StringEdit([result.edit]));
+        const postEditContentST = new abstractText_1.StringText(postEditContent);
+        let cachedEdit = this._nextEditCache.lookupNextEdit(docId, postEditContentST, selections);
+        let shiftedSelection;
+        if (cachedEdit) {
+            // first cachedEdit should be without edits because of noSuggestions caching
+            if (cachedEdit.edit) {
+                logger.trace('already have cached edit for post-edit state');
+                return;
+            }
+            else if (cachedEdit.editWindow) {
+                const trans = postEditContentST.getTransformer();
+                const endOfEditWindow = trans.getPosition(cachedEdit.editWindow.endExclusive - 1);
+                const shiftedCursorLineNumber = (endOfEditWindow.lineNumber + 1 < postEditContentST.lineRange.endLineNumberExclusive
+                    ? endOfEditWindow.lineNumber + 1
+                    : endOfEditWindow.lineNumber);
+                const shiftedSelectionCursorOffset = trans.getOffset(new position_1.Position(shiftedCursorLineNumber, 1));
+                shiftedSelection = new offsetRange_1.OffsetRange(shiftedSelectionCursorOffset, shiftedSelectionCursorOffset);
+                cachedEdit = this._nextEditCache.lookupNextEdit(docId, postEditContentST, [shiftedSelection]);
+                if (cachedEdit?.edit) {
+                    logger.trace('already have cached edit for post-edit state (after shifting selection)');
+                    return;
+                }
+            }
+            else {
+                logger.trace('already have cached no-suggestions entry for post-edit state');
+                return;
+            }
+        }
+        // Check if we already have a pending request for the post-edit state
+        if (this._pendingStatelessNextEditRequest?.documentBeforeEdits.value === postEditContent) {
+            logger.trace('already have pending request for post-edit state');
+            return;
+        }
+        // Check if we already have a speculative request for this post-edit state
+        if (this._speculativePendingRequest?.postEditContent === postEditContent) {
+            logger.trace('already have speculative request for post-edit state');
+            return;
+        }
+        // Get the document to trigger speculative fetch
+        // Note: targetDocumentId is defined when the suggestion targets a different document
+        // Otherwise, use the file path from the log context
+        const doc = this._workspace.getDocument(docId);
+        if (!doc) {
+            logger.trace('document not found for speculative request');
+            return;
+        }
+        // Cancel any previous speculative request
+        this._speculativePendingRequest?.request.cancellationTokenSource.cancel();
+        this._speculativePendingRequest = null;
+        const historyContext = this._historyContextProvider.getHistoryContext(docId);
+        if (!historyContext) {
+            logger.trace('no history context for speculative request');
+            return;
+        }
+        // Create a speculative request
+        // Use a dummy version since this is speculative and we don't have the actual post-edit version
+        const logContext = new inlineEditLogContext_1.InlineEditRequestLogContext(docId.uri, 0, undefined);
+        const req = new NextEditFetchRequest(`sp-${suggestion.source.opportunityId}`, logContext, undefined, `sp-${(0, uuid_1.generateUuid)()}`);
+        logger.trace(`triggering speculative request for post-edit state (opportunityId=${req.opportunityId}, headerRequestId=${req.headerRequestId})`);
+        logger.trace(`triggering speculative request for post-edit state (opportunityId=${req.opportunityId}, headerRequestId=${req.headerRequestId})`);
+        try {
+            const speculativeRequest = await this._createSpeculativeRequest(req, doc, shiftedSelection, historyContext, postEditContent, rootedEdit, result.edit, logger);
+            if (speculativeRequest) {
+                this._speculativePendingRequest = {
+                    request: speculativeRequest,
+                    postEditContent,
+                };
+            }
+        }
+        catch (e) {
+            logger.trace(`speculative request failed: ${errors.toString(e)}`);
+        }
+    }
+    /**
+     * Creates and starts a speculative request for the post-edit document state.
+     * The request will populate the cache so that when the user accepts the suggestion,
+     * the next NES request can reuse or find the result in cache.
+     */
+    async _createSpeculativeRequest(req, doc, shiftedSelection, historyContext, postEditContent, rootedEdit, appliedEdit, parentLogger) {
+        const logger = parentLogger.createSubLogger('_createSpeculativeRequest');
+        const curDocId = doc.id;
+        const recording = this._debugRecorder?.getRecentLog();
+        const logContext = req.log;
+        const activeDocAndIdx = historyContext.getDocumentAndIdx(curDocId);
+        if (!activeDocAndIdx) {
+            logger.trace('active doc not found in history context');
+            return undefined;
+        }
+        // Create the post-edit document content
+        const postEditText = new abstractText_1.StringText(postEditContent);
+        // Process documents, but for the active document, use the post-edit state
+        const projectedDocuments = historyContext.documents.map(docHist => {
+            if (docHist.docId !== curDocId) {
+                return this._processDoc(docHist);
+            }
+            else {
+                // For the active document, create a version representing post-edit state
+                // The "recent edit" from the model's perspective is the NES edit we just applied
+                const workspaceRoot = this._workspace.getWorkspaceRoot(curDocId);
+                const postEditEdit = new stringEdit_1.StringEdit([appliedEdit]);
+                const postEditLineEdit = rootedLineEdit_1.RootedLineEdit.fromEdit(new edit_1.RootedEdit(doc.value.get(), postEditEdit)).removeCommonSuffixPrefixLines().edit;
+                let selection = shiftedSelection;
+                if (selection === undefined) {
+                    const appliedEditEndPos = postEditText.getTransformer().getPosition(appliedEdit.replaceRange.endExclusive + appliedEdit.getLengthDelta());
+                    const pos = new position_1.Position(appliedEditEndPos.lineNumber, 1);
+                    const offset = postEditText.getTransformer().getOffset(pos);
+                    selection = new offsetRange_1.OffsetRange(offset, offset);
+                }
+                const nextEditDoc = new statelessNextEditProvider_1.StatelessNextEditDocument(curDocId, workspaceRoot, docHist.languageId, doc.value.get().getLines(), // lines before the NES edit
+                postEditLineEdit, // the NES edit as LineEdit
+                doc.value.get(), // document before NES edit
+                edit_1.Edits.single(postEditEdit), // the NES edit as Edits
+                selection);
+                return {
+                    recentEdit: new edit_1.RootedEdit(doc.value.get(), postEditEdit),
+                    nextEditDoc,
+                    documentAfterEdits: postEditText,
+                };
+            }
+        });
+        const xtabEditHistory = this._xtabHistoryTracker.getHistory();
+        const suggestedEdit = { kind: 'edit', docId: curDocId, edit: rootedEdit };
+        xtabEditHistory.push(suggestedEdit);
+        const firstEdit = new async_1.DeferredPromise();
+        const nLinesEditWindow = this._configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsAutoExpandEditWindowLines, this._expService);
+        const nextEditRequest = new statelessNextEditProvider_1.StatelessNextEditRequest(req.headerRequestId, req.opportunityId, postEditText, // documentBeforeEdits is the post-edit state
+        projectedDocuments.map(d => d.nextEditDoc), activeDocAndIdx.idx, xtabEditHistory, firstEdit, nLinesEditWindow, logContext, undefined, // recordingBookmark
+        recording, undefined);
+        logger.trace('starting speculative provider call');
+        // Start the provider call - this runs in the background and populates the cache
+        const label = `NES | spec | ${(0, path_1.basename)(doc.id.toUri().fsPath)} (v${doc.version})`;
+        const capturingToken = new capturingToken_1.CapturingToken(label, undefined, true, true);
+        void this._requestLogger.captureInvocation(capturingToken, () => this._runSpeculativeProviderCall(nextEditRequest, projectedDocuments, curDocId, req, logger));
+        return nextEditRequest;
+    }
+    /**
+     * Runs the provider call for a speculative request and caches results.
+     */
+    async _runSpeculativeProviderCall(nextEditRequest, projectedDocuments, curDocId, req, parentLogger) {
+        const logger = parentLogger.createSubLogger('_runSpeculativeProviderCall');
+        const statePerDoc = new cache_1.CachedFunction((id) => {
+            const doc = projectedDocuments.find(d => d.nextEditDoc.id === id);
+            if (!doc) {
+                throw new errors_1.BugIndicatingError();
+            }
+            return {
+                docContents: doc.documentAfterEdits,
+                editsSoFar: stringEdit_1.StringEdit.empty,
+                nextEdits: [],
+                docId: id,
+            };
+        });
+        const logContext = req.log;
+        const editStream = this._statelessNextEditProvider.provideNextEdit(nextEditRequest, logger, logContext, nextEditRequest.cancellationTokenSource.token);
+        let ithEdit = -1;
+        try {
+            let res = await editStream.next();
+            if (res.done) {
+                nextEditRequest.firstEdit.complete(result_1.Result.error(res.value.v));
+                nextEditRequest.setResult(new statelessNextEditProvider_1.StatelessNextEditResult(result_1.Result.error(res.value.v), res.value.telemetryBuilder));
+                logger.trace('speculative request completed with no edits');
+            }
+            else {
+                (async () => {
+                    while (!res.done) {
+                        ++ithEdit;
+                        const streamedEdit = res.value.v;
+                        const targetDocState = statePerDoc.get(streamedEdit.targetDocument ?? curDocId);
+                        const singleLineEdit = streamedEdit.edit;
+                        const lineEdit = new lineEdit_1.LineEdit([singleLineEdit]);
+                        const edit = convertLineEditToEdit(lineEdit, projectedDocuments, targetDocState.docId);
+                        const rebasedEdit = edit.tryRebase(targetDocState.editsSoFar);
+                        if (rebasedEdit === undefined) {
+                            logger.trace(`speculative edit ${ithEdit} rebasing failed`);
+                            res = await editStream.next();
+                            continue;
+                        }
+                        targetDocState.editsSoFar = targetDocState.editsSoFar.compose(rebasedEdit);
+                        if (rebasedEdit.replacements.length === 1) {
+                            const nextEditReplacement = rebasedEdit.replacements[0];
+                            targetDocState.nextEdits.push(nextEditReplacement);
+                            // Populate the cache with the speculative result
+                            const cachedEdit = this._nextEditCache.setKthNextEdit(targetDocState.docId, targetDocState.docContents, ithEdit === 0 ? streamedEdit.window : undefined, nextEditReplacement, ithEdit, ithEdit === 0 ? targetDocState.nextEdits : undefined, undefined, // no userEditSince for speculative
+                            req, { isFromCursorJump: streamedEdit.isFromCursorJump, originalEditWindow: streamedEdit.originalWindow });
+                            if (!nextEditRequest.firstEdit.isSettled && cachedEdit) {
+                                nextEditRequest.firstEdit.complete(result_1.Result.ok(cachedEdit));
+                                nextEditRequest.setResult(new statelessNextEditProvider_1.StatelessNextEditResult(result_1.Result.ok(undefined), res.value.telemetryBuilder));
+                            }
+                            logger.trace(`cached speculative edit ${ithEdit}`);
+                        }
+                        targetDocState.docContents = rebasedEdit.applyOnText(targetDocState.docContents);
+                        res = await editStream.next();
+                    }
+                })().finally(() => {
+                    if (!nextEditRequest.firstEdit.isSettled) {
+                        nextEditRequest.firstEdit.complete(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.Uncategorized(new Error('Speculative request ended without edits'))));
+                        nextEditRequest.setResult(new statelessNextEditProvider_1.StatelessNextEditResult(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.Uncategorized(new Error('Speculative request ended without edits'))), res.value.telemetryBuilder));
+                    }
+                });
+            }
+            logger.trace(`speculative request completed with ${ithEdit + 1} edits`);
+        }
+        catch (e) {
+            logger.trace(`speculative provider call error: ${errors.toString(e)}`);
+        }
     }
     handleAcceptance(docId, suggestion) {
         this.runSnippy(docId, suggestion);
@@ -621,7 +956,15 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         this._lastRejectionTime = Date.now();
         this._statelessNextEditProvider.handleRejection?.();
     }
-    handleIgnored(docId, suggestion, supersededBy) { }
+    handleIgnored(docId, suggestion, supersededBy) {
+        // Check if this was the last shown suggestion
+        const wasShown = this._lastShownSuggestionId === suggestion.requestId;
+        const wasSuperseded = supersededBy !== undefined;
+        if (wasShown && !wasSuperseded) {
+            // Was shown to the user
+            this._statelessNextEditProvider.handleIgnored?.();
+        }
+    }
     async runSnippy(docId, suggestion) {
         if (suggestion.result === undefined || suggestion.result.edit === undefined) {
             return;
@@ -638,7 +981,8 @@ exports.NextEditProvider = NextEditProvider = __decorate([
     __param(5, configurationService_1.IConfigurationService),
     __param(6, snippyService_1.ISnippyService),
     __param(7, logService_1.ILogService),
-    __param(8, nullExperimentationService_1.IExperimentationService)
+    __param(8, nullExperimentationService_1.IExperimentationService),
+    __param(9, requestLogger_1.IRequestLogger)
 ], NextEditProvider);
 function assertDefined(value) {
     if (!value) {
@@ -647,11 +991,11 @@ function assertDefined(value) {
     return value;
 }
 class NextEditFetchRequest {
-    constructor(opportunityId, log, providerRequestStartDateTime) {
+    constructor(opportunityId, log, providerRequestStartDateTime, headerRequestId = (0, uuid_1.generateUuid)()) {
         this.opportunityId = opportunityId;
         this.log = log;
         this.providerRequestStartDateTime = providerRequestStartDateTime;
-        this.headerRequestId = (0, uuid_1.generateUuid)();
+        this.headerRequestId = headerRequestId;
     }
 }
 exports.NextEditFetchRequest = NextEditFetchRequest;