@vscode/chat-lib 0.1.1-0 → 0.1.1-10

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

@@ -68,7 +68,6 @@ 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");
@@ -77,7 +76,6 @@ 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");
@@ -103,14 +101,13 @@ 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, logService, langCtxService, langDiagService, ignoreService, telemetryService) {
+    constructor(simulationCtx, instaService, workspaceService, diffService, configService, expService, 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;
@@ -120,7 +117,6 @@ let XtabProvider = class XtabProvider {
         this.showNextEditPreference = "always" /* ShowNextEditPreference.Always */;
         this.forceUseDefaultModel = false;
         this.delayer = new delayer_1.Delayer(this.configService, this.expService);
-        this.tracer = (0, tracing_1.createTracer)(['NES', 'XtabProvider'], (s) => this.logService.trace(s));
     }
     handleAcceptance() {
         this.delayer.handleAcceptance();
@@ -128,7 +124,7 @@ let XtabProvider = class XtabProvider {
     handleRejection() {
         this.delayer.handleRejection();
     }
-    provideNextEdit(request, pushEdit, logContext, cancellationToken) {
+    provideNextEdit(request, pushEdit, tracer, logContext, cancellationToken) {
         const filteringPushEdit = (result) => {
             if (result.isError()) {
                 pushEdit(result);
@@ -141,7 +137,7 @@ let XtabProvider = class XtabProvider {
             }
             pushEdit(result);
         };
-        return this._provideNextEdit(request, filteringPushEdit, logContext, cancellationToken);
+        return this._provideNextEdit(request, filteringPushEdit, tracer, logContext, cancellationToken);
     }
     filterEdit(activeDoc, edits) {
         const filters = [
@@ -151,7 +147,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.Internal.InlineEditsUndoInsertionFiltering, this.expService);
+        const undoInsertionFiltering = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsUndoInsertionFiltering, this.expService);
         if (undoInsertionFiltering !== undefined) {
             let filter;
             switch (undoInsertionFiltering) {
@@ -168,7 +164,7 @@ let XtabProvider = class XtabProvider {
         }
         return filters.reduce((acc, filter) => filter(acc), edits);
     }
-    async _provideNextEdit(request, pushEdit, logContext, cancellationToken) {
+    async _provideNextEdit(request, pushEdit, tracer, logContext, cancellationToken) {
         const telemetry = new statelessNextEditProvider_1.StatelessNextEditTelemetryBuilder(request);
         logContext.setProviderStartTime();
         try {
@@ -176,13 +172,10 @@ 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, logContext, cancellationToken, telemetry, 0 /* RetryState.NotRetrying */);
+            const nextEditResult = await this.doGetNextEdit(request, pushEdit, delaySession, tracer, 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) {
@@ -192,11 +185,11 @@ let XtabProvider = class XtabProvider {
             logContext.setProviderEndTime();
         }
     }
-    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 doGetNextEdit(request, pushEdit, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, retryState) {
+        return this.doGetNextEditWithSelection(request, (0, nearbyCursorInlineEditProvider_1.getOrDeduceSelectionFromLastEdit)(request.getActiveDocument()), pushEdit, delaySession, { showLabel: false }, tracer, logContext, cancellationToken, telemetryBuilder, retryState);
     }
-    async doGetNextEditWithSelection(request, selection, pushEdit, delaySession, opts, logContext, cancellationToken, telemetryBuilder, retryState) {
-        const tracer = this.tracer.sub('doGetNextEditWithSelection');
+    async doGetNextEditWithSelection(request, selection, pushEdit, delaySession, opts, parentTracer, logContext, cancellationToken, telemetryBuilder, retryState) {
+        const tracer = parentTracer.sub(['XtabProvider', 'doGetNextEditWithSelection']);
         const activeDocument = request.getActiveDocument();
         if (selection === null) {
             return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.Uncategorized(new Error('NoSelection')));
@@ -208,31 +201,36 @@ 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];
-        const isCursorAtEndOfLine = cursorPosition.column === cursorLine.trimEnd().length;
+        // check if there's any non-whitespace character after the cursor in the line
+        const isCursorAtEndOfLine = cursorLine.substring(cursorPosition.column - 1).match(/^\s*$/) !== null;
         if (isCursorAtEndOfLine) {
-            delaySession.setExtraDebounce(this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsExtraDebounceEndOfLine, this.expService));
+            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');
         }
         telemetryBuilder.setIsCursorAtLineEnd(isCursorAtEndOfLine);
         const areaAroundEditWindowLinesRange = this.computeAreaAroundEditWindowLinesRange(currentDocument);
-        const editWindowLinesRange = this.computeEditWindowLinesRange(currentDocument, request, retryState, telemetryBuilder);
+        const editWindowLinesRange = this.computeEditWindowLinesRange(currentDocument, request, retryState, tracer, telemetryBuilder);
         const cursorOriginalLinesOffset = Math.max(0, currentDocument.cursorLineOffset - editWindowLinesRange.start);
         const editWindowLastLineLength = currentDocument.transformer.getLineLength(editWindowLinesRange.endExclusive);
         const editWindow = currentDocument.transformer.getOffsetRange(new range_1.Range(editWindowLinesRange.start + 1, 1, editWindowLinesRange.endExclusive, editWindowLastLineLength + 1));
         const editWindowLines = currentDocument.lines.slice(editWindowLinesRange.start, editWindowLinesRange.endExclusive);
-        const editWindowTokenLimit = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabEditWindowMaxTokens, this.expService);
+        const editWindowTokenLimit = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabEditWindowMaxTokens, this.expService);
         if (editWindowTokenLimit !== undefined && (0, promptCrafting_1.countTokensForLines)(editWindowLines, XtabProvider_1.computeTokens) > editWindowTokenLimit) {
             return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.PromptTooLarge('editWindow'));
         }
         // 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 = this.constructTaggedFile(currentDocument, editWindowLinesRange, areaAroundEditWindowLinesRange, promptOptions, XtabProvider_1.computeTokens, { includeLineNumbers: false });
+        const taggedCurrentFileContentResult = this.constructTaggedFile(currentDocument, editWindowLinesRange, areaAroundEditWindowLinesRange, promptOptions, XtabProvider_1.computeTokens, { includeLineNumbers: { areaAroundCodeToEdit: false, currentFileContent: 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, logContext, cancellationToken);
+        const langCtx = await this.getAndProcessLanguageContext(request, delaySession, activeDocument, cursorPosition, promptOptions, tracer, logContext, cancellationToken);
         if (cancellationToken.isCancellationRequested) {
             return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.GotCancelled('afterLanguageContextAwait'));
         }
@@ -251,7 +249,7 @@ let XtabProvider = class XtabProvider {
         if (promptCharCount > HARD_CHAR_LIMIT) {
             return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.PromptTooLarge('final'));
         }
-        await this.debounce(delaySession, telemetryBuilder);
+        await this.debounce(delaySession, tracer, telemetryBuilder);
         if (cancellationToken.isCancellationRequested) {
             return result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.GotCancelled('afterDebounce'));
         }
@@ -272,7 +270,7 @@ let XtabProvider = class XtabProvider {
             return contentWithCursor.getLines();
         })();
         const addLineNumbers = (lines) => lines.map((line, idx) => `${idx}| ${line}`);
-        const contentWithCursorAsLines = opts.includeLineNumbers
+        const contentWithCursorAsLines = opts.includeLineNumbers.areaAroundCodeToEdit
             ? addLineNumbers(contentWithCursorAsLinesOriginal)
             : contentWithCursorAsLinesOriginal;
         const editWindowWithCursorAsLines = contentWithCursorAsLines.slice(editWindowLinesRange.start, editWindowLinesRange.endExclusive);
@@ -285,19 +283,22 @@ let XtabProvider = class XtabProvider {
             ...contentWithCursorAsLines.slice(editWindowLinesRange.endExclusive, areaAroundEditWindowLinesRange.endExclusive),
             tags_1.PromptTags.AREA_AROUND.end
         ].join('\n');
-        const currentFileContentLines = opts.includeLineNumbers
+        const currentFileContentWithCursorLines = opts.includeLineNumbers.currentFileContent
+            ? addLineNumbers(contentWithCursorAsLinesOriginal)
+            : contentWithCursorAsLinesOriginal;
+        const currentFileContentLines = opts.includeLineNumbers.currentFileContent
             ? addLineNumbers(currentDocument.lines)
             : currentDocument.lines;
         let areaAroundCodeToEditForCurrentFile;
-        if (promptOptions.currentFile.includeTags) {
+        if (promptOptions.currentFile.includeTags && opts.includeLineNumbers.currentFileContent === opts.includeLineNumbers.areaAroundCodeToEdit) {
             areaAroundCodeToEditForCurrentFile = areaAroundCodeToEdit;
         }
         else {
             const editWindowLines = currentFileContentLines.slice(editWindowLinesRange.start, editWindowLinesRange.endExclusive);
             areaAroundCodeToEditForCurrentFile = [
-                ...contentWithCursorAsLines.slice(areaAroundEditWindowLinesRange.start, editWindowLinesRange.start),
+                ...currentFileContentWithCursorLines.slice(areaAroundEditWindowLinesRange.start, editWindowLinesRange.start),
                 ...editWindowLines,
-                ...contentWithCursorAsLines.slice(editWindowLinesRange.endExclusive, areaAroundEditWindowLinesRange.endExclusive),
+                ...currentFileContentWithCursorLines.slice(editWindowLinesRange.endExclusive, areaAroundEditWindowLinesRange.endExclusive),
             ].join('\n');
         }
         const taggedCurrentFileContentResult = (0, promptCrafting_1.createTaggedCurrentFileContentUsingPagedClipping)(currentFileContentLines, areaAroundCodeToEditForCurrentFile, areaAroundEditWindowLinesRange, computeTokens, promptOptions.pagedClipping.pageSize, promptOptions.currentFile);
@@ -306,12 +307,13 @@ let XtabProvider = class XtabProvider {
             areaAroundCodeToEdit,
         }));
     }
-    getAndProcessLanguageContext(request, delaySession, activeDocument, cursorPosition, promptOptions, logContext, cancellationToken) {
-        const recordingEnabled = this.configService.getConfig(configurationService_1.ConfigKey.Internal.InlineEditsLogContextRecorderEnabled);
-        if (!promptOptions.languageContext.enabled && !recordingEnabled) {
+    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) {
             return Promise.resolve(undefined);
         }
-        const langCtxPromise = this.getLanguageContext(request, delaySession, activeDocument, cursorPosition, logContext, cancellationToken);
+        const langCtxPromise = this.getLanguageContext(request, delaySession, activeDocument, cursorPosition, tracer, 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());
@@ -325,13 +327,13 @@ let XtabProvider = class XtabProvider {
             ? langCtxPromise
             : Promise.resolve(undefined);
     }
-    async getLanguageContext(request, delaySession, activeDocument, cursorPosition, logContext, cancellationToken) {
+    async getLanguageContext(request, delaySession, activeDocument, cursorPosition, tracer, 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);
+            const providers = this.langCtxService.getContextProviders(textDoc, languageContextProviderService_1.ProviderTarget.NES);
             if (providers.length < 1) {
                 return undefined;
             }
@@ -344,7 +346,8 @@ let XtabProvider = class XtabProvider {
                     uri: textDoc.uri.toString(),
                     languageId: textDoc.languageId,
                     version: textDoc.version,
-                    offset: textDoc.offsetAt(cursorPositionVscode)
+                    offset: textDoc.offsetAt(cursorPositionVscode),
+                    position: cursorPositionVscode
                 },
                 activeExperiments: new Map(),
                 timeBudget: debounceTime,
@@ -382,7 +385,7 @@ let XtabProvider = class XtabProvider {
         }
         catch (error) {
             logContext.setError(errors.fromUnknown(error));
-            this.tracer.trace(`Failed to fetch language context: ${error}`);
+            tracer.trace(`Failed to fetch language context: ${error}`);
             return undefined;
         }
     }
@@ -436,7 +439,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, logContext, cancellationToken, telemetryBuilder, opts.retryState); // use the same retry state
+                return this.doGetNextEdit(request, pushEdit, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, opts.retryState); // use the same retry state
             }
             pushEdit(result_1.Result.error(XtabProvider_1.mapChatFetcherErrorToNoNextEditReason(fetchRes)));
             return;
@@ -468,7 +471,6 @@ 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, '')
@@ -492,7 +494,7 @@ let XtabProvider = class XtabProvider {
             }
             const trimmedLines = firstLine.value.trim();
             if (trimmedLines === tags_1.ResponseTags.NO_CHANGE.start) {
-                await this.pushNoSuggestionsOrRetry(request, editWindow, promptPieces, pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, opts.retryState);
+                await this.pushNoSuggestionsOrRetry(request, editWindow, promptPieces, pushEdit, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, opts.retryState);
                 return;
             }
             if (trimmedLines === tags_1.ResponseTags.INSERT.start) {
@@ -548,15 +550,17 @@ let XtabProvider = class XtabProvider {
         const diffOptions = {
             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),
+                : 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`);
         (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
@@ -572,6 +576,7 @@ 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));
@@ -583,10 +588,10 @@ let XtabProvider = class XtabProvider {
                     }
                     logContext.setResponse(responseSoFar);
                     for (const singleLineEdit of singleLineEdits) {
-                        this.trace(`pushing edit #${i}:\n${singleLineEdit.toString()}`, logContext, tracer);
+                        tracer.trace(`pushing edit #${i}:\n${singleLineEdit.toString()}`);
                         if (!hasBeenDelayed) { // delay only the first one
                             hasBeenDelayed = true;
-                            await this.enforceArtificialDelay(delaySession, telemetryBuilder);
+                            await this.enforceArtificialDelay(delaySession, tracer, telemetryBuilder);
                         }
                         pushEdit(result_1.Result.ok({ edit: singleLineEdit, window: editWindow, showLabel: opts.showLabel }));
                         i++;
@@ -601,7 +606,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, logContext, cancellationToken, telemetryBuilder, opts.retryState);
+                    await this.pushNoSuggestionsOrRetry(request, editWindow, promptPieces, pushEdit, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, opts.retryState);
                 }
             }
             catch (err) {
@@ -611,37 +616,35 @@ let XtabProvider = class XtabProvider {
             }
         })();
     }
