@vscode/chat-lib 0.1.2-0 → 0.1.2

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

@@ -49,10 +49,15 @@ var XtabProvider_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.XtabProvider = void 0;
 exports.findMergeConflictMarkersRange = findMergeConflictMarkersRange;
+const copilot_api_1 = require("@vscode/copilot-api");
+const prompt_tsx_1 = require("@vscode/prompt-tsx");
+const rawTypes_1 = require("@vscode/prompt-tsx/dist/base/output/rawTypes");
 const chatMLFetcher_1 = require("../../../platform/chat/common/chatMLFetcher");
 const commonTypes_1 = require("../../../platform/chat/common/commonTypes");
+const globalStringUtils_1 = require("../../../platform/chat/common/globalStringUtils");
 const configurationService_1 = require("../../../platform/configuration/common/configurationService");
 const diffService_1 = require("../../../platform/diff/common/diffService");
+const chatEndpoint_1 = require("../../../platform/endpoint/node/chatEndpoint");
 const proxyXtabEndpoint_1 = require("../../../platform/endpoint/node/proxyXtabEndpoint");
 const ignoreService_1 = require("../../../platform/ignore/common/ignoreService");
 const nextCursorLinePrediction_1 = require("../../../platform/inlineEdits/common/dataTypes/nextCursorLinePrediction");
