@vscode/chat-lib 0.4.1-2 → 0.4.1-20

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

@@ -3,50 +3,18 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
+var NextEditProvider_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NextEditFetchRequest = exports.NextEditProvider = void 0;
+exports.NextEditFetchRequest = exports.NextEditProvider = exports.NesOutcome = void 0;
 const path_1 = require("path");
 const configurationService_1 = require("../../../platform/configuration/common/configurationService");
 const edit_1 = require("../../../platform/inlineEdits/common/dataTypes/edit");
@@ -60,12 +28,12 @@ const capturingToken_1 = require("../../../platform/requestLogger/common/capturi
 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"));
+const errors_1 = require("../../../util/common/errors");
 const result_1 = require("../../../util/common/result");
 const assert_1 = require("../../../util/vs/base/common/assert");
 const async_1 = require("../../../util/vs/base/common/async");
 const cache_1 = require("../../../util/vs/base/common/cache");
-const errors_1 = require("../../../util/vs/base/common/errors");
+const errors_2 = require("../../../util/vs/base/common/errors");
 const lifecycle_1 = require("../../../util/vs/base/common/lifecycle");
 const observable_2 = require("../../../util/vs/base/common/observable");
 const stopwatch_1 = require("../../../util/vs/base/common/stopwatch");
@@ -107,13 +75,22 @@ function convertLineEditToEdit(nextLineEdit, projectedDocuments, docId) {
     const suggestedEdit = rootedLineEdit.toEdit();
     return suggestedEdit;
 }
-let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
+var NesOutcome;
+(function (NesOutcome) {
+    NesOutcome["Accepted"] = "accepted";
+    NesOutcome["Rejected"] = "rejected";
+    NesOutcome["Ignored"] = "ignored";
+})(NesOutcome || (exports.NesOutcome = NesOutcome = {}));
+let NextEditProvider = NextEditProvider_1 = class NextEditProvider extends lifecycle_1.Disposable {
     get lastRejectionTime() {
         return this._lastRejectionTime;
     }
     get lastTriggerTime() {
         return this._lastTriggerTime;
     }
+    get lastOutcome() {
+        return this._lastOutcome;
+    }
     constructor(_workspace, _statelessNextEditProvider, _historyContextProvider, _xtabHistoryTracker, _debugRecorder, _configService, _snippyService, _logService, _expService, _requestLogger) {
         super();
         this._workspace = _workspace;
@@ -135,6 +112,14 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
          * This allows reusing the in-flight request when the user actually accepts the suggestion.
          */
         this._speculativePendingRequest = null;
+        /**
+         * A speculative request that is deferred until the originating stream completes.
+         * When a suggestion is shown while its stream is still running, we schedule the
+         * speculative request here instead of firing immediately. If more edits arrive
+         * from the stream, the schedule is cleared (the shown edit wasn't the last one).
+         * When the stream ends, if the schedule is still present, the speculative fires.
+         */
+        this._scheduledSpeculativeRequest = 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;
@@ -149,7 +134,21 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
             }));
         }).recomputeInitiallyAndOnChange(this._store);
     }