-    async pushNoSuggestionsOrRetry(request, editWindow, promptPieces, pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, retryState) {
-        const allowRetryWithExpandedWindow = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderRetryWithNMoreLinesBelow, this.expService);
+    async pushNoSuggestionsOrRetry(request, editWindow, promptPieces, pushEdit, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, retryState) {
+        const allowRetryWithExpandedWindow = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderRetryWithNMoreLinesBelow, this.expService);
         // if allowed to retry and not retrying already, flip the retry state and try again
         if (allowRetryWithExpandedWindow && retryState === 0 /* RetryState.NotRetrying */ && request.expandedEditWindowNLines === undefined) {
-            this.doGetNextEdit(request, pushEdit, delaySession, logContext, cancellationToken, telemetryBuilder, 1 /* RetryState.Retrying */);
+            this.doGetNextEdit(request, pushEdit, delaySession, tracer, logContext, cancellationToken, telemetryBuilder, 1 /* RetryState.Retrying */);
             return;
         }
-        let nextCursorLinePrediction = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsNextCursorPredictionEnabled, this.expService);
-        nextCursorLinePrediction = (nextCursorLinePrediction === true ? nextCursorLinePrediction_1.NextCursorLinePrediction.OnlyWithEdit :
-            (nextCursorLinePrediction === false ? undefined : nextCursorLinePrediction));
+        const nextCursorLinePrediction = this.determineNextCursorPredicationEnablement();
         if (nextCursorLinePrediction !== undefined && retryState === 0 /* RetryState.NotRetrying */) {
-            const nextCursorLineR = await this.predictNextCursorPosition(promptPieces);
+            const nextCursorLineR = await this.predictNextCursorPosition(promptPieces, tracer);
             if (cancellationToken.isCancellationRequested) {
                 pushEdit(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow)));
                 return;
             }
             if (nextCursorLineR.isError()) {
-                this.tracer.trace(`Predicted next cursor line error: ${nextCursorLineR.err.message}`);
+                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);
-                this.tracer.trace(`Predicted next cursor line: ${nextCursorLineZeroBased}`);
+                tracer.trace(`Predicted next cursor line: ${nextCursorLineZeroBased}`);
                 if (nextCursorLineZeroBased >= promptPieces.currentDocument.lines.length) { // >= because the line index is zero-based
-                    this.tracer.trace(`Predicted next cursor line error: exceedsDocumentLines`);
+                    tracer.trace(`Predicted next cursor line error: exceedsDocumentLines`);
                     telemetryBuilder.setNextCursorLineError('exceedsDocumentLines');
                 }
                 else if (promptPieces.editWindowLinesRange.contains(nextCursorLineZeroBased)) {
-                    this.tracer.trace(`Predicted next cursor line error: withinEditWindow`);
+                    tracer.trace(`Predicted next cursor line error: withinEditWindow`);
                     telemetryBuilder.setNextCursorLineError('withinEditWindow');
                 }
                 else {
@@ -656,7 +659,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, { showLabel: nextCursorLinePrediction === nextCursorLinePrediction_1.NextCursorLinePrediction.LabelOnlyWithEdit }, 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 }, tracer, logContext, cancellationToken, telemetryBuilder, 1 /* RetryState.Retrying */);
                             return;
                         }
                         default: {
@@ -669,18 +672,37 @@ let XtabProvider = class XtabProvider {
         pushEdit(result_1.Result.error(new statelessNextEditProvider_1.NoNextEditReason.NoSuggestions(request.documentBeforeEdits, editWindow)));
         return;
     }
+    determineNextCursorPredicationEnablement() {
+        const originalNextCursorLinePrediction = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsNextCursorPredictionEnabled, this.expService);
+        switch (originalNextCursorLinePrediction) {
+            case undefined:
+                return undefined;
+            // remove support for enum members other than OnlyWithEdit
+            case nextCursorLinePrediction_1.NextCursorLinePrediction.OnlyWithEdit:
+            case nextCursorLinePrediction_1.NextCursorLinePrediction.Jump:
+            case nextCursorLinePrediction_1.NextCursorLinePrediction.LabelOnlyWithEdit:
+                return nextCursorLinePrediction_1.NextCursorLinePrediction.OnlyWithEdit;
+            // for backward compatibility
+            case true:
+                return nextCursorLinePrediction_1.NextCursorLinePrediction.OnlyWithEdit;
+            case false:
+                return undefined;
+            default:
+                (0, assert_1.assertNever)(originalNextCursorLinePrediction);
+        }
+    }
     computeAreaAroundEditWindowLinesRange(currentDocument) {
         const cursorLine = currentDocument.cursorLineOffset;
         const areaAroundStart = Math.max(0, cursorLine - promptCrafting_1.N_LINES_AS_CONTEXT);
         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, telemetry) {
+    computeEditWindowLinesRange(currentDocument, request, retryState, tracer, telemetry) {
         const currentDocLines = currentDocument.lines;
         const cursorLineOffset = currentDocument.cursorLineOffset;
         let nLinesAbove;
         {
-            const useVaryingLinesAbove = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderUseVaryingLinesAbove, this.expService);
+            const useVaryingLinesAbove = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderUseVaryingLinesAbove, this.expService);
             if (useVaryingLinesAbove) {
                 nLinesAbove = 0; // default
                 for (let i = 0; i < 8; ++i) {
@@ -695,45 +717,45 @@ let XtabProvider = class XtabProvider {
                 }
             }
             else {
-                nLinesAbove = (this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderNLinesAbove, this.expService)
+                nLinesAbove = (this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderNLinesAbove, this.expService)
                     ?? promptCrafting_1.N_LINES_ABOVE);
             }
         }
         let nLinesBelow;
         if (request.expandedEditWindowNLines !== undefined) {
-            this.tracer.trace(`Using expanded nLinesBelow: ${request.expandedEditWindowNLines}`);
+            tracer.trace(`Using expanded nLinesBelow: ${request.expandedEditWindowNLines}`);
             nLinesBelow = request.expandedEditWindowNLines;
         }
         else {
-            const overriddenNLinesBelow = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderNLinesBelow, this.expService);
+            const overriddenNLinesBelow = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderNLinesBelow, this.expService);
             if (overriddenNLinesBelow !== undefined) {
-                this.tracer.trace(`Using overridden nLinesBelow: ${overriddenNLinesBelow}`);
+                tracer.trace(`Using overridden nLinesBelow: ${overriddenNLinesBelow}`);
                 nLinesBelow = overriddenNLinesBelow;
             }
             else {
-                this.tracer.trace(`Using default nLinesBelow: ${promptCrafting_1.N_LINES_BELOW}`);
+                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.Internal.InlineEditsXtabProviderRetryWithNMoreLinesBelow, this.expService) ?? 0;
+            nLinesBelow += this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderRetryWithNMoreLinesBelow, this.expService) ?? 0;
         }
         let codeToEditStart = Math.max(0, cursorLineOffset - nLinesAbove);
         let codeToEditEndExcl = Math.min(currentDocLines.length, cursorLineOffset + nLinesBelow + 1);