@@ -63,6 +68,7 @@ const statelessNextEditProviders_1 = require("../../../platform/inlineEdits/comm
 const languageContextProviderService_1 = require("../../../platform/languageContextProvider/common/languageContextProviderService");
 const languageDiagnosticsService_1 = require("../../../platform/languages/common/languageDiagnosticsService");
 const languageContextService_1 = require("../../../platform/languageServer/common/languageContextService");
+const logService_1 = require("../../../platform/log/common/logService");
 const simulationTestContext_1 = require("../../../platform/simulationTestContext/common/simulationTestContext");
 const nullExperimentationService_1 = require("../../../platform/telemetry/common/nullExperimentationService");
 const telemetry_1 = require("../../../platform/telemetry/common/telemetry");
@@ -70,10 +76,14 @@ const workspaceService_1 = require("../../../platform/workspace/common/workspace
 const async_1 = require("../../../util/common/async");
 const errors = __importStar(require("../../../util/common/errors"));
 const result_1 = require("../../../util/common/result");
+const tokenizer_1 = require("../../../util/common/tokenizer");
+const tracing_1 = require("../../../util/common/tracing");
 const assert_1 = require("../../../util/vs/base/common/assert");
 const async_2 = require("../../../util/vs/base/common/async");
+const cancellation_1 = require("../../../util/vs/base/common/cancellation");
 const stopwatch_1 = require("../../../util/vs/base/common/stopwatch");
 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 range_1 = require("../../../util/vs/editor/common/core/range");
 const lineRange_1 = require("../../../util/vs/editor/common/core/ranges/lineRange");
@@ -88,19 +98,33 @@ const systemMessages_1 = require("../common/systemMessages");
 const tags_1 = require("../common/tags");
 const xtabCurrentDocument_1 = require("../common/xtabCurrentDocument");
 const xtabEndpoint_1 = require("./xtabEndpoint");
-const xtabNextCursorPredictor_1 = require("./xtabNextCursorPredictor");
 const xtabUtils_1 = require("./xtabUtils");
+var ResponseTags;
+(function (ResponseTags) {
+    ResponseTags.NO_CHANGE = {
+        start: '<NO_CHANGE>'
+    };
+    ResponseTags.EDIT = {
+        start: '<EDIT>',
+        end: '</EDIT>'
+    };
+    ResponseTags.INSERT = {
+        start: '<INSERT>',
+        end: '</INSERT>'
+    };
+})(ResponseTags || (ResponseTags = {}));
 let XtabProvider = class XtabProvider {
     static { XtabProvider_1 = this; }
     static { this.ID = configurationService_1.XTabProviderId; }
     static { this.computeTokens = (s) => Math.floor(s.length / 4); }
-    constructor(simulationCtx, instaService, workspaceService, diffService, configService, expService, langCtxService, langDiagService, ignoreService, telemetryService) {
+    constructor(simulationCtx, instaService, workspaceService, diffService, configService, expService, logService, langCtxService, langDiagService, ignoreService, telemetryService) {
         this.simulationCtx = simulationCtx;
         this.instaService = instaService;
         this.workspaceService = workspaceService;
         this.diffService = diffService;
         this.configService = configService;
         this.expService = expService;
+        this.logService = logService;
         this.langCtxService = langCtxService;
         this.langDiagService = langDiagService;
         this.ignoreService = ignoreService;
@@ -110,7 +134,7 @@ let XtabProvider = class XtabProvider {
         this.showNextEditPreference = "always" /* ShowNextEditPreference.Always */;
         this.forceUseDefaultModel = false;
         this.delayer = new delayer_1.Delayer(this.configService, this.expService);
-        this.nextCursorPredictor = this.instaService.createInstance(xtabNextCursorPredictor_1.XtabNextCursorPredictor, XtabProvider_1.computeTokens);
+        this.tracer = (0, tracing_1.createTracer)(['NES', 'XtabProvider'], (s) => this.logService.trace(s));
     }
     handleAcceptance() {
         this.delayer.handleAcceptance();
@@ -118,7 +142,7 @@ let XtabProvider = class XtabProvider {
     handleRejection() {
         this.delayer.handleRejection();
     }
-    provideNextEdit(request, pushEdit, tracer, logContext, cancellationToken) {
+    provideNextEdit(request, pushEdit, logContext, cancellationToken) {
         const filteringPushEdit = (result) => {
             if (result.isError()) {
                 pushEdit(result);
@@ -131,7 +155,7 @@ let XtabProvider = class XtabProvider {
             }
             pushEdit(result);
         };
-        return this._provideNextEdit(request, filteringPushEdit, tracer, logContext, cancellationToken);
+        return this._provideNextEdit(request, filteringPushEdit, logContext, cancellationToken);
     }
     filterEdit(activeDoc, edits) {
         const filters = [
@@ -141,7 +165,7 @@ let XtabProvider = class XtabProvider {
         if (!this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.InlineEditsAllowWhitespaceOnlyChanges, this.expService)) {
             filters.push((edits) => statelessNextEditProviders_1.IgnoreWhitespaceOnlyChanges.filterEdit(activeDoc, edits));
         }
-        const undoInsertionFiltering = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsUndoInsertionFiltering, this.expService);
+        const undoInsertionFiltering = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsUndoInsertionFiltering, this.expService);
         if (undoInsertionFiltering !== undefined) {
             let filter;
             switch (undoInsertionFiltering) {
@@ -158,7 +182,7 @@ let XtabProvider = class XtabProvider {
         }
         return filters.reduce((acc, filter) => filter(acc), edits);
     }
-    async _provideNextEdit(request, pushEdit, tracer, logContext, cancellationToken) {
+    async _provideNextEdit(request, pushEdit, logContext, cancellationToken) {
         const telemetry = new statelessNextEditProvider_1.StatelessNextEditTelemetryBuilder(request);
         logContext.setProviderStartTime();
         try {
@@ -166,10 +190,13 @@ let XtabProvider = class XtabProvider {
                 return statelessNextEditProvider_1.StatelessNextEditResult.noEdit(new statelessNextEditProvider_1.NoNextEditReason.ActiveDocumentHasNoEdits(), telemetry);
             }
             const delaySession = this.delayer.createDelaySession(request.providerRequestStartDateTime);
-            const nextEditResult = await this.doGetNextEdit(request, pushEdit, delaySession, tracer, logContext, cancellationToken, telemetry, 0 /* RetryState.NotRetrying */);
+            const nextEditResult = await this.doGetNextEdit(request, pushEdit, delaySession, logContext, cancellationToken, telemetry, 0 /* RetryState.NotRetrying */);
             if (nextEditResult.isError() && nextEditResult.err instanceof statelessNextEditProvider_1.NoNextEditReason.GotCancelled) {
                 logContext.setIsSkipped();
             }
+            if (nextEditResult.isOk()) {
+                await this.enforceArtificialDelay(delaySession, telemetry);
+            }
             return new statelessNextEditProvider_1.StatelessNextEditResult(nextEditResult, telemetry.build(nextEditResult));
         }
         catch (err) {
@@ -179,11 +206,11 @@ let XtabProvider = class XtabProvider {
             logContext.setProviderEndTime();
         }
     }
-    async doGetNextEdit(request, pushEdit, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, retryState) {
-        return this.doGetNextEditWithSelection(request, (0, nearbyCursorInlineEditProvider_1.getOrDeduceSelectionFromLastEdit)(request.getActiveDocument()), pushEdit, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, retryState);
+    async doGetNextEdit(request, pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, retryState) {
+        return this.doGetNextEditWithSelection(request, (0, nearbyCursorInlineEditProvider_1.getOrDeduceSelectionFromLastEdit)(request.getActiveDocument()), pushEdit, delaySession, { showLabel: false }, logContext, cancellationToken, telemetryBuilder, retryState);
     }
-    async doGetNextEditWithSelection(request, selection, pushEdit, delaySession, parentTracer, logContext, cancellationToken, telemetryBuilder, retryState) {
-        const tracer = parentTracer.sub(['XtabProvider', 'doGetNextEditWithSelection']);
+    async doGetNextEditWithSelection(request, selection, pushEdit, delaySession, opts, logContext, cancellationToken, telemetryBuilder, retryState) {
+        const tracer = this.tracer.sub('doGetNextEditWithSelection');
         const activeDocument = request.getActiveDocument();
         if (selection === null) {
             return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.Uncategorized(new Error('NoSelection')));
@@ -195,36 +222,31 @@ let XtabProvider = class XtabProvider {
         const cursorPosition = new position_1.Position(selection.endLineNumber, selection.endColumn);
         const currentDocument = new xtabCurrentDocument_1.CurrentDocument(activeDocument.documentAfterEdits, cursorPosition);
         const cursorLine = currentDocument.lines[currentDocument.cursorLineOffset];
-        // check if there's any non-whitespace character after the cursor in the line
-        const isCursorAtEndOfLine = cursorLine.substring(cursorPosition.column - 1).match(/^\s*$/) !== null;
+        const isCursorAtEndOfLine = cursorPosition.column === cursorLine.trimEnd().length;
         if (isCursorAtEndOfLine) {
-            tracer.trace('Debouncing for cursor at end of line');
-            delaySession.setExtraDebounce(this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsExtraDebounceEndOfLine, this.expService));
-        }
-        else {
-            tracer.trace('Debouncing for cursor NOT at end of line');
+            delaySession.setExtraDebounce(this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsExtraDebounceEndOfLine, this.expService));
         }
         telemetryBuilder.setIsCursorAtLineEnd(isCursorAtEndOfLine);
         const areaAroundEditWindowLinesRange = this.computeAreaAroundEditWindowLinesRange(currentDocument);
-        const editWindowLinesRange = this.computeEditWindowLinesRange(currentDocument, request, retryState, tracer, telemetryBuilder);
+        const editWindowLinesRange = this.computeEditWindowLinesRange(currentDocument, request, retryState, telemetryBuilder);
         const cursorOriginalLinesOffset = Math.max(0, currentDocument.cursorLineOffset - editWindowLinesRange.start);
         const editWindowLastLineLength = currentDocument.transformer.getLineLength(editWindowLinesRange.endExclusive);
         const editWindow = currentDocument.transformer.getOffsetRange(new range_1.Range(editWindowLinesRange.start + 1, 1, editWindowLinesRange.endExclusive, editWindowLastLineLength + 1));
         const editWindowLines = currentDocument.lines.slice(editWindowLinesRange.start, editWindowLinesRange.endExclusive);
-        const editWindowTokenLimit = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabEditWindowMaxTokens, this.expService);
+        const editWindowTokenLimit = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabEditWindowMaxTokens, this.expService);
         if (editWindowTokenLimit !== undefined && (0, promptCrafting_1.countTokensForLines)(editWindowLines, XtabProvider_1.computeTokens) > editWindowTokenLimit) {
             return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.PromptTooLarge('editWindow'));
         }
         // Expected: editWindow.substring(activeDocument.documentAfterEdits.value) === editWindowLines.join('\n')
         const doesIncludeCursorTag = editWindowLines.some(line => line.includes(tags_1.PromptTags.CURSOR));
         const shouldRemoveCursorTagFromResponse = !doesIncludeCursorTag; // we'd like to remove the tag only if the original edit-window didn't include the tag
-        const taggedCurrentFileContentResult = (0, promptCrafting_1.constructTaggedFile)(currentDocument, editWindowLinesRange, areaAroundEditWindowLinesRange, promptOptions, XtabProvider_1.computeTokens, { includeLineNumbers: { areaAroundCodeToEdit: false, currentFileContent: false } });
+        const taggedCurrentFileContentResult = this.constructTaggedFile(currentDocument, editWindowLinesRange, areaAroundEditWindowLinesRange, promptOptions, XtabProvider_1.computeTokens, { includeLineNumbers: false });
         if (taggedCurrentFileContentResult.isError()) {
             return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.PromptTooLarge('currentFile'));
         }
         const { taggedCurrentDocLines, areaAroundCodeToEdit } = taggedCurrentFileContentResult.val;
         telemetryBuilder.setNLinesOfCurrentFileInPrompt(taggedCurrentDocLines.length);
-        const langCtx = await this.getAndProcessLanguageContext(request, delaySession, activeDocument, cursorPosition, promptOptions, tracer, logContext, cancellationToken);
+        const langCtx = await this.getAndProcessLanguageContext(request, delaySession, activeDocument, cursorPosition, promptOptions, logContext, cancellationToken);
         if (cancellationToken.isCancellationRequested) {
             return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.GotCancelled('afterLanguageContextAwait'));
         }
@@ -232,37 +254,78 @@ let XtabProvider = class XtabProvider {
         const userPrompt = (0, promptCrafting_1.getUserPrompt)(promptPieces);
         const responseFormat = xtabPromptOptions.ResponseFormat.fromPromptingStrategy(promptOptions.promptingStrategy);
         const prediction = this.getPredictedOutput(editWindowLines, responseFormat);
-        const messages = (0, xtabUtils_1.constructMessages)({
+        const messages = constructMessages({
             systemMsg: this.pickSystemPrompt(promptOptions.promptingStrategy),
             userMsg: userPrompt,
         });
         logContext.setPrompt(messages);
         telemetryBuilder.setPrompt(messages);
         const HARD_CHAR_LIMIT = 30000 * 4; // 30K tokens, assuming 4 chars per token -- we use approximation here because counting tokens exactly is time-consuming
-        const promptCharCount = (0, xtabUtils_1.charCount)(messages);
+        const promptCharCount = charCount(messages);
         if (promptCharCount > HARD_CHAR_LIMIT) {
             return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.PromptTooLarge('final'));
         }
-        await this.debounce(delaySession, tracer, telemetryBuilder);
+        await this.debounce(delaySession, telemetryBuilder);
         if (cancellationToken.isCancellationRequested) {
             return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.GotCancelled('afterDebounce'));
         }
         request.fetchIssued = true;
         const cursorLineOffset = cursorPosition.column;
         this.streamEdits(request, pushEdit, endpoint, messages, editWindow, editWindowLines, cursorOriginalLinesOffset, cursorLineOffset, editWindowLinesRange, promptPieces, prediction, {
+            showLabel: opts.showLabel,
             shouldRemoveCursorTagFromResponse,
             responseFormat,
             retryState,
         }, delaySession, tracer, telemetryBuilder, logContext, cancellationToken);
         return result_1.Result.ok(undefined);
     }
-    getAndProcessLanguageContext(request, delaySession, activeDocument, cursorPosition, promptOptions, tracer, logContext, cancellationToken) {
-        const recordingEnabled = this.configService.getConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsLogContextRecorderEnabled);
-        const diagnosticsContextProviderEnabled = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Advanced.DiagnosticsContextProvider, this.expService);
-        if (!promptOptions.languageContext.enabled && !recordingEnabled && !diagnosticsContextProviderEnabled) {
+    constructTaggedFile(currentDocument, editWindowLinesRange, areaAroundEditWindowLinesRange, promptOptions, computeTokens, opts) {
+        const contentWithCursorAsLinesOriginal = (() => {
+            const addCursorTagEdit = stringEdit_1.StringEdit.single(stringEdit_1.StringReplacement.insert(currentDocument.cursorOffset, tags_1.PromptTags.CURSOR));
+            const contentWithCursor = addCursorTagEdit.applyOnText(currentDocument.content);
+            return contentWithCursor.getLines();
+        })();
+        const addLineNumbers = (lines) => lines.map((line, idx) => `${idx}| ${line}`);
+        const contentWithCursorAsLines = opts.includeLineNumbers
+            ? addLineNumbers(contentWithCursorAsLinesOriginal)
+            : contentWithCursorAsLinesOriginal;
+        const editWindowWithCursorAsLines = contentWithCursorAsLines.slice(editWindowLinesRange.start, editWindowLinesRange.endExclusive);
+        const areaAroundCodeToEdit = [
+            tags_1.PromptTags.AREA_AROUND.start,
+            ...contentWithCursorAsLines.slice(areaAroundEditWindowLinesRange.start, editWindowLinesRange.start),
+            tags_1.PromptTags.EDIT_WINDOW.start,
+            ...editWindowWithCursorAsLines,
+            tags_1.PromptTags.EDIT_WINDOW.end,
+            ...contentWithCursorAsLines.slice(editWindowLinesRange.endExclusive, areaAroundEditWindowLinesRange.endExclusive),
+            tags_1.PromptTags.AREA_AROUND.end
+        ].join('\n');
+        const currentFileContentLines = opts.includeLineNumbers
+            ? addLineNumbers(currentDocument.lines)
+            : currentDocument.lines;
+        let areaAroundCodeToEditForCurrentFile;
+        if (promptOptions.currentFile.includeTags) {
+            areaAroundCodeToEditForCurrentFile = areaAroundCodeToEdit;
+        }
+        else {
+            const editWindowLines = currentFileContentLines.slice(editWindowLinesRange.start, editWindowLinesRange.endExclusive);
+            areaAroundCodeToEditForCurrentFile = [
+                ...contentWithCursorAsLines.slice(areaAroundEditWindowLinesRange.start, editWindowLinesRange.start),
+                ...editWindowLines,
+                ...contentWithCursorAsLines.slice(editWindowLinesRange.endExclusive, areaAroundEditWindowLinesRange.endExclusive),
+            ].join('\n');
+        }
+        const taggedCurrentFileContentResult = (0, promptCrafting_1.createTaggedCurrentFileContentUsingPagedClipping)(currentFileContentLines, areaAroundCodeToEditForCurrentFile, areaAroundEditWindowLinesRange, computeTokens, promptOptions.pagedClipping.pageSize, promptOptions.currentFile);
+        return taggedCurrentFileContentResult.map(taggedCurrentDocLines => ({
+            taggedCurrentDocLines,
+            areaAroundCodeToEdit,
+        }));
+    }
+    getAndProcessLanguageContext(request, delaySession, activeDocument, cursorPosition, promptOptions, logContext, cancellationToken) {
+        const recordingEnabled = this.configService.getConfig(configurationService_1.ConfigKey.Internal.InlineEditsLogContextRecorderEnabled);
+        if (!promptOptions.languageContext.enabled && !recordingEnabled) {
             return Promise.resolve(undefined);
         }
-        const langCtxPromise = this.getLanguageContext(request, delaySession, activeDocument, cursorPosition, tracer, logContext, cancellationToken);
+        const langCtxPromise = this.getLanguageContext(request, delaySession, activeDocument, cursorPosition, logContext, cancellationToken);
         // if recording, add diagnostics for the file to the recording and hook up the language context promise to write to the recording
         if (recordingEnabled) {
             logContext.setFileDiagnostics(this.langDiagService.getAllDiagnostics());
@@ -276,13 +339,13 @@ let XtabProvider = class XtabProvider {
             ? langCtxPromise
             : Promise.resolve(undefined);
     }
-    async getLanguageContext(request, delaySession, activeDocument, cursorPosition, tracer, logContext, cancellationToken) {
+    async getLanguageContext(request, delaySession, activeDocument, cursorPosition, logContext, cancellationToken) {
         try {
             const textDoc = this.workspaceService.textDocuments.find(doc => doc.uri.toString() === activeDocument.id.uri);
             if (textDoc === undefined) {
                 return undefined;
             }
-            const providers = this.langCtxService.getContextProviders(textDoc, languageContextProviderService_1.ProviderTarget.NES);
+            const providers = this.langCtxService.getContextProviders(textDoc);
             if (providers.length < 1) {
                 return undefined;
             }
@@ -295,8 +358,7 @@ let XtabProvider = class XtabProvider {
                     uri: textDoc.uri.toString(),
                     languageId: textDoc.languageId,
                     version: textDoc.version,
-                    offset: textDoc.offsetAt(cursorPositionVscode),
-                    position: cursorPositionVscode
+                    offset: textDoc.offsetAt(cursorPositionVscode)
                 },
                 activeExperiments: new Map(),
                 timeBudget: debounceTime,
@@ -334,7 +396,7 @@ let XtabProvider = class XtabProvider {
         }
         catch (error) {
             logContext.setError(errors.fromUnknown(error));
-            tracer.trace(`Failed to fetch language context: ${error}`);
+            this.tracer.trace(`Failed to fetch language context: ${error}`);
             return undefined;
         }
     }
@@ -388,7 +450,7 @@ let XtabProvider = class XtabProvider {
                 !this.forceUseDefaultModel // if we haven't already forced using the default model; otherwise, this could cause an infinite loop
             ) {
                 this.forceUseDefaultModel = true;
-                return this.doGetNextEdit(request, pushEdit, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, opts.retryState); // use the same retry state
+                return this.doGetNextEdit(request, pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, opts.retryState); // use the same retry state
             }
             pushEdit(result_1.Result.error(XtabProvider_1.mapChatFetcherErrorToNoNextEditReason(fetchRes)));
             return;
@@ -420,6 +482,7 @@ let XtabProvider = class XtabProvider {
             let i = 0;
             return llmLinesStream.map((v) => {
                 const trace = `Line ${i++} emitted with latency ${fetchRequestStopWatch.elapsed()} ms`;
+                logContext.addLog(trace);
                 tracer.trace(trace);
                 return opts.shouldRemoveCursorTagFromResponse
                     ? v.replaceAll(tags_1.PromptTags.CURSOR, '')
@@ -442,13 +505,13 @@ let XtabProvider = class XtabProvider {
                 return;
             }
             const trimmedLines = firstLine.value.trim();
-            if (trimmedLines === tags_1.ResponseTags.NO_CHANGE.start) {
-                await this.pushNoSuggestionsOrRetry(request, editWindow, promptPieces, pushEdit, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, opts.retryState);
+            if (trimmedLines === ResponseTags.NO_CHANGE.start) {
+                await this.pushNoSuggestionsOrRetry(request, editWindow, promptPieces, pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, opts.retryState);
                 return;
             }
-            if (trimmedLines === tags_1.ResponseTags.INSERT.start) {
+            if (trimmedLines === ResponseTags.INSERT.start) {
                 const lineWithCursorContinued = await linesIter.next();
-                if (lineWithCursorContinued.done || lineWithCursorContinued.value.includes(tags_1.ResponseTags.INSERT.end)) {
+                if (lineWithCursorContinued.done || lineWithCursorContinued.value.includes(ResponseTags.INSERT.end)) {
                     pushEdit(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow)));
                     return;
                 }
@@ -457,7 +520,7 @@ let XtabProvider = class XtabProvider {
                 const lines = [];
                 let v = await linesIter.next();
                 while (!v.done) {
-                    if (v.value.includes(tags_1.ResponseTags.INSERT.end)) {
+                    if (v.value.includes(ResponseTags.INSERT.end)) {
                         break;
                     }
                     else {
@@ -473,11 +536,11 @@ let XtabProvider = class XtabProvider {
                 pushEdit(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow)));
                 return;
             }
-            if (trimmedLines === tags_1.ResponseTags.EDIT.start) {
+            if (trimmedLines === ResponseTags.EDIT.start) {
                 cleanedLinesStream = new async_2.AsyncIterableObject(async (emitter) => {
                     let v = await linesIter.next();
                     while (!v.done) {
-                        if (v.value.includes(tags_1.ResponseTags.EDIT.end)) {
+                        if (v.value.includes(ResponseTags.EDIT.end)) {
                             return;
                         }
                         emitter.emitOne(v.value);
@@ -497,17 +560,17 @@ let XtabProvider = class XtabProvider {
             (0, assert_1.assertNever)(opts.responseFormat);
         }
         const diffOptions = {
-            emitFastCursorLineChange: 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),
+            emitFastCursorLineChange: opts.showLabel
+                ? false
+                : this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderEmitFastCursorLineChange, this.expService),
+            nLinesToConverge: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabNNonSignificantLinesToConverge, this.expService),
+            nSignificantLinesToConverge: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabNSignificantLinesToConverge, this.expService),
         };
-        tracer.trace(`starting to diff stream against edit window lines with latency ${fetchRequestStopWatch.elapsed()} ms`);
         (async () => {
             let i = 0;
             let hasBeenDelayed = false;
             try {
                 for await (const edit of responseProcessor_1.ResponseProcessor.diff(editWindowLines, cleanedLinesStream, cursorOriginalLinesOffset, diffOptions)) {
-                    tracer.trace(`ResponseProcessor streamed edit #${i} with latency ${fetchRequestStopWatch.elapsed()} ms`);
                     const singleLineEdits = [];
                     if (edit.lineRange.startLineNumber === edit.lineRange.endLineNumberExclusive || // we don't want to run diff on insertion
                         edit.newLines.length === 0 || // we don't want to run diff on deletion
@@ -523,7 +586,6 @@ let XtabProvider = class XtabProvider {
                             maxComputationTimeMs: 0,
                             computeMoves: false
                         });
-                        tracer.trace(`Ran diff for #${i} with latency ${fetchRequestStopWatch.elapsed()} ms`);
                         const translateByNLines = editWindowLineRange.start + edit.lineRange.startLineNumber;
                         for (const change of diffResult.changes) {
                             const singleLineEdit = new lineEdit_1.LineReplacement(new lineRange_1.LineRange(translateByNLines + change.original.startLineNumber - 1, translateByNLines + change.original.endLineNumberExclusive - 1), edit.newLines.slice(change.modified.startLineNumber - 1, change.modified.endLineNumberExclusive - 1));
@@ -535,20 +597,12 @@ let XtabProvider = class XtabProvider {
                     }
                     logContext.setResponse(responseSoFar);
                     for (const singleLineEdit of singleLineEdits) {
-                        tracer.trace(`pushing edit #${i}:\n${singleLineEdit.toString()}`);
+                        this.trace(`pushing edit #${i}:\n${singleLineEdit.toString()}`, logContext, tracer);
                         if (!hasBeenDelayed) { // delay only the first one
                             hasBeenDelayed = true;
-                            const artificialDelay = this.determineArtificialDelayMs(delaySession, tracer, telemetryBuilder);
-                            if (artificialDelay) {
-                                await (0, async_2.timeout)(artificialDelay);
-                                tracer.trace(`Artificial delay of ${artificialDelay} ms completed`);
-                                if (cancellationToken.isCancellationRequested) {
-                                    pushEdit(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.GotCancelled('afterArtificialDelay')));
-                                    return;
-                                }
-                            }
+                            await this.enforceArtificialDelay(delaySession, telemetryBuilder);
                         }
-                        pushEdit(result_1.Result.ok({ edit: singleLineEdit, window: editWindow }));
+                        pushEdit(result_1.Result.ok({ edit: singleLineEdit, window: editWindow, showLabel: opts.showLabel }));
                         i++;
                     }
                 }
@@ -561,7 +615,7 @@ let XtabProvider = class XtabProvider {
                     pushEdit(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow)));
                 }
                 else {
-                    await this.pushNoSuggestionsOrRetry(request, editWindow, promptPieces, pushEdit, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, opts.retryState);
+                    await this.pushNoSuggestionsOrRetry(request, editWindow, promptPieces, pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, opts.retryState);
                 }
             }
             catch (err) {
@@ -571,35 +625,37 @@ let XtabProvider = class XtabProvider {
             }
         })();
     }
-    async pushNoSuggestionsOrRetry(request, editWindow, promptPieces, pushEdit, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, retryState) {
-        const allowRetryWithExpandedWindow = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderRetryWithNMoreLinesBelow, this.expService);
+    async pushNoSuggestionsOrRetry(request, editWindow, promptPieces, pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, retryState) {
+        const allowRetryWithExpandedWindow = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderRetryWithNMoreLinesBelow, this.expService);
         // if allowed to retry and not retrying already, flip the retry state and try again
         if (allowRetryWithExpandedWindow && retryState === 0 /* RetryState.NotRetrying */ && request.expandedEditWindowNLines === undefined) {
-            this.doGetNextEdit(request, pushEdit, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, 1 /* RetryState.Retrying */);
+            this.doGetNextEdit(request, pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, 1 /* RetryState.Retrying */);
             return;
         }
-        const nextCursorLinePrediction = this.nextCursorPredictor.determineEnablement();
+        let nextCursorLinePrediction = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsNextCursorPredictionEnabled, this.expService);
+        nextCursorLinePrediction = (nextCursorLinePrediction === true ? nextCursorLinePrediction_1.NextCursorLinePrediction.OnlyWithEdit :
+            (nextCursorLinePrediction === false ? undefined : nextCursorLinePrediction));
         if (nextCursorLinePrediction !== undefined && retryState === 0 /* RetryState.NotRetrying */) {
-            const nextCursorLineR = await this.nextCursorPredictor.predictNextCursorPosition(promptPieces, tracer);
+            const nextCursorLineR = await this.predictNextCursorPosition(promptPieces);
             if (cancellationToken.isCancellationRequested) {
                 pushEdit(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow)));
                 return;
             }
             if (nextCursorLineR.isError()) {
-                tracer.trace(`Predicted next cursor line error: ${nextCursorLineR.err.message}`);
+                this.tracer.trace(`Predicted next cursor line error: ${nextCursorLineR.err.message}`);
                 telemetryBuilder.setNextCursorLineError(nextCursorLineR.err.message);
             }
             else {
                 const nextCursorLineZeroBased = nextCursorLineR.val;
                 const lineDistanceFromCursorLine = nextCursorLineZeroBased - promptPieces.currentDocument.cursorLineOffset;
                 telemetryBuilder.setNextCursorLineDistance(lineDistanceFromCursorLine);
-                tracer.trace(`Predicted next cursor line: ${nextCursorLineZeroBased}`);
+                this.tracer.trace(`Predicted next cursor line: ${nextCursorLineZeroBased}`);
                 if (nextCursorLineZeroBased >= promptPieces.currentDocument.lines.length) { // >= because the line index is zero-based
-                    tracer.trace(`Predicted next cursor line error: exceedsDocumentLines`);
+                    this.tracer.trace(`Predicted next cursor line error: exceedsDocumentLines`);
                     telemetryBuilder.setNextCursorLineError('exceedsDocumentLines');
                 }
                 else if (promptPieces.editWindowLinesRange.contains(nextCursorLineZeroBased)) {
-                    tracer.trace(`Predicted next cursor line error: withinEditWindow`);
+                    this.tracer.trace(`Predicted next cursor line error: withinEditWindow`);
                     telemetryBuilder.setNextCursorLineError('withinEditWindow');
                 }
                 else {
@@ -614,7 +670,7 @@ let XtabProvider = class XtabProvider {
                         }
                         case nextCursorLinePrediction_1.NextCursorLinePrediction.OnlyWithEdit:
                         case nextCursorLinePrediction_1.NextCursorLinePrediction.LabelOnlyWithEdit: {
-                            this.doGetNextEditWithSelection(request, new range_1.Range(nextCursorLineOneBased, nextCursorColumn, nextCursorLineOneBased, nextCursorColumn), pushEdit, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, 1 /* RetryState.Retrying */);
+                            this.doGetNextEditWithSelection(request, new range_1.Range(nextCursorLineOneBased, nextCursorColumn, nextCursorLineOneBased, nextCursorColumn), pushEdit, delaySession, { showLabel: nextCursorLinePrediction === nextCursorLinePrediction_1.NextCursorLinePrediction.LabelOnlyWithEdit }, logContext, cancellationToken, telemetryBuilder, 1 /* RetryState.Retrying */);
                             return;
                         }
                         default: {
@@ -633,12 +689,12 @@ let XtabProvider = class XtabProvider {
         const areaAroundEndExcl = Math.min(currentDocument.lines.length, cursorLine + promptCrafting_1.N_LINES_AS_CONTEXT + 1);
         return new offsetRange_1.OffsetRange(areaAroundStart, areaAroundEndExcl);
     }
-    computeEditWindowLinesRange(currentDocument, request, retryState, tracer, telemetry) {
+    computeEditWindowLinesRange(currentDocument, request, retryState, telemetry) {
         const currentDocLines = currentDocument.lines;
         const cursorLineOffset = currentDocument.cursorLineOffset;
         let nLinesAbove;
         {
-            const useVaryingLinesAbove = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderUseVaryingLinesAbove, this.expService);
+            const useVaryingLinesAbove = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderUseVaryingLinesAbove, this.expService);
             if (useVaryingLinesAbove) {
                 nLinesAbove = 0; // default
                 for (let i = 0; i < 8; ++i) {
@@ -653,45 +709,45 @@ let XtabProvider = class XtabProvider {
                 }
             }
             else {
-                nLinesAbove = (this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderNLinesAbove, this.expService)
+                nLinesAbove = (this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderNLinesAbove, this.expService)
                     ?? promptCrafting_1.N_LINES_ABOVE);
             }
         }
         let nLinesBelow;
         if (request.expandedEditWindowNLines !== undefined) {
-            tracer.trace(`Using expanded nLinesBelow: ${request.expandedEditWindowNLines}`);
+            this.tracer.trace(`Using expanded nLinesBelow: ${request.expandedEditWindowNLines}`);
             nLinesBelow = request.expandedEditWindowNLines;
         }
         else {
-            const overriddenNLinesBelow = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderNLinesBelow, this.expService);
+            const overriddenNLinesBelow = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderNLinesBelow, this.expService);
             if (overriddenNLinesBelow !== undefined) {
-                tracer.trace(`Using overridden nLinesBelow: ${overriddenNLinesBelow}`);
+                this.tracer.trace(`Using overridden nLinesBelow: ${overriddenNLinesBelow}`);
                 nLinesBelow = overriddenNLinesBelow;
             }
             else {
-                tracer.trace(`Using default nLinesBelow: ${promptCrafting_1.N_LINES_BELOW}`);
+                this.tracer.trace(`Using default nLinesBelow: ${promptCrafting_1.N_LINES_BELOW}`);
                 nLinesBelow = promptCrafting_1.N_LINES_BELOW; // default
             }
         }
         if (retryState === 1 /* RetryState.Retrying */) {
-            nLinesBelow += this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderRetryWithNMoreLinesBelow, this.expService) ?? 0;
+            nLinesBelow += this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderRetryWithNMoreLinesBelow, this.expService) ?? 0;
         }
         let codeToEditStart = Math.max(0, cursorLineOffset - nLinesAbove);
         let codeToEditEndExcl = Math.min(currentDocLines.length, cursorLineOffset + nLinesBelow + 1);
-        const maxMergeConflictLines = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabMaxMergeConflictLines, this.expService);
+        const maxMergeConflictLines = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabMaxMergeConflictLines, this.expService);
         if (maxMergeConflictLines) {
             const tentativeEditWindow = new offsetRange_1.OffsetRange(codeToEditStart, codeToEditEndExcl);
             const mergeConflictRange = findMergeConflictMarkersRange(currentDocLines, tentativeEditWindow, maxMergeConflictLines);
             if (mergeConflictRange) {
-                const onlyMergeConflictLines = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabOnlyMergeConflictLines, this.expService);
+                const onlyMergeConflictLines = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabOnlyMergeConflictLines, this.expService);
                 telemetry.setMergeConflictExpanded(onlyMergeConflictLines ? 'only' : 'normal');
                 if (onlyMergeConflictLines) {
-                    tracer.trace(`Expanding edit window to include ONLY merge conflict markers: ${mergeConflictRange.toString()}`);
+                    this.tracer.trace(`Expanding edit window to include ONLY merge conflict markers: ${mergeConflictRange.toString()}`);
                     codeToEditStart = mergeConflictRange.start;
                     codeToEditEndExcl = mergeConflictRange.endExclusive;
                 }
                 else {
-                    tracer.trace(`Expanding edit window to include merge conflict markers: ${mergeConflictRange.toString()}; edit window range [${codeToEditStart}, ${codeToEditEndExcl})`);
+                    this.tracer.trace(`Expanding edit window to include merge conflict markers: ${mergeConflictRange.toString()}; edit window range [${codeToEditStart}, ${codeToEditEndExcl})`);
                     codeToEditEndExcl = Math.max(codeToEditEndExcl, mergeConflictRange.endExclusive);
                 }
             }
@@ -732,40 +788,40 @@ let XtabProvider = class XtabProvider {
             modelName: undefined,
             promptingStrategy: undefined,
             currentFile: {
-                maxTokens: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabCurrentFileMaxTokens, this.expService),
-                includeTags: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabIncludeTagsInCurrentFile, this.expService),
-                prioritizeAboveCursor: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabPrioritizeAboveCursor, this.expService)
+                maxTokens: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabCurrentFileMaxTokens, this.expService),
+                includeTags: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabIncludeTagsInCurrentFile, this.expService),
+                prioritizeAboveCursor: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabPrioritizeAboveCursor, this.expService)
             },
             pagedClipping: {
-                pageSize: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabPageSize, this.expService)
+                pageSize: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabPageSize, this.expService)
             },
             recentlyViewedDocuments: {
-                nDocuments: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabNRecentlyViewedDocuments, this.expService),
-                maxTokens: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabRecentlyViewedDocumentsMaxTokens, this.expService),
-                includeViewedFiles: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabIncludeViewedFiles, this.expService),
+                nDocuments: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabNRecentlyViewedDocuments, this.expService),
+                maxTokens: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabRecentlyViewedDocumentsMaxTokens, this.expService),
+                includeViewedFiles: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabIncludeViewedFiles, this.expService),
             },
             languageContext: this.determineLanguageContextOptions(activeDocument.languageId, {
-                enabled: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabLanguageContextEnabled, this.expService),
-                enabledLanguages: this.configService.getConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabLanguageContextEnabledLanguages),
-                maxTokens: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabLanguageContextMaxTokens, this.expService),
+                enabled: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabLanguageContextEnabled, this.expService),
+                enabledLanguages: this.configService.getConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabLanguageContextEnabledLanguages),
+                maxTokens: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabLanguageContextMaxTokens, this.expService),
             }),
             diffHistory: {
-                nEntries: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabDiffNEntries, this.expService),
-                maxTokens: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabDiffMaxTokens, this.expService),
-                onlyForDocsInPrompt: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabDiffOnlyForDocsInPrompt, this.expService),
-                useRelativePaths: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabDiffUseRelativePaths, this.expService),
+                nEntries: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabDiffNEntries, this.expService),
+                maxTokens: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabDiffMaxTokens, this.expService),
+                onlyForDocsInPrompt: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabDiffOnlyForDocsInPrompt, this.expService),
+                useRelativePaths: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabDiffUseRelativePaths, this.expService),
             },
             includePostScript: true,
         };