+    _cancelSpeculativeRequest() {
+        this._scheduledSpeculativeRequest = null;
+        if (this._speculativePendingRequest) {
+            this._speculativePendingRequest.request.cancellationTokenSource.cancel();
+            this._speculativePendingRequest = null;
+        }
+    }
     _cancelPendingRequestDueToDocChange(docId, docValue) {
+        // Note: we intentionally do NOT cancel the speculative request here.
+        // The speculative request's postEditContent represents a *future* document state
+        // (after the user would accept the suggestion), so it will almost never match the
+        // current document value while the user is still typing. Cancelling here would
+        // wastefully kill and recreate the speculative request on every keystroke.
+        // Instead, speculative requests are cancelled by the appropriate lifecycle handlers:
+        // handleRejection, handleIgnored, _triggerSpeculativeRequest, and _executeNewNextEditRequest.
         const isAsyncCompletions = this._configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsAsyncCompletions, this._expService);
         if (isAsyncCompletions || this._pendingStatelessNextEditRequest === null) {
             return;
@@ -175,7 +174,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         }
         catch (error) {
             logContext.setError(error);
-            telemetryBuilder.setNextEditProviderError(errors.toString(error));
+            telemetryBuilder.setNextEditProviderError(errors_1.ErrorUtils.toString(error));
             throw error;
         }
         finally {
@@ -190,7 +189,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         const doc = this._workspace.getDocument(docId);
         if (!doc) {
             logger.trace(`Document "${docId.baseName}" not found`);
-            throw new errors_1.BugIndicatingError(`Document "${docId.baseName}" not found`);
+            throw new errors_2.BugIndicatingError(`Document "${docId.baseName}" not found`);
         }
         const documentAtInvocationTime = doc.value.get();
         const selections = doc.selection.get();
@@ -210,6 +209,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         let targetDocumentId = docId;
         let isRebasedCachedEdit = false;
         let isSubsequentCachedEdit = false;
+        let isFromSpeculativeRequest = false;
         if (cachedEdit) {
             logger.trace('using cached edit');
             const actualEdit = cachedEdit.rebasedEdit || cachedEdit.edit;
@@ -232,7 +232,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
             const providerRequestStartDateTime = (this._configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsDebounceUseCoreRequestTime, this._expService)
                 ? (context.requestIssuedDateTime ?? undefined)
                 : undefined);
-            req = new NextEditFetchRequest(context.requestUuid, logContext, providerRequestStartDateTime);
+            req = new NextEditFetchRequest(context.requestUuid, logContext, providerRequestStartDateTime, false);
             telemetryBuilder.setHeaderRequestId(req.headerRequestId);
             const startVersion = doc.value.get();
             logger.trace('awaiting firstEdit promise');
@@ -266,6 +266,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
                         logger.trace('fetch succeeded');
                         logContext.setResponseResults([suggestedNextEdit]); // TODO: other streamed edits?
                         edit = { actualEdit: suggestedNextEdit, isFromCursorJump: result.val.isFromCursorJump };
+                        isFromSpeculativeRequest = result.val.isFromSpeculativeRequest ?? false;
                     }
                 }
             }
@@ -280,7 +281,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
             }
             else {
                 telemetryBuilder.setStatus('emptyEditsButHasNextCursorPosition');
-                return new nextEditResult_1.NextEditResult(logContext.requestId, req, { jumpToPosition: error.nextCursorPosition, documentBeforeEdits: documentAtInvocationTime, isFromCursorJump: false });
+                return new nextEditResult_1.NextEditResult(logContext.requestId, req, { jumpToPosition: error.nextCursorPosition, documentBeforeEdits: documentAtInvocationTime, isFromCursorJump: false, isSubsequentEdit: false });
             }
         }
         const emptyResult = new nextEditResult_1.NextEditResult(logContext.requestId, req, undefined);
@@ -303,9 +304,9 @@ 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 nextEditResult = new nextEditResult_1.NextEditResult(logContext.requestId, req, { edit: edit.actualEdit, isFromCursorJump: edit.isFromCursorJump, documentBeforeEdits: currentDocument, targetDocumentId });
+        const nextEditResult = new nextEditResult_1.NextEditResult(logContext.requestId, req, { edit: edit.actualEdit, isFromCursorJump: edit.isFromCursorJump, documentBeforeEdits: currentDocument, targetDocumentId, isSubsequentEdit: isSubsequentCachedEdit });
         telemetryBuilder.setHasNextEdit(true);
