@vscode/chat-lib 0.44.1 → 0.45.2026041705

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

@@ -79,6 +79,7 @@ const nullExperimentationService_1 = require("../../../platform/telemetry/common
 const workspaceService_1 = require("../../../platform/workspace/common/workspaceService");
 const async_1 = require("../../../util/common/async");
 const asyncIterableUtils_1 = require("../../../util/common/asyncIterableUtils");
+const backwardCompatSetting_1 = require("../../../util/common/backwardCompatSetting");
 const errors_1 = require("../../../util/common/errors");
 const result_1 = require("../../../util/common/result");
 const assert_1 = require("../../../util/vs/base/common/assert");
@@ -94,11 +95,13 @@ const range_1 = require("../../../util/vs/editor/common/core/range");
 const lineRange_1 = require("../../../util/vs/editor/common/core/ranges/lineRange");
 const offsetRange_1 = require("../../../util/vs/editor/common/core/ranges/offsetRange");
 const abstractText_1 = require("../../../util/vs/editor/common/core/text/abstractText");
+const positionToOffset_1 = require("../../../util/vs/editor/common/core/text/positionToOffset");
 const instantiation_1 = require("../../../util/vs/platform/instantiation/common/instantiation");
 const vscodeTypesShim_1 = require("../../../util/common/test/shims/vscodeTypesShim");
 const nearbyCursorInlineEditProvider_1 = require("../../inlineEdits/common/nearbyCursorInlineEditProvider");
 const userInteractionMonitor_1 = require("../../inlineEdits/common/userInteractionMonitor");
 const importFiltering_1 = require("../../inlineEdits/node/importFiltering");
+const fetchStreamError_1 = require("../common/fetchStreamError");
 const inlineSuggestion_1 = require("../common/inlineSuggestion");
 const lintErrors_1 = require("../common/lintErrors");
 const promptCrafting_1 = require("../common/promptCrafting");
@@ -139,9 +142,8 @@ var RetryState;
 var FetchResult;
 (function (FetchResult) {
     class Lines {
-        constructor(linesStream, getFetchFailure, getResponseSoFar, fetchRequestStopWatch) {
+        constructor(linesStream, getResponseSoFar, fetchRequestStopWatch) {
             this.linesStream = linesStream;
-            this.getFetchFailure = getFetchFailure;
             this.getResponseSoFar = getResponseSoFar;
             this.fetchRequestStopWatch = fetchRequestStopWatch;
         }
@@ -533,7 +535,6 @@ let XtabProvider = class XtabProvider {
         const fetchStreamSource = new chatMLFetcher_1.FetchStreamSource();
         const fetchRequestStopWatch = new stopwatch_1.StopWatch();
         let responseSoFar = '';
-        let chatResponseFailure;
         let ttft;
         const firstTokenReceived = new async_2.DeferredPromise();
         logContext.setHeaderRequestId(requestId);
@@ -577,20 +578,23 @@ let XtabProvider = class XtabProvider {
         logContext.setFullResponse(fetchResultPromise.then((response) => response.type === commonTypes_1.ChatFetchResponseType.Success ? response.value : undefined));
         fetchResultPromise
             .then((response) => {
-            // this's a way to signal the edit-pushing code to know if the request failed and
-            // 	it shouldn't push edits constructed from an erroneous response
-            chatResponseFailure = response.type !== commonTypes_1.ChatFetchResponseType.Success ? response : undefined;
+            if (response.type !== commonTypes_1.ChatFetchResponseType.Success) {
+                fetchStreamSource.reject(new fetchStreamError_1.FetchStreamError(mapChatFetcherErrorToNoNextEditReason(response)));
+            }
+            else {
+                fetchStreamSource.resolve();
+            }
         })
             .catch((err) => {
             // in principle this shouldn't happen because ChatMLFetcher's fetchOne should not throw
             logContext.setError(errors_1.ErrorUtils.fromUnknown(err));
             logContext.addLog(`ChatMLFetcher fetch call threw -- this's UNEXPECTED!`);
+            fetchStreamSource.reject(errors_1.ErrorUtils.fromUnknown(err));
         }).finally(() => {
             logContext.setFetchEndTime();
             if (!firstTokenReceived.isSettled) {
                 firstTokenReceived.complete();
             }
-            fetchStreamSource.resolve();
             logContext.setResponse(responseSoFar);
         });
         const fetchRes = await Promise.race([firstTokenReceived.p, fetchResultPromise]);
@@ -607,7 +611,6 @@ let XtabProvider = class XtabProvider {
             }
             return new FetchResult.FetchFailure(mapChatFetcherErrorToNoNextEditReason(fetchRes));
         }
-        const getFetchFailure = () => chatResponseFailure ? mapChatFetcherErrorToNoNextEditReason(chatResponseFailure) : undefined;
         const llmLinesStream = asyncIterableUtils_1.AsyncIterUtilsExt.splitLines(asyncIterableUtils_1.AsyncIterUtils.map(fetchStreamSource.stream, (chunk) => chunk.delta.text));
         // logging of times
         // removal of cursor tag if option is set
@@ -621,7 +624,7 @@ let XtabProvider = class XtabProvider {
                     : v;
             }
         })();
-        return new FetchResult.Lines(linesStream, getFetchFailure, () => responseSoFar, fetchRequestStopWatch);
+        return new FetchResult.Lines(linesStream, () => responseSoFar, fetchRequestStopWatch);
     }
     async *_streamEditsImpl(request, editStreamCtx, responseOpts, fetchMetadata, retryState, delaySession, tracing, cancellationToken, fetchCts, fetchCancellationToken) {
         const { tracer, logContext, telemetry } = tracing;
@@ -636,130 +639,112 @@ let XtabProvider = class XtabProvider {
         if (fetchResult instanceof FetchResult.FetchFailure) {
             return fetchResult.reason;
         }
-        const { linesStream, getFetchFailure, getResponseSoFar, fetchRequestStopWatch } = fetchResult;
+        const { linesStream, getResponseSoFar, fetchRequestStopWatch } = fetchResult;
         // Phase 2: Dispatch to the appropriate response format handler
         const isFromCursorJump = retryState instanceof RetryState.Retrying && retryState.reason === 'cursorJump';
         let parseResult;
-        switch (responseOpts.responseFormat) {
-            case xtabPromptOptions.ResponseFormat.EditWindowOnly: {
-                parseResult = (0, responseFormatHandlers_1.handleEditWindowOnly)(linesStream);
-                break;
-            }
-            case xtabPromptOptions.ResponseFormat.CodeBlock: {
-                parseResult = (0, responseFormatHandlers_1.handleCodeBlock)(linesStream);
-                break;
-            }
-            case xtabPromptOptions.ResponseFormat.EditWindowWithEditIntent:
-            case xtabPromptOptions.ResponseFormat.EditWindowWithEditIntentShort: {
-                const parseMode = responseOpts.responseFormat === xtabPromptOptions.ResponseFormat.EditWindowWithEditIntentShort
-                    ? editIntent_1.EditIntentParseMode.ShortName
-                    : editIntent_1.EditIntentParseMode.Tags;
-                parseResult = await (0, responseFormatHandlers_1.handleEditWindowWithEditIntent)(linesStream, tracer, parseMode, getFetchFailure);
-                break;
-            }
-            case xtabPromptOptions.ResponseFormat.CustomDiffPatch: {
-                const activeDoc = request.getActiveDocument();
-                const currentDocument = promptPieces.currentDocument;
-                const lastLine = currentDocument.lines[clippedTaggedCurrentDoc.keptRange.endExclusive - 1];
-                const lastLineLength = lastLine.length;
-                const pseudoEditWindow = currentDocument.transformer.getOffsetRange(new range_1.Range(clippedTaggedCurrentDoc.keptRange.start + 1, 1, clippedTaggedCurrentDoc.keptRange.endExclusive, lastLineLength + 1));
-                parseResult = new responseFormatHandlers_1.ResponseParseResult.DirectEdits(xtabCustomDiffPatchResponseHandler_1.XtabCustomDiffPatchResponseHandler.handleResponse(linesStream, currentDocument, activeDoc.id, activeDoc.workspaceRoot, pseudoEditWindow, tracer, getFetchFailure));
-                break;
+        try {
+            switch (responseOpts.responseFormat) {
+                case xtabPromptOptions.ResponseFormat.EditWindowOnly: {
+                    parseResult = (0, responseFormatHandlers_1.handleEditWindowOnly)(linesStream);
+                    break;
+                }
+                case xtabPromptOptions.ResponseFormat.CodeBlock: {
+                    parseResult = (0, responseFormatHandlers_1.handleCodeBlock)(linesStream);
+                    break;
+                }
+                case xtabPromptOptions.ResponseFormat.EditWindowWithEditIntent:
+                case xtabPromptOptions.ResponseFormat.EditWindowWithEditIntentShort: {
+                    const parseMode = responseOpts.responseFormat === xtabPromptOptions.ResponseFormat.EditWindowWithEditIntentShort
+                        ? editIntent_1.EditIntentParseMode.ShortName
+                        : editIntent_1.EditIntentParseMode.Tags;
+                    parseResult = await (0, responseFormatHandlers_1.handleEditWindowWithEditIntent)(linesStream, tracer, parseMode);
+                    break;
+                }
+                case xtabPromptOptions.ResponseFormat.CustomDiffPatch: {
+                    const activeDoc = request.getActiveDocument();
+                    const currentDocument = promptPieces.currentDocument;
+                    const lastLine = currentDocument.lines[clippedTaggedCurrentDoc.keptRange.endExclusive - 1];
+                    const lastLineLength = lastLine.length;
+                    const pseudoEditWindow = currentDocument.transformer.getOffsetRange(new range_1.Range(clippedTaggedCurrentDoc.keptRange.start + 1, 1, clippedTaggedCurrentDoc.keptRange.endExclusive, lastLineLength + 1));
+                    parseResult = new responseFormatHandlers_1.ResponseParseResult.DirectEdits(xtabCustomDiffPatchResponseHandler_1.XtabCustomDiffPatchResponseHandler.handleResponse(linesStream, currentDocument, activeDoc.id, activeDoc.workspaceRoot, pseudoEditWindow, tracer));
+                    break;
+                }
+                case xtabPromptOptions.ResponseFormat.UnifiedWithXml: {
+                    parseResult = await (0, responseFormatHandlers_1.handleUnifiedWithXml)(linesStream, {
+                        editWindowLines,
+                        editWindowLineRange,
+                        cursorOriginalLinesOffset,
+                        cursorColumnZeroBased: promptPieces.currentDocument.cursorPosition.column - 1,
+                        editWindow,
+                        originalEditWindow,
+                        targetDocument,
+                        isFromCursorJump,
+                    }, request.documentBeforeEdits, tracer);
+                    break;
+                }
+                default:
+                    (0, assert_1.assertNever)(responseOpts.responseFormat);
             }
-            case xtabPromptOptions.ResponseFormat.UnifiedWithXml: {
-                parseResult = await (0, responseFormatHandlers_1.handleUnifiedWithXml)(linesStream, {
-                    editWindowLines,
-                    editWindowLineRange,
-                    cursorOriginalLinesOffset,
-                    cursorColumnZeroBased: promptPieces.currentDocument.cursorPosition.column - 1,
-                    editWindow,
-                    originalEditWindow,
-                    targetDocument,
-                    isFromCursorJump,
-                }, request.documentBeforeEdits, tracer, getFetchFailure);
-                break;
+            // Handle result uniformly
+            if (parseResult instanceof responseFormatHandlers_1.ResponseParseResult.Done) {
+                return parseResult.reason;
             }
-            default:
-                (0, assert_1.assertNever)(responseOpts.responseFormat);
-        }
-        // Handle result uniformly
-        if (parseResult instanceof responseFormatHandlers_1.ResponseParseResult.Done) {
-            return parseResult.reason;
-        }
-        if (parseResult instanceof responseFormatHandlers_1.ResponseParseResult.DirectEdits) {
-            return yield* parseResult.stream;
-        }
-        // parseResult is EditWindowLines — log edit-intent telemetry and apply aggressiveness filter
-        if (parseResult.editIntentMetadata) {
-            const { intent, parseError } = parseResult.editIntentMetadata;
-            telemetry.setEditIntent(intent);
-            if (parseError) {
-                telemetry.setEditIntentParseError(parseError);
+            if (parseResult instanceof responseFormatHandlers_1.ResponseParseResult.DirectEdits) {
+                return yield* parseResult.stream;
             }
-            if (!xtabPromptOptions.EditIntent.shouldShowEdit(intent, promptPieces.aggressivenessLevel)) {
-                tracer.trace(`Filtered out edit due to edit intent "${intent}" with aggressiveness "${promptPieces.aggressivenessLevel}"`);
-                return new statelessNextEditProvider_1.NoNextEditReason.FilteredOut(`editIntent:${intent} aggressivenessLevel:${promptPieces.aggressivenessLevel}`);
+            // parseResult is EditWindowLines — log edit-intent telemetry and apply aggressiveness filter
+            if (parseResult.editIntentMetadata) {
+                const { intent, parseError } = parseResult.editIntentMetadata;
+                telemetry.setEditIntent(intent);
+                if (parseError) {
+                    telemetry.setEditIntentParseError(parseError);
+                }
+                if (!xtabPromptOptions.EditIntent.shouldShowEdit(intent, promptPieces.aggressivenessLevel)) {
+                    tracer.trace(`Filtered out edit due to edit intent "${intent}" with aggressiveness "${promptPieces.aggressivenessLevel}"`);
+                    return new statelessNextEditProvider_1.NoNextEditReason.FilteredOut(`editIntent:${intent} aggressivenessLevel:${promptPieces.aggressivenessLevel}`);
+                }
             }
-        }
-        const cleanedLinesStream = parseResult.lines;
-        const diffOptions = {
-            emitFastCursorLineChange: responseProcessor_1.ResponseProcessor.mapEmitFastCursorLineChange(this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderEmitFastCursorLineChange, this.expService)),
-            nLinesToConverge: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabNNonSignificantLinesToConverge, this.expService),
-            nSignificantLinesToConverge: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabNSignificantLinesToConverge, this.expService),
-        };
-        tracer.trace(`starting to diff stream against edit window lines with latency ${fetchRequestStopWatch.elapsed()} ms`);
-        // Wrap the line stream to detect early cursor-line divergence.
-        // If the user has typed at the cursor since the request started and the cursor line
-        // in the model's response doesn't match what the user currently has, the response
-        // is stale and we can cancel early instead of waiting for the full response.
-        //
-        // We check compatibility using `isModelCursorLineCompatible`: the user's
-        // cursor-line change must be contained within the model's cursor-line change range
-        // and match via the helper's `startsWith` / auto-close subsequence rules.
-        const earlyCursorLineDivergenceCancellation = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabEarlyCursorLineDivergenceCancellation, this.expService);
-        let cursorLineDiverged = false;
-        const divergenceCheckedStream = earlyCursorLineDivergenceCancellation
-            ? (async function* () {
-                let lineIdx = 0;
-                for await (const line of cleanedLinesStream) {
-                    if (lineIdx === cursorOriginalLinesOffset) {
-                        const intermediateEdit = request.intermediateUserEdit;
-                        if (intermediateEdit && !intermediateEdit.isEmpty()) {
-                            const cursorDocLineIdx = editWindowLineRange.start + cursorOriginalLinesOffset;
-                            const currentCursorLine = (0, cursorLineDivergence_1.getCurrentCursorLine)(request.documentBeforeEdits.getTransformer(), cursorDocLineIdx, intermediateEdit);
-                            if (currentCursorLine !== undefined) {
-                                const originalCursorLine = editWindowLines[cursorOriginalLinesOffset];
-                                if (currentCursorLine !== originalCursorLine // user changed the cursor line
-                                    && !(0, cursorLineDivergence_1.isModelCursorLineCompatible)(originalCursorLine, currentCursorLine, line) // model's cursor line isn't compatible with user's typing
-                                ) {
-                                    cursorLineDiverged = true;
-                                    tracer.trace(`Cursor line DIVERGED: model="${line}" current="${currentCursorLine}"`);
-                                    // Cancel our local fetch token so the HTTP request is
-                                    // aborted immediately. We own this token, so this is safe.
-                                    fetchCts.cancel();
-                                    return;
-                                }
-                            }
-                        }
-                    }
-                    yield line;
-                    lineIdx++;
+            const cleanedLinesStream = parseResult.lines;
+            const diffOptions = {
+                emitFastCursorLineChange: responseProcessor_1.ResponseProcessor.mapEmitFastCursorLineChange(this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderEmitFastCursorLineChange, this.expService)),
+                nLinesToConverge: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabNNonSignificantLinesToConverge, this.expService),
+                nSignificantLinesToConverge: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabNSignificantLinesToConverge, this.expService),
+            };
+            tracer.trace(`starting to diff stream against edit window lines with latency ${fetchRequestStopWatch.elapsed()} ms`);
+            // Wrap the line stream to detect early divergence between the user's
+            // intermediate edits and the model's streamed output.
+            // In `Cursor` mode only the cursor line is checked; in `EditWindow`
+            // mode every line in the edit window is checked.
+            //
+            // We check compatibility using `isModelLineCompatible`: the user's
+            // line change must be contained within the model's line change range
+            // and match via the helper's `startsWith` / auto-close subsequence rules.
+            const earlyDivergenceMode = (0, backwardCompatSetting_1.backwardCompatSetting)(this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabEarlyCursorLineDivergenceCancellation, this.expService), (value) => {
+                switch (value) {
+                    case false:
+                    case undefined:
+                        return xtabPromptOptions_1.EarlyDivergenceCancellationMode.Off;
+                    case true:
+                        return xtabPromptOptions_1.EarlyDivergenceCancellationMode.Cursor;
+                    case xtabPromptOptions_1.EarlyDivergenceCancellationMode.Off:
+                    case xtabPromptOptions_1.EarlyDivergenceCancellationMode.Cursor:
+                    case xtabPromptOptions_1.EarlyDivergenceCancellationMode.EditWindow:
+                        return value;
+                    default:
+                        return xtabPromptOptions_1.EarlyDivergenceCancellationMode.Off;
                 }
-            })()
-            : cleanedLinesStream;
-        let i = 0;
-        let hasBeenDelayed = false;
-        try {
+            });
+            let lineDiverged = false;
+            const divergenceCheckedStream = earlyDivergenceMode === xtabPromptOptions_1.EarlyDivergenceCancellationMode.Off
+                ? cleanedLinesStream
+                : linesWithIntermediateEditDivergenceCheck(cleanedLinesStream, cursorOriginalLinesOffset, request, editWindowLineRange, editWindowLines, fetchCts, tracing, (value) => { lineDiverged = value; }, earlyDivergenceMode);
+            let i = 0;
+            let hasBeenDelayed = false;
             for await (const edit of responseProcessor_1.ResponseProcessor.diff(editWindowLines, divergenceCheckedStream, cursorOriginalLinesOffset, diffOptions)) {
-                if (cursorLineDiverged) {
+                if (lineDiverged) {
                     break;
                 }
-                {
-                    const fetchFailure = getFetchFailure();
-                    if (fetchFailure) {
-                        return fetchFailure;
-                    }
-                }
                 tracer.trace(`ResponseProcessor streamed edit #${i} with latency ${fetchRequestStopWatch.elapsed()} ms`);
                 const singleLineEdits = [];
                 if (edit.lineRange.startLineNumber === edit.lineRange.endLineNumberExclusive || // we don't want to run diff on insertion
@@ -801,20 +786,16 @@ let XtabProvider = class XtabProvider {
                     i++;
                 }
             }
-            if (cursorLineDiverged) {
-                return new statelessNextEditProvider_1.NoNextEditReason.GotCancelled('cursorLineDiverged');
-            }
-            {
-                const fetchFailure = getFetchFailure();
-                if (fetchFailure) {
-                    return fetchFailure;
-                }
+            if (lineDiverged) {
+                return new statelessNextEditProvider_1.NoNextEditReason.GotCancelled(earlyDivergenceMode === xtabPromptOptions_1.EarlyDivergenceCancellationMode.Cursor ? 'cursorLineDiverged' : 'editWindowLineDiverged');
             }
             return new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow);
         }
         catch (err) {
+            if (err instanceof fetchStreamError_1.FetchStreamError) {
+                return err.reason;
+            }
             logContext.setError(err);
-            // Properly handle the error by pushing it as a result
             return new statelessNextEditProvider_1.NoNextEditReason.Unexpected(errors_1.ErrorUtils.fromUnknown(err));
         }
     }
@@ -1291,4 +1272,49 @@ function getPredictionContents(doc, editWindowLines, responseFormat) {
         (0, assert_1.assertNever)(responseFormat);
     }
 }
+async function* linesWithIntermediateEditDivergenceCheck(cleanedLinesStream, cursorOriginalLinesOffset, request, editWindowLineRange, editWindowLines, fetchCts, { tracer }, setLineDiverged, mode) {
+    const intermediateEdit = request.intermediateUserEdit;
+    if (!intermediateEdit || intermediateEdit.isEmpty()) {
+        yield* cleanedLinesStream;
+        return;
+    }
+    const transformer = request.documentBeforeEdits.getTransformer();
+    // Precompute the post-edit document once to avoid O(lines * docSize) in EditWindow mode.
+    const currentDoc = intermediateEdit.apply(transformer.text);
+    const currentTransformer = new positionToOffset_1.PositionOffsetTransformer(currentDoc);
+    const precomputed = { currentDoc, currentTransformer };
+    const shouldCheckLine = (lineIdx) => {
+        if (lineIdx >= editWindowLines.length) {
+            return false;
+        }
+        switch (mode) {
+            case xtabPromptOptions_1.EarlyDivergenceCancellationMode.Cursor:
+                return lineIdx === cursorOriginalLinesOffset;
+            case xtabPromptOptions_1.EarlyDivergenceCancellationMode.EditWindow:
+                return true;
+        }
+    };
+    let lineIdx = 0;
+    for await (const line of cleanedLinesStream) {
+        if (shouldCheckLine(lineIdx)) {
+            const docLineIdx = editWindowLineRange.start + lineIdx;
+            const currentLine = (0, cursorLineDivergence_1.getCurrentLine)(transformer, docLineIdx, intermediateEdit, precomputed);
+            if (currentLine !== undefined) {
+                const originalLine = editWindowLines[lineIdx];
+                if (currentLine !== originalLine // user changed this line
+                    && !(0, cursorLineDivergence_1.isModelLineCompatible)(originalLine, currentLine, line) // model's line isn't compatible with user's typing
+                ) {
+                    setLineDiverged(true);
+                    tracer.trace(`Line ${lineIdx} DIVERGED (mode=${mode}): model="${line}" current="${currentLine}"`);
+                    // Cancel our local fetch token so the HTTP request is
+                    // aborted immediately. We own this token, so this is safe.
+                    fetchCts.cancel();
+                    return;
+                }
+            }
+        }
+        yield line;
+        lineIdx++;
+    }
+}
 //# sourceMappingURL=xtabProvider.js.map