-        const maxMergeConflictLines = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabMaxMergeConflictLines, this.expService);
+        const maxMergeConflictLines = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.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.Internal.InlineEditsXtabOnlyMergeConflictLines, this.expService);
+                const onlyMergeConflictLines = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabOnlyMergeConflictLines, this.expService);
                 telemetry.setMergeConflictExpanded(onlyMergeConflictLines ? 'only' : 'normal');
                 if (onlyMergeConflictLines) {
-                    this.tracer.trace(`Expanding edit window to include ONLY merge conflict markers: ${mergeConflictRange.toString()}`);
+                    tracer.trace(`Expanding edit window to include ONLY merge conflict markers: ${mergeConflictRange.toString()}`);
                     codeToEditStart = mergeConflictRange.start;
                     codeToEditEndExcl = mergeConflictRange.endExclusive;
                 }
                 else {
-                    this.tracer.trace(`Expanding edit window to include merge conflict markers: ${mergeConflictRange.toString()}; edit window range [${codeToEditStart}, ${codeToEditEndExcl})`);
+                    tracer.trace(`Expanding edit window to include merge conflict markers: ${mergeConflictRange.toString()}; edit window range [${codeToEditStart}, ${codeToEditEndExcl})`);
                     codeToEditEndExcl = Math.max(codeToEditEndExcl, mergeConflictRange.endExclusive);
                 }
             }