-        const localOverridingModelConfig = this.configService.getConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderModelConfiguration);
+        const localOverridingModelConfig = this.configService.getConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderModelConfiguration);
         if (localOverridingModelConfig) {
             return XtabProvider_1.overrideModelConfig(sourcedModelConfig, localOverridingModelConfig);
         }
-        const expBasedModelConfig = this.overrideByStringModelConfig(sourcedModelConfig, configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderModelConfigurationString);
+        const expBasedModelConfig = this.overrideByStringModelConfig(sourcedModelConfig, configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderModelConfigurationString);
         if (expBasedModelConfig) {
             return expBasedModelConfig;
         }
-        const defaultModelConfig = this.overrideByStringModelConfig(sourcedModelConfig, configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderDefaultModelConfigurationString);
+        const defaultModelConfig = this.overrideByStringModelConfig(sourcedModelConfig, configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderDefaultModelConfigurationString);
         if (defaultModelConfig) {
             return defaultModelConfig;
         }
@@ -808,6 +864,90 @@ let XtabProvider = class XtabProvider {
             },
         };
     }
+    async predictNextCursorPosition(promptPieces) {
+        const tracer = this.tracer.sub('predictNextCursorPosition');
+        const systemMessage = 'Your task is to predict the next line number in the current file where the developer is most likely to make their next edit, using the provided context.';
+        const maxTokens = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsNextCursorPredictionCurrentFileMaxTokens, this.expService);
+        const currentFileContentR = this.constructTaggedFile(promptPieces.currentDocument, promptPieces.editWindowLinesRange, promptPieces.areaAroundEditWindowLinesRange, {
+            ...promptPieces.opts,
+            currentFile: {
+                ...promptPieces.opts.currentFile,
+                maxTokens,
+                includeTags: false,
+            }
+        }, XtabProvider_1.computeTokens, { includeLineNumbers: true });
+        if (currentFileContentR.isError()) {
+            tracer.trace(`Failed to construct tagged file: ${currentFileContentR.err}`);
+            return result_1.Result.fromString(currentFileContentR.err);
+        }
+        const { taggedCurrentDocLines, areaAroundCodeToEdit } = currentFileContentR.val;
+        const newPromptPieces = new promptCrafting_1.PromptPieces(promptPieces.currentDocument, promptPieces.editWindowLinesRange, promptPieces.areaAroundEditWindowLinesRange, promptPieces.activeDoc, promptPieces.xtabHistory, taggedCurrentDocLines, areaAroundCodeToEdit, promptPieces.langCtx, XtabProvider_1.computeTokens, {
+            ...promptPieces.opts,
+            includePostScript: false,
+        });
+        const userMessage = (0, promptCrafting_1.getUserPrompt)(newPromptPieces);
+        const messages = constructMessages({
+            systemMsg: systemMessage,
+            userMsg: userMessage
+        });
+        const modelName = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsNextCursorPredictionModelName, this.expService);
+        if (modelName === undefined) {
+            tracer.trace('Model name for cursor prediction is not defined; skipping prediction');
+            return result_1.Result.fromString('modelNameNotDefined');
+        }
+        const url = this.configService.getConfig(configurationService_1.ConfigKey.Internal.InlineEditsNextCursorPredictionUrl);
+        const secretKey = this.configService.getConfig(configurationService_1.ConfigKey.Internal.InlineEditsNextCursorPredictionApiKey);
+        const endpoint = this.instaService.createInstance(chatEndpoint_1.ChatEndpoint, {
+            id: modelName,
+            name: 'nes.nextCursorPosition',
+            urlOrRequestMetadata: url ? url : { type: copilot_api_1.RequestType.ProxyChatCompletions },
+            model_picker_enabled: false,
+            is_chat_default: false,
+            is_chat_fallback: false,
+            version: '',
+            capabilities: {
+                type: 'chat',
+                family: '',
+                tokenizer: tokenizer_1.TokenizerType.CL100K,
+                limits: undefined,
+                supports: {
+                    parallel_tool_calls: false,
+                    tool_calls: false,
+                    streaming: true,
+                    vision: false,
+                    prediction: false,
+                    thinking: false
+                }
+            },
+        });
+        const response = await endpoint.makeChatRequest2({
+            messages,
+            debugName: 'nes.nextCursorPosition',
+            finishedCb: undefined,
+            location: commonTypes_1.ChatLocation.Other,
+            requestOptions: secretKey ? {
+                secretKey,
+            } : undefined,
+        }, cancellation_1.CancellationToken.None);
+        if (response.type !== commonTypes_1.ChatFetchResponseType.Success) {
+            return result_1.Result.fromString(`fetchError:${response.type}`);
+        }
+        try {
+            const trimmed = response.value.trim();
+            const lineNumber = parseInt(trimmed, 10);
+            if (isNaN(lineNumber)) {
+                return result_1.Result.fromString(`gotNaN`);
+            }
+            if (lineNumber < 0) {
+                return result_1.Result.fromString(`negativeLineNumber`);
+            }
+            return result_1.Result.ok(lineNumber);
+        }
+        catch (err) {
+            tracer.trace(`Failed to parse predicted line number from response '${response.value}': ${err}`);
+            return result_1.Result.fromString(`failedToParseLine:"${response.value}". Error ${errors.fromUnknown(err).message}`);
+        }
+    }
     pickSystemPrompt(promptingStrategy) {
         switch (promptingStrategy) {
             case xtabPromptOptions.PromptingStrategy.UnifiedModel:
@@ -831,8 +971,8 @@ let XtabProvider = class XtabProvider {
         return { enabled, maxTokens };
     }
     getEndpoint(configuredModelName) {
-        const url = this.configService.getConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderUrl);
-        const apiKey = this.configService.getConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderApiKey);
+        const url = this.configService.getConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderUrl);
+        const apiKey = this.configService.getConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderApiKey);
         const hasOverriddenUrlAndApiKey = url !== undefined && apiKey !== undefined;
         if (hasOverriddenUrlAndApiKey) {
             return this.instaService.createInstance(xtabEndpoint_1.XtabEndpoint, url, apiKey, configuredModelName);
@@ -840,7 +980,7 @@ let XtabProvider = class XtabProvider {
         return (0, proxyXtabEndpoint_1.createProxyXtabEndpoint)(this.instaService, configuredModelName);
     }
     getPredictedOutput(editWindowLines, responseFormat) {
-        return this.configService.getConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderUsePrediction)
+        return this.configService.getConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderUsePrediction)
             ? {
                 type: 'content',
                 content: XtabProvider_1.getPredictionContents(editWindowLines, responseFormat)
@@ -861,26 +1001,29 @@ let XtabProvider = class XtabProvider {
             (0, assert_1.assertNever)(responseFormat);
         }
     }