-        const delay = this.computeMinimumResponseDelay({ triggerTime, isRebasedCachedEdit, isSubsequentCachedEdit, enforceCacheDelay: context.enforceCacheDelay }, logger);
+        const delay = this.computeMinimumResponseDelay({ triggerTime, isRebasedCachedEdit, isSubsequentCachedEdit, isFromSpeculativeRequest, enforceCacheDelay: context.enforceCacheDelay }, logger);
         if (delay > 0) {
             await (0, async_1.timeout)(delay);
             if (cancellationToken.isCancellationRequested) {
@@ -356,7 +357,8 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         const existingNextEditRequest = (pendingRequestStillCurrent || nesConfigs.isAsyncCompletions) && !this._pendingStatelessNextEditRequest?.cancellationTokenSource.token.isCancellationRequested
             && this._pendingStatelessNextEditRequest || undefined;
         // Check if we can reuse the speculative pending request (from when a suggestion was shown)
-        const speculativeRequestMatches = this._speculativePendingRequest?.postEditContent === documentAtInvocationTime.value
+        const speculativeRequestMatches = this._speculativePendingRequest?.docId === curDocId
+            && 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)
@@ -371,9 +373,14 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
             const requestStillCurrent = speculativeRequest
                 ? speculativeRequestMatches // For speculative, we already checked it matches
                 : pendingRequestStillCurrent;
+            const reusedRequestKind = speculativeRequest ? "speculative" /* ReusedRequestKind.Speculative */ : "async" /* ReusedRequestKind.Async */;
             if (requestStillCurrent) {
-                const nextEditResult = await this._joinNextEditRequest(requestToReuse, telemetryBuilder, logContext, cancellationToken);
+                const nextEditResult = await this._joinNextEditRequest(requestToReuse, reusedRequestKind, telemetryBuilder, logContext, cancellationToken);
                 telemetryBuilder.setStatelessNextEditTelemetry(nextEditResult.telemetry);
+                if (speculativeRequest) {
+                    const firstEdit = await requestToReuse.firstEdit.p;
+                    return firstEdit.map(val => ({ ...val, isFromSpeculativeRequest: true }));
+                }
                 return nextEditResult.nextEdit.isError() ? nextEditResult.nextEdit : requestToReuse.firstEdit.p;
             }
             else if (nesConfigs.isEagerBackupRequest) {
@@ -391,7 +398,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
                         .catch(() => undefined);
                 };
                 // Simultaneously attempt to join + rebase the stale request
-                const nextEditResult = await this._joinNextEditRequest(requestToReuse, telemetryBuilder, logContext, cancellationToken);
+                const nextEditResult = await this._joinNextEditRequest(requestToReuse, reusedRequestKind, telemetryBuilder, logContext, cancellationToken);
                 const cacheResult = await requestToReuse.firstEdit.p;
                 if (cacheResult.isOk() && cacheResult.val.edit) {
                     const rebasedCachedEdit = this._nextEditCache.tryRebaseCacheEntry(cacheResult.val, documentAtInvocationTime, selectionAtInvocationTime);
@@ -415,7 +422,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
                 return backupRes.nextEditResult.nextEdit.isError() ? backupRes.nextEditResult.nextEdit : backupRes.nextEditRequest.firstEdit.p;
             }
             else {
-                const nextEditResult = await this._joinNextEditRequest(requestToReuse, telemetryBuilder, logContext, cancellationToken);
+                const nextEditResult = await this._joinNextEditRequest(requestToReuse, reusedRequestKind, telemetryBuilder, logContext, cancellationToken);
                 // Needs rebasing.
                 const cacheResult = await requestToReuse.firstEdit.p;
                 if (cacheResult.isOk() && cacheResult.val.edit) {
@@ -436,7 +443,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
                     && this._pendingStatelessNextEditRequest || undefined;
                 if (existingNextEditRequest2) {
                     logger.trace('reusing 2nd existing next edit request after rebase failed');
-                    const nextEditResult2 = await this._joinNextEditRequest(existingNextEditRequest2, telemetryBuilder, logContext, cancellationToken);
+                    const nextEditResult2 = await this._joinNextEditRequest(existingNextEditRequest2, "async" /* ReusedRequestKind.Async */, telemetryBuilder, logContext, cancellationToken);
                     telemetryBuilder.setStatelessNextEditTelemetry(nextEditResult2.telemetry);
                     return nextEditResult2.nextEdit.isError() ? nextEditResult2.nextEdit : existingNextEditRequest2.firstEdit.p;
                 }
@@ -449,10 +456,9 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         telemetryBuilder.setStatelessNextEditTelemetry(nextEditResult.telemetry);
         return nextEditResult.nextEdit.isError() ? nextEditResult.nextEdit : nextEditRequest.firstEdit.p;
     }
-    async _joinNextEditRequest(nextEditRequest, telemetryBuilder, logContext, cancellationToken) {
-        // TODO: Will the telemetry look alright in this case?
+    async _joinNextEditRequest(nextEditRequest, reusedRequestKind, telemetryBuilder, logContext, cancellationToken) {
         telemetryBuilder.setHeaderRequestId(nextEditRequest.headerRequestId);
-        telemetryBuilder.setIsFromCache();
+        telemetryBuilder.setReusedRequest(reusedRequestKind);
         telemetryBuilder.setRequest(nextEditRequest);
         logContext.setRequestInput(nextEditRequest);
         logContext.setIsCachedResult(nextEditRequest.logContext);
@@ -477,11 +483,23 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         const nLinesEditWindow = (shouldExpandEditWindow
             ? this._configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsAutoExpandEditWindowLines, this._expService)
             : undefined);
-        const nextEditRequest = new statelessNextEditProvider_1.StatelessNextEditRequest(req.headerRequestId, req.opportunityId, doc.value.get(), projectedDocuments.map(d => d.nextEditDoc), activeDocAndIdx.idx, xtabEditHistory, firstEdit, nLinesEditWindow, logContext, req.log.recordingBookmark, recording, req.providerRequestStartDateTime);
+        const nextEditRequest = new statelessNextEditProvider_1.StatelessNextEditRequest(req.headerRequestId, req.opportunityId, doc.value.get(), projectedDocuments.map(d => d.nextEditDoc), activeDocAndIdx.idx, xtabEditHistory, firstEdit, nLinesEditWindow, false, // isSpeculative
+        logContext, req.log.recordingBookmark, recording, req.providerRequestStartDateTime);
         let nextEditResult;
         if (this._pendingStatelessNextEditRequest) {
             this._pendingStatelessNextEditRequest.cancellationTokenSource.cancel();
             this._pendingStatelessNextEditRequest = null;
+            // Clear any scheduled (but not yet triggered) speculative request tied to the
+            // old stream — it would otherwise fire stale when the old stream's background
+            // loop calls handleStreamEnd after the stream has already been superseded.
+            this._scheduledSpeculativeRequest = null;
+        }
+        // Cancel speculative request if it doesn't match the document/state
+        // of this new request — it was built for a different document or post-edit state.
+        if (this._speculativePendingRequest
+            && (this._speculativePendingRequest.docId !== curDocId
+                || this._speculativePendingRequest.postEditContent !== nextEditRequest.documentBeforeEdits.value)) {
+            this._cancelSpeculativeRequest();
         }
         this._pendingStatelessNextEditRequest = nextEditRequest;
         const removeFromPending = () => {
@@ -514,7 +532,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         const statePerDoc = new cache_1.CachedFunction((id) => {
             const doc = projectedDocuments.find(d => d.nextEditDoc.id === id);
             if (!doc) {
-                throw new errors_1.BugIndicatingError();
+                throw new errors_2.BugIndicatingError();
             }
             return {
                 docContents: doc.documentAfterEdits,
@@ -596,6 +614,13 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
             nextEditRequest.setResult(result);
             disp.dispose();
             removeFromPending();
+            // Fire any scheduled speculative request — the last shown edit
+            // was indeed the last edit from this stream.
+            if (this._scheduledSpeculativeRequest?.headerRequestId === nextEditRequest.headerRequestId) {
+                const scheduled = this._scheduledSpeculativeRequest;
+                this._scheduledSpeculativeRequest = null;
+                void this._triggerSpeculativeRequest(scheduled.suggestion);
+            }
             return result;
         };
         try {
@@ -617,6 +642,11 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
                         while (!res.done) {
                             const streamedEdit = res.value.v;
                             processEdit(streamedEdit, res.value.telemetryBuilder);
+                            // A new edit arrived from the stream — the previously-shown
+                            // edit was not the last one. Clear the scheduled speculative.
+                            if (this._scheduledSpeculativeRequest?.headerRequestId === nextEditRequest.headerRequestId) {
+                                this._scheduledSpeculativeRequest = null;
+                            }
                             res = await editStream.next();
                         }
                         // Stream completed
@@ -624,8 +654,8 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
                         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));
+                        logger.trace(`Error while streaming further edits: ${errors_1.ErrorUtils.toString(err)}`);
+                        const errorReason = new statelessNextEditProvider_1.NoNextEditReason.Unexpected(errors_1.ErrorUtils.fromUnknown(err));
                         handleStreamEnd(errorReason, firstTelemetry);
                     }
                 })();
@@ -679,7 +709,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         nextEditRequest.liveDependentants++;
         return disposables;
     }
-    computeMinimumResponseDelay({ triggerTime, isRebasedCachedEdit, isSubsequentCachedEdit, enforceCacheDelay }, logger) {
+    computeMinimumResponseDelay({ triggerTime, isRebasedCachedEdit, isSubsequentCachedEdit, isFromSpeculativeRequest, enforceCacheDelay }, logger) {
         if (!enforceCacheDelay) {
             logger.trace('[minimumDelay] no minimum delay enforced due to enforceCacheDelay being false');
             return 0;
@@ -687,6 +717,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         const cacheDelay = this._configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsCacheDelay, this._expService);
         const rebasedCacheDelay = this._configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsRebasedCacheDelay, this._expService);
         const subsequentCacheDelay = this._configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsSubsequentCacheDelay, this._expService);
+        const speculativeRequestDelay = this._configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsSpeculativeRequestDelay, this._expService);
         let minimumResponseDelay = cacheDelay;
         if (isRebasedCachedEdit && rebasedCacheDelay !== undefined) {
             minimumResponseDelay = rebasedCacheDelay;
@@ -694,41 +725,64 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         else if (isSubsequentCachedEdit && subsequentCacheDelay !== undefined) {
             minimumResponseDelay = subsequentCacheDelay;
         }
+        else if (isFromSpeculativeRequest && speculativeRequestDelay !== undefined) {
+            minimumResponseDelay = speculativeRequestDelay;
+        }
         const nextEditProviderCallLatency = Date.now() - triggerTime;
         // if the provider call took longer than the minimum delay, we don't need to delay further
         const delay = Math.max(0, minimumResponseDelay - nextEditProviderCallLatency);
-        logger.trace(`[minimumDelay] expected delay: ${minimumResponseDelay}ms, effective delay: ${delay}. isRebasedCachedEdit: ${isRebasedCachedEdit} (rebasedCacheDelay: ${rebasedCacheDelay}), isSubsequentCachedEdit: ${isSubsequentCachedEdit} (subsequentCacheDelay: ${subsequentCacheDelay})`);
+        logger.trace(`[minimumDelay] expected delay: ${minimumResponseDelay}ms, effective delay: ${delay}. isRebasedCachedEdit: ${isRebasedCachedEdit} (rebasedCacheDelay: ${rebasedCacheDelay}), isSubsequentCachedEdit: ${isSubsequentCachedEdit} (subsequentCacheDelay: ${subsequentCacheDelay}), isFromSpeculativeRequest: ${isFromSpeculativeRequest} (speculativeRequestDelay: ${speculativeRequestDelay})`);
         return delay;
     }
     handleShown(suggestion) {
         this._lastShownTime = Date.now();
         this._lastShownSuggestionId = suggestion.requestId;
+        this._lastOutcome = undefined; // clear so that outcome is "pending" until resolved
+        this._scheduledSpeculativeRequest = null; // clear any previously scheduled speculative
         // 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);
+            // If the originating stream is still running, defer the speculative request
+            // until the stream completes. If more edits come from this stream, the
+            // schedule is cleared (the shown edit wasn't the last one). The speculative
+            // request only fires when the stream ends with the shown edit as the last one.
+            const originatingRequest = this._pendingStatelessNextEditRequest;
+            if (originatingRequest && originatingRequest.headerRequestId === suggestion.source.headerRequestId) {
+                this._scheduledSpeculativeRequest = {
+                    suggestion,
+                    headerRequestId: originatingRequest.headerRequestId,
+                };
+            }
+            else {
+                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;
         }
+        const logContext = new inlineEditLogContext_1.InlineEditRequestLogContext(docId.uri, 0, undefined);
+        const sw = new stopwatch_1.StopWatch();
+        const logger = this._logger.createSubLogger('_triggerSpeculativeRequest')
+            .withExtraTarget(logService_1.LogTarget.fromCallback((_level, msg) => {
+            logContext.trace(`[${Math.floor(sw.elapsed()).toString().padStart(4, ' ')}ms] ${msg}`);
+        }));
         // 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 preciseEdit = result.edit.removeCommonSuffixPrefix(result.documentBeforeEdits.value);
+        const postEditCursorOffset = preciseEdit.replaceRange.start + preciseEdit.newText.length;
+        const postEditCursorOffsetRange = new offsetRange_1.OffsetRange(postEditCursorOffset, postEditCursorOffset);
+        const selections = [postEditCursorOffsetRange];
         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;
+        let shiftedSelection = postEditCursorOffsetRange;
         if (cachedEdit) {
             // first cachedEdit should be without edits because of noSuggestions caching
             if (cachedEdit.edit) {
@@ -736,17 +790,22 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
                 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;
+                logger.trace('have cached no-suggestions entry for post-edit state, but it has an edit window. Checking if shifting selection based on cursor placement config can yield a cached edit');
+                const cursorPlacement = this._configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsSpeculativeRequestsCursorPlacement, this._expService);
+                if (cursorPlacement === xtabPromptOptions_1.SpeculativeRequestsCursorPlacement.AfterEditWindow) {
+                    logger.trace('cursor placement config is AfterEditWindow, shifting selection to after edit window');
+                    shiftedSelection = NextEditProvider_1.shiftSelectionAfterEditWindow(postEditContentST, cachedEdit.editWindow);
+                    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('no cached edit even after shifting selection');
+                    }
+                }
+                else {
+                    logger.trace(`cursor placement config is ${cursorPlacement}, not shifting selection`);
                 }
             }
             else {
@@ -760,7 +819,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
             return;
         }
         // Check if we already have a speculative request for this post-edit state