@@ -774,40 +796,40 @@ let XtabProvider = class XtabProvider {
             modelName: undefined,
             promptingStrategy: undefined,
             currentFile: {
-                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)
+                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)
             },
             pagedClipping: {
-                pageSize: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabPageSize, this.expService)
+                pageSize: this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabPageSize, this.expService)
             },
             recentlyViewedDocuments: {
-                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),
+                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),
             },
             languageContext: this.determineLanguageContextOptions(activeDocument.languageId, {
-                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),
+                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),
             }),
             diffHistory: {
-                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),
+                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),
             },
             includePostScript: true,
         };
-        const localOverridingModelConfig = this.configService.getConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderModelConfiguration);
+        const localOverridingModelConfig = this.configService.getConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderModelConfiguration);
         if (localOverridingModelConfig) {
             return XtabProvider_1.overrideModelConfig(sourcedModelConfig, localOverridingModelConfig);
         }
-        const expBasedModelConfig = this.overrideByStringModelConfig(sourcedModelConfig, configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderModelConfigurationString);
+        const expBasedModelConfig = this.overrideByStringModelConfig(sourcedModelConfig, configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderModelConfigurationString);
         if (expBasedModelConfig) {
             return expBasedModelConfig;
         }
-        const defaultModelConfig = this.overrideByStringModelConfig(sourcedModelConfig, configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderDefaultModelConfigurationString);
+        const defaultModelConfig = this.overrideByStringModelConfig(sourcedModelConfig, configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderDefaultModelConfigurationString);
         if (defaultModelConfig) {
             return defaultModelConfig;
         }