-    async debounce(delaySession, tracer, telemetry) {
+    async debounce(delaySession, telemetry) {
         if (this.simulationCtx.isInSimulationTests) {
             return;
         }
         const debounceTime = delaySession.getDebounceTime();
-        tracer.trace(`Debouncing for ${debounceTime} ms`);
+        this.tracer.trace(`Debouncing for ${debounceTime} ms`);
         telemetry.setDebounceTime(debounceTime);
         await (0, async_2.timeout)(debounceTime);
     }
-    determineArtificialDelayMs(delaySession, tracer, telemetry) {
+    async enforceArtificialDelay(delaySession, telemetry) {
         if (this.simulationCtx.isInSimulationTests) {
             return;
         }
         const artificialDelay = delaySession.getArtificialDelay();
-        if (artificialDelay <= 0) {
-            return undefined;
-        }
-        tracer.trace(`Enforcing artificial delay of ${artificialDelay} ms`);
+        this.tracer.trace(`Enforcing artificial delay of ${artificialDelay} ms`);
         telemetry.setArtificialDelay(artificialDelay);
-        return artificialDelay;
+        if (artificialDelay > 0) {
+            await (0, async_2.timeout)(artificialDelay);
+        }
+    }
+    trace(msg, logContext, tracer) {
+        tracer.trace(msg);
+        logContext.addLog(msg);
     }
 };
 exports.XtabProvider = XtabProvider;
@@ -891,10 +1034,11 @@ exports.XtabProvider = XtabProvider = XtabProvider_1 = __decorate([
     __param(3, diffService_1.IDiffService),
     __param(4, configurationService_1.IConfigurationService),
     __param(5, nullExperimentationService_1.IExperimentationService),
-    __param(6, languageContextProviderService_1.ILanguageContextProviderService),
-    __param(7, languageDiagnosticsService_1.ILanguageDiagnosticsService),
-    __param(8, ignoreService_1.IIgnoreService),
-    __param(9, telemetry_1.ITelemetryService)
+    __param(6, logService_1.ILogService),
+    __param(7, languageContextProviderService_1.ILanguageContextProviderService),
+    __param(8, languageDiagnosticsService_1.ILanguageDiagnosticsService),
+    __param(9, ignoreService_1.IIgnoreService),
+    __param(10, telemetry_1.ITelemetryService)
 ], XtabProvider);
 /**
  * Finds the range of lines containing merge conflict markers within a specified edit window.
@@ -918,4 +1062,20 @@ function findMergeConflictMarkersRange(lines, editWindowRange, maxMergeConflictL
     }
     return undefined;
 }
+function constructMessages({ systemMsg, userMsg }) {
+    return [
+        {
+            role: prompt_tsx_1.Raw.ChatRole.System,
+            content: (0, globalStringUtils_1.toTextParts)(systemMsg)
+        },
+        {
+            role: prompt_tsx_1.Raw.ChatRole.User,
+            content: (0, globalStringUtils_1.toTextParts)(userMsg)
+        }
+    ];
+}
+function charCount(messages) {
+    const promptCharCount = messages.reduce((total, msg) => total + msg.content.reduce((subtotal, part) => subtotal + (part.type === rawTypes_1.ChatCompletionContentPartKind.Text ? part.text.length : 0), 0), 0);
+    return promptCharCount;
+}
 //# sourceMappingURL=xtabProvider.js.map