-        if (this._speculativePendingRequest?.postEditContent === postEditContent) {
+        if (this._speculativePendingRequest?.docId === docId && this._speculativePendingRequest?.postEditContent === postEditContent) {
             logger.trace('already have speculative request for post-edit state');
             return;
         }
@@ -773,30 +832,29 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
             return;
         }
         // Cancel any previous speculative request
-        this._speculativePendingRequest?.request.cancellationTokenSource.cancel();
-        this._speculativePendingRequest = null;
+        this._cancelSpeculativeRequest();
         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})`);
+        const req = new NextEditFetchRequest(`sp-${suggestion.source.opportunityId}`, logContext, undefined, true, `sp-${(0, uuid_1.generateUuid)()}`);
         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);
+            const speculativeRequest = await this._createSpeculativeRequest(req, doc, shiftedSelection, historyContext, postEditContent, rootedEdit, result.edit, {
+                triggeredBySpeculativeRequest: suggestion.source.isSpeculative,
+                isSubsequentEdit: suggestion.result?.isSubsequentEdit ?? false,
+            }, logger);
             if (speculativeRequest) {
                 this._speculativePendingRequest = {
                     request: speculativeRequest,
+                    docId,
                     postEditContent,
                 };
             }
         }
         catch (e) {
-            logger.trace(`speculative request failed: ${errors.toString(e)}`);
+            logger.trace(`speculative request failed: ${errors_1.ErrorUtils.toString(e)}`);
         }
     }
     /**
@@ -804,11 +862,12 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
      * 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');
+    async _createSpeculativeRequest(req, doc, shiftedSelection, historyContext, postEditContent, rootedEdit, appliedEdit, { triggeredBySpeculativeRequest, isSubsequentEdit }, parentLogger) {
         const curDocId = doc.id;
         const recording = this._debugRecorder?.getRecentLog();
         const logContext = req.log;
+        logContext.setStatelessNextEditProviderId(this._statelessNextEditProvider.ID);
+        const logger = parentLogger.createSubLogger('_createSpeculativeRequest');
         const activeDocAndIdx = historyContext.getDocumentAndIdx(curDocId);
         if (!activeDocAndIdx) {
             logger.trace('active doc not found in history context');
@@ -827,18 +886,11 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
                 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);
+                shiftedSelection);
                 return {
                     recentEdit: new edit_1.RootedEdit(doc.value.get(), postEditEdit),
                     nextEditDoc,
@@ -850,15 +902,43 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         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);
+        // FIXME@ulugbekna: implement advanced expansion
+        const autoExpandEditWindowLinesSetting = this._configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsSpeculativeRequestsAutoExpandEditWindowLines, this._expService);
+        let nLinesEditWindow;
+        switch (autoExpandEditWindowLinesSetting) {
+            case xtabPromptOptions_1.SpeculativeRequestsAutoExpandEditWindowLines.Off:
+                nLinesEditWindow = undefined;
+                break;
+            case xtabPromptOptions_1.SpeculativeRequestsAutoExpandEditWindowLines.Always:
+                nLinesEditWindow = this._configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsAutoExpandEditWindowLines, this._expService);
+                break;
+            case xtabPromptOptions_1.SpeculativeRequestsAutoExpandEditWindowLines.Smart: {
+                const isModelOnRightTrack = triggeredBySpeculativeRequest || isSubsequentEdit;
+                nLinesEditWindow = (isModelOnRightTrack
+                    ? this._configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsAutoExpandEditWindowLines, this._expService)
+                    : undefined);
+                break;
+            }
+            default:
+                (0, assert_1.assertNever)(autoExpandEditWindowLinesSetting);
+        }
         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
+        projectedDocuments.map(d => d.nextEditDoc), activeDocAndIdx.idx, xtabEditHistory, firstEdit, nLinesEditWindow, true, // isSpeculative
+        logContext, undefined, // recordingBookmark
         recording, undefined);
+        logContext.setRequestInput(nextEditRequest);
         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));
+        const label = `NES | spec | ${(0, path_1.basename)(doc.id.toUri().fsPath)} (v${doc.version.get()})`;
+        const capturingToken = new capturingToken_1.CapturingToken(label, undefined, false, true);
+        void this._requestLogger.captureInvocation(capturingToken, async () => {
+            try {
+                await this._runSpeculativeProviderCall(nextEditRequest, projectedDocuments, curDocId, req, logger);
+            }
+            finally {
+                this._addLogContextEntry(logContext, label);
+            }
+        });
         return nextEditRequest;
     }
     /**
@@ -869,7 +949,7 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         const statePerDoc = new cache_1.CachedFunction((id) => {
             const doc = projectedDocuments.find(d => d.nextEditDoc.id === id);
             if (!doc) {
-                throw new errors_1.BugIndicatingError();
+                throw new errors_2.BugIndicatingError();
             }
             return {
                 docContents: doc.documentAfterEdits,
@@ -929,12 +1009,23 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
             logger.trace(`speculative request completed with ${ithEdit + 1} edits`);
         }
         catch (e) {
-            logger.trace(`speculative provider call error: ${errors.toString(e)}`);
+            logger.trace(`speculative provider call error: ${errors_1.ErrorUtils.toString(e)}`);
         }
     }
+    static shiftSelectionAfterEditWindow(postEditContentST, editWindowOffsetRange) {
+        const trans = postEditContentST.getTransformer();
+        const endOfEditWindow = trans.getPosition(editWindowOffsetRange.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));
+        const shiftedSelection = new offsetRange_1.OffsetRange(shiftedSelectionCursorOffset, shiftedSelectionCursorOffset);
+        return shiftedSelection;
+    }
     handleAcceptance(docId, suggestion) {
         this.runSnippy(docId, suggestion);
         this._statelessNextEditProvider.handleAcceptance?.();
+        this._lastOutcome = NesOutcome.Accepted;
         const logger = this._logger.createSubLogger(suggestion.source.opportunityId.substring(4, 8)).createSubLogger('handleAcceptance');
         if (suggestion === this._lastNextEditResult) {
             logger.trace('setting shouldExpandEditWindow to true due to acceptance of last suggestion');
@@ -946,6 +1037,10 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
     }
     handleRejection(docId, suggestion) {
         (0, types_1.assertType)(suggestion.result, '@ulugbekna: undefined edit cannot be rejected?');
+        // The user rejected the suggestion, so the speculative request (which
+        // predicted the post-accept state) will never be reused. Cancel it to
+        // avoid wasting a server slot.
+        this._cancelSpeculativeRequest();
         const shownDuration = Date.now() - this._lastShownTime;
         if (shownDuration > 1000 && suggestion.result.edit) {
             // we can argue that the user had the time to review this
@@ -954,14 +1049,18 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
             this._nextEditCache.rejectedNextEdit(suggestion.source.headerRequestId);
         }
         this._lastRejectionTime = Date.now();
+        this._lastOutcome = NesOutcome.Rejected;
         this._statelessNextEditProvider.handleRejection?.();
     }
     handleIgnored(docId, suggestion, supersededBy) {
+        this._lastOutcome = NesOutcome.Ignored;
         // 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
+            // The shown suggestion was dismissed (not superseded by a new one),
+            // so the speculative request for its post-accept state is useless.
+            this._cancelSpeculativeRequest();
             this._statelessNextEditProvider.handleIgnored?.();
         }
     }
@@ -971,13 +1070,25 @@ let NextEditProvider = class NextEditProvider extends lifecycle_1.Disposable {
         }
         this._snippyService.handlePostInsertion(docId.toUri(), suggestion.result.documentBeforeEdits, suggestion.result.edit);
     }
+    _addLogContextEntry(logContext, debugNameOverride) {
+        if (!logContext.includeInLogTree) {
+            return;
+        }
+        this._requestLogger.addEntry({
+            type: "MarkdownContentRequest" /* LoggedRequestKind.MarkdownContentRequest */,
+            debugName: debugNameOverride ?? logContext.getDebugName(),
+            icon: logContext.getIcon(),
+            startTimeMs: logContext.time,
+            markdownContent: logContext.toLogDocument(),
+        });
+    }
     clearCache() {
         this._nextEditCache.clear();
         this._rejectionCollector.clear();
     }
 };
 exports.NextEditProvider = NextEditProvider;
-exports.NextEditProvider = NextEditProvider = __decorate([
+exports.NextEditProvider = NextEditProvider = NextEditProvider_1 = __decorate([
     __param(5, configurationService_1.IConfigurationService),
     __param(6, snippyService_1.ISnippyService),
     __param(7, logService_1.ILogService),
@@ -986,15 +1097,16 @@ exports.NextEditProvider = NextEditProvider = __decorate([
 ], NextEditProvider);
 function assertDefined(value) {
     if (!value) {
-        throw new errors_1.BugIndicatingError('expected value to be defined, but it was not');
+        throw new errors_2.BugIndicatingError('expected value to be defined, but it was not');
     }
     return value;
 }
 class NextEditFetchRequest {
-    constructor(opportunityId, log, providerRequestStartDateTime, headerRequestId = (0, uuid_1.generateUuid)()) {
+    constructor(opportunityId, log, providerRequestStartDateTime, isSpeculative, headerRequestId = (0, uuid_1.generateUuid)()) {
         this.opportunityId = opportunityId;
         this.log = log;
         this.providerRequestStartDateTime = providerRequestStartDateTime;
+        this.isSpeculative = isSpeculative;
         this.headerRequestId = headerRequestId;
     }
 }