@@ -850,10 +872,10 @@ 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);
+    async predictNextCursorPosition(promptPieces, parentTracer) {
+        const tracer = parentTracer.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. If you don't think anywhere is a good next line jump target, just output the current line number of the cursor. Make sure to just output the line number and nothing else (no explanation, reasoning, etc.).`;
+        const maxTokens = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Advanced.InlineEditsNextCursorPredictionCurrentFileMaxTokens, this.expService);
         const currentFileContentR = this.constructTaggedFile(promptPieces.currentDocument, promptPieces.editWindowLinesRange, promptPieces.areaAroundEditWindowLinesRange, {
             ...promptPieces.opts,
             currentFile: {
@@ -861,7 +883,7 @@ let XtabProvider = class XtabProvider {
                 maxTokens,
                 includeTags: false,
             }
-        }, XtabProvider_1.computeTokens, { includeLineNumbers: true });
+        }, XtabProvider_1.computeTokens, { includeLineNumbers: { areaAroundCodeToEdit: false, currentFileContent: true } });
         if (currentFileContentR.isError()) {
             tracer.trace(`Failed to construct tagged file: ${currentFileContentR.err}`);
             return result_1.Result.fromString(currentFileContentR.err);
@@ -876,13 +898,13 @@ let XtabProvider = class XtabProvider {
             systemMsg: systemMessage,
             userMsg: userMessage
         });
-        const modelName = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.Internal.InlineEditsNextCursorPredictionModelName, this.expService);
+        const modelName = this.configService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.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 url = this.configService.getConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsNextCursorPredictionUrl);
+        const secretKey = this.configService.getConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsNextCursorPredictionApiKey);
         const endpoint = this.instaService.createInstance(chatEndpoint_1.ChatEndpoint, {
             id: modelName,
             name: 'nes.nextCursorPosition',
@@ -957,8 +979,8 @@ let XtabProvider = class XtabProvider {
         return { enabled, maxTokens };
     }
     getEndpoint(configuredModelName) {
-        const url = this.configService.getConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderUrl);
-        const apiKey = this.configService.getConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderApiKey);
+        const url = this.configService.getConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderUrl);
+        const apiKey = this.configService.getConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderApiKey);
         const hasOverriddenUrlAndApiKey = url !== undefined && apiKey !== undefined;
         if (hasOverriddenUrlAndApiKey) {
             return this.instaService.createInstance(xtabEndpoint_1.XtabEndpoint, url, apiKey, configuredModelName);
@@ -966,7 +988,7 @@ let XtabProvider = class XtabProvider {
         return (0, proxyXtabEndpoint_1.createProxyXtabEndpoint)(this.instaService, configuredModelName);
     }
     getPredictedOutput(editWindowLines, responseFormat) {
-        return this.configService.getConfig(configurationService_1.ConfigKey.Internal.InlineEditsXtabProviderUsePrediction)
+        return this.configService.getConfig(configurationService_1.ConfigKey.TeamInternal.InlineEditsXtabProviderUsePrediction)
             ? {
                 type: 'content',
                 content: XtabProvider_1.getPredictionContents(editWindowLines, responseFormat)
@@ -987,30 +1009,26 @@ let XtabProvider = class XtabProvider {
             (0, assert_1.assertNever)(responseFormat);
         }
     }
-    async debounce(delaySession, telemetry) {
+    async debounce(delaySession, tracer, telemetry) {
         if (this.simulationCtx.isInSimulationTests) {
             return;
         }
         const debounceTime = delaySession.getDebounceTime();
-        this.tracer.trace(`Debouncing for ${debounceTime} ms`);
+        tracer.trace(`Debouncing for ${debounceTime} ms`);
         telemetry.setDebounceTime(debounceTime);
         await (0, async_2.timeout)(debounceTime);
     }
-    async enforceArtificialDelay(delaySession, telemetry) {
+    async enforceArtificialDelay(delaySession, tracer, telemetry) {
         if (this.simulationCtx.isInSimulationTests) {
             return;
         }
         const artificialDelay = delaySession.getArtificialDelay();
-        this.tracer.trace(`Enforcing artificial delay of ${artificialDelay} ms`);
+        tracer.trace(`Enforcing artificial delay of ${artificialDelay} ms`);
         telemetry.setArtificialDelay(artificialDelay);
         if (artificialDelay > 0) {
             await (0, async_2.timeout)(artificialDelay);
         }
     }
-    trace(msg, logContext, tracer) {
-        tracer.trace(msg);
-        logContext.addLog(msg);
-    }
 };
 exports.XtabProvider = XtabProvider;
 exports.XtabProvider = XtabProvider = XtabProvider_1 = __decorate([
@@ -1020,11 +1038,10 @@ exports.XtabProvider = XtabProvider = XtabProvider_1 = __decorate([
     __param(3, diffService_1.IDiffService),
     __param(4, configurationService_1.IConfigurationService),
     __param(5, nullExperimentationService_1.IExperimentationService),
-    __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)
+    __param(6, languageContextProviderService_1.ILanguageContextProviderService),
+    __param(7, languageDiagnosticsService_1.ILanguageDiagnosticsService),
+    __param(8, ignoreService_1.IIgnoreService),
+    __param(9, telemetry_1.ITelemetryService)
 ], XtabProvider);
 /**
  * Finds the range of lines containing merge conflict markers within a specified edit window.