@vscode/chat-lib 0.2.1-27 → 0.2.1-28

package/dist/src/_internal/extension/completions-core/vscode-node/lib/src/ghostText/ghostText.js

@@ -1,11 +1,18 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ForceMultiLine = exports.ResultType = void 0;
+exports.ForceMultiLine = exports.CompletionsFromNetwork = exports.ResultType = void 0;
 exports.getGhostText = getGhostText;
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
+const configurationService_1 = require("../../../../../../platform/configuration/common/configurationService");
+const nullExperimentationService_1 = require("../../../../../../platform/telemetry/common/nullExperimentationService");
 const telemetry_1 = require("../../../../../../platform/telemetry/common/telemetry");
 const crypto_1 = require("../../../../../../util/common/crypto");
 const uuid_1 = require("../../../../../../util/vs/base/common/uuid");
@@ -54,117 +61,256 @@ var ResultType;
 // average token length is around 4 characters
 // the below values have quite a bit of buffer while bringing the limit in significantly from 500
 const maxSinglelineTokens = 20;
-async function genericGetCompletionsFromNetwork(accessor, requestContext, baseTelemetryData, cancellationToken, finishedCb, what, processChoices) {
-    const featuresService = accessor.get(featuresService_1.ICompletionsFeaturesService);
-    const fetcherService = accessor.get(fetch_1.ICompletionsOpenAIFetcherService);
-    const runtimeMode = accessor.get(runtimeMode_1.ICompletionsRuntimeModeService);
-    const instantiationService = accessor.get(instantiation_1.IInstantiationService);
-    const logTarget = accessor.get(logger_1.ICompletionsLogTargetService);
-    const userErrorNotifier = accessor.get(userErrorNotifier_1.ICompletionsUserErrorNotifierService);
-    ghostTextLogger.debug(logTarget, `Getting ${what} from network`);
-    // copy the base telemetry data
-    baseTelemetryData = baseTelemetryData.extendedBy();
-    // Request one choice for automatic requests, three for invoked (cycling) requests.
-    const n = requestContext.isCycling ? 3 : 1;
-    const temperature = (0, openai_1.getTemperatureForSamples)(runtimeMode, n);
-    const extra = {
-        language: requestContext.languageId,
-        next_indent: requestContext.indentation.next ?? 0,
-        trim_by_indentation: (0, config_1.shouldDoServerTrimming)(requestContext.blockMode),
-        prompt_tokens: requestContext.prompt.prefixTokens ?? 0,
-        suffix_tokens: requestContext.prompt.suffixTokens ?? 0,
-    };
-    const postOptions = { n, temperature, code_annotations: false };
-    const modelTerminatesSingleline = featuresService.modelAlwaysTerminatesSingleline(baseTelemetryData);
-    const simulateSingleline = requestContext.blockMode === config_1.BlockMode.MoreMultiline &&
-        blockTrimmer_1.BlockTrimmer.isSupported(requestContext.languageId) &&
-        !modelTerminatesSingleline;
-    if (!requestContext.multiline && !simulateSingleline) {
-        // If we are not in multiline mode, we get the server to truncate the results. This does mean that we
-        // also cache a single line result which will be reused even if we are later in multiline mode. This is
-        // an acceptable trade-off as the transition should be relatively rare and truncating on the server is
-        // more efficient.
-        // Note that this also means we don't need to truncate when creating the GhostAPIChoice object below.
-        postOptions['stop'] = ['\n'];
-    }
-    else if (requestContext.stop) {
-        postOptions['stop'] = requestContext.stop;
+let CompletionsFromNetwork = class CompletionsFromNetwork {
+    constructor(instantiationService, fetcherService, featuresService, runtimeMode, logTarget, completionsCacheService, userErrorNotifier, configurationService, expService) {
+        this.instantiationService = instantiationService;
+        this.fetcherService = fetcherService;
+        this.featuresService = featuresService;
+        this.runtimeMode = runtimeMode;
+        this.logTarget = logTarget;
+        this.completionsCacheService = completionsCacheService;
+        this.userErrorNotifier = userErrorNotifier;
+        this.configurationService = configurationService;
+        this.expService = expService;
     }
-    if (requestContext.maxTokens !== undefined) {
-        postOptions['max_tokens'] = requestContext.maxTokens;
+    /** Requests new completion from OpenAI, should be called if and only if the completions for given prompt were not cached before.
+     *  It returns only first completion, additional completions are added to the caches in the background.
+     *  Copies from the base telemetry data are used as the basis for each choice's telemetry.
+     */
+    async getCompletionsFromNetwork(requestContext, baseTelemetryData, cancellationToken, finishedCb) {
+        return this.genericGetCompletionsFromNetwork(requestContext, baseTelemetryData, cancellationToken, finishedCb, 'completions', async (requestStart, processingTime, choicesStream) => {
+            const choicesIterator = choicesStream[Symbol.asyncIterator]();
+            const firstRes = await choicesIterator.next();
+            if (firstRes.done) {
+                ghostTextLogger.debug(this.logTarget, 'All choices redacted');
+                return {
+                    type: 'empty',
+                    reason: 'all choices redacted',
+                    telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
+                };
+            }
+            if (cancellationToken?.isCancellationRequested) {
+                ghostTextLogger.debug(this.logTarget, 'Cancelled after awaiting redactedChoices iterator');
+                return {
+                    type: 'canceled',
+                    reason: 'after awaiting redactedChoices iterator',
+                    telemetryData: (0, telemetry_3.mkCanceledResultTelemetry)(baseTelemetryData),
+                };
+            }
+            const firstChoice = firstRes.value;
+            if (firstChoice === undefined) {
+                // This is probably unreachable given the firstRes.done check above
+                ghostTextLogger.debug(this.logTarget, 'Got undefined choice from redactedChoices iterator');
+                return {
+                    type: 'empty',
+                    reason: 'got undefined choice from redactedChoices iterator',
+                    telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
+                };
+            }
+            this.instantiationService.invokeFunction(telemetryPerformance, 'performance', firstChoice, requestStart, processingTime);
+            ghostTextLogger.debug(this.logTarget, `Awaited first result, id:  ${firstChoice.choiceIndex}`);
+            // Adds first result to cache
+            const processedFirstChoice = postProcessChoices(firstChoice);
+            if (processedFirstChoice) {
+                appendToCache(this.completionsCacheService, requestContext, processedFirstChoice);
+                ghostTextLogger.debug(this.logTarget, `GhostText first completion (index ${processedFirstChoice?.choiceIndex}): ${JSON.stringify(processedFirstChoice?.completionText)}`);
+            }
+            //Create promise for each result, don't `await` it (unless in test mode) but handle asynchronously with `.then()`
+            const cacheDone = (async () => {
+                const apiChoices = processedFirstChoice !== undefined ? [processedFirstChoice] : [];
+                for await (const choice of choicesStream) {
+                    if (choice === undefined) {
+                        continue;
+                    }
+                    ghostTextLogger.debug(this.logTarget, `GhostText later completion (index ${choice?.choiceIndex}): ${JSON.stringify(choice.completionText)}`);
+                    const processedChoice = postProcessChoices(choice, apiChoices);
+                    if (!processedChoice) {
+                        continue;
+                    }
+                    apiChoices.push(processedChoice);
+                    appendToCache(this.completionsCacheService, requestContext, processedChoice);
+                }
+            })();
+            if (this.runtimeMode.isRunningInTest()) {
+                await cacheDone;
+            }
+            if (processedFirstChoice) {
+                // Because we ask the server to stop at \n above, we don't need to force single line here
+                return {
+                    type: 'success',
+                    value: [makeGhostAPIChoice(processedFirstChoice, { forceSingleLine: false }), cacheDone],
+                    telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
+                    telemetryBlob: baseTelemetryData,
+                    resultType: ResultType.Network,
+                };
+            }
+            else {
+                return {
+                    type: 'empty',
+                    reason: 'got undefined processedFirstChoice',
+                    telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
+                };
+            }
+        });
     }
-    const requestStart = Date.now();
-    // extend telemetry data
-    const newProperties = {
-        endpoint: 'completions',
-        uiKind: fetch_1.CopilotUiKind.GhostText,
-        temperature: JSON.stringify(temperature),
-        n: JSON.stringify(n),
-        stop: JSON.stringify(postOptions['stop']) ?? 'unset',
-        logit_bias: JSON.stringify(null),
-    };
-    Object.assign(baseTelemetryData.properties, newProperties);
-    try {
-        const completionParams = {
-            prompt: requestContext.prompt,
-            languageId: requestContext.languageId,
-            repoInfo: requestContext.repoInfo,
-            ourRequestId: requestContext.ourRequestId,
-            engineModelId: requestContext.engineModelId,
-            count: n,
-            uiKind: fetch_1.CopilotUiKind.GhostText,
-            postOptions,
-            headers: requestContext.headers,
-            extra,
-        };
-        const res = await fetcherService.fetchAndStreamCompletions(completionParams, baseTelemetryData, finishedCb, cancellationToken);
-        if (res.type === 'failed') {
+    /** Requests new completion from OpenAI, should be called if and only if we are in the servers-side termination mode, and it's follow-up cycling request
+     *  It returns all requested completions
+     *  Copies from the base telemetry data are used as the basis for each choice's telemetry.
+     */
+    async getAllCompletionsFromNetwork(requestContext, baseTelemetryData, cancellationToken, finishedCb) {
+        return this.genericGetCompletionsFromNetwork(requestContext, baseTelemetryData, cancellationToken, finishedCb, 'all completions', async (requestStart, processingTime, choicesStream) => {
+            const apiChoices = [];
+            for await (const choice of choicesStream) {
+                if (cancellationToken?.isCancellationRequested) {
+                    ghostTextLogger.debug(this.logTarget, 'Cancelled after awaiting choices iterator');
+                    return {
+                        type: 'canceled',
+                        reason: 'after awaiting choices iterator',
+                        telemetryData: (0, telemetry_3.mkCanceledResultTelemetry)(baseTelemetryData),
+                    };
+                }
+                const processedChoice = postProcessChoices(choice, apiChoices);
+                if (!processedChoice) {
+                    continue;
+                }
+                apiChoices.push(processedChoice);
+            }
+            //Append results to current completions cache, and network cache
+            if (apiChoices.length > 0) {
+                for (const choice of apiChoices) {
+                    appendToCache(this.completionsCacheService, requestContext, choice);
+                }
+                this.instantiationService.invokeFunction(telemetryPerformance, 'cyclingPerformance', apiChoices[0], requestStart, processingTime);
+            }
             return {
-                type: 'failed',
-                reason: res.reason,
+                type: 'success',
+                value: [apiChoices, Promise.resolve()],
                 telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
+                telemetryBlob: baseTelemetryData,
+                resultType: ResultType.Cycling,
             };
+        });
+    }
+    async genericGetCompletionsFromNetwork(requestContext, baseTelemetryData, cancellationToken, finishedCb, what, processChoices) {
+        ghostTextLogger.debug(this.logTarget, `Getting ${what} from network`);
+        // copy the base telemetry data
+        baseTelemetryData = baseTelemetryData.extendedBy();
+        // Request one choice for automatic requests, three for invoked (cycling) requests.
+        const n = requestContext.isCycling ? 3 : 1;
+        const temperature = (0, openai_1.getTemperatureForSamples)(this.runtimeMode, n);
+        const extra = {
+            language: requestContext.languageId,
+            next_indent: requestContext.indentation.next ?? 0,
+            trim_by_indentation: (0, config_1.shouldDoServerTrimming)(requestContext.blockMode),
+            prompt_tokens: requestContext.prompt.prefixTokens ?? 0,
+            suffix_tokens: requestContext.prompt.suffixTokens ?? 0,
+        };
+        const postOptions = { n, temperature, code_annotations: false };
+        const modelTerminatesSingleline = this.featuresService.modelAlwaysTerminatesSingleline(baseTelemetryData);
+        const simulateSingleline = requestContext.blockMode === config_1.BlockMode.MoreMultiline &&
+            blockTrimmer_1.BlockTrimmer.isSupported(requestContext.languageId) &&
+            !modelTerminatesSingleline;
+        if (!requestContext.multiline && !simulateSingleline) {
+            // If we are not in multiline mode, we get the server to truncate the results. This does mean that we
+            // also cache a single line result which will be reused even if we are later in multiline mode. This is
+            // an acceptable trade-off as the transition should be relatively rare and truncating on the server is
+            // more efficient.
+            // Note that this also means we don't need to truncate when creating the GhostAPIChoice object below.
+            postOptions['stop'] = ['\n'];
         }
-        if (res.type === 'canceled') {
-            ghostTextLogger.debug(logTarget, 'Cancelled after awaiting fetchCompletions');
-            return {
-                type: 'canceled',
-                reason: res.reason,
-                telemetryData: (0, telemetry_3.mkCanceledResultTelemetry)(baseTelemetryData),
-            };
+        else if (requestContext.stop) {
+            postOptions['stop'] = requestContext.stop;
         }
-        return processChoices(requestStart, res.getProcessingTime(), res.choices);
-    }
-    catch (err) {
-        // If we cancelled a network request, we don't want to log an error
-        if ((0, networking_1.isAbortError)(err)) {
-            return {
-                type: 'canceled',
-                reason: 'network request aborted',
-                telemetryData: (0, telemetry_3.mkCanceledResultTelemetry)(baseTelemetryData, {
-                    cancelledNetworkRequest: true,
-                }),
+        if (requestContext.maxTokens !== undefined) {
+            postOptions['max_tokens'] = requestContext.maxTokens;
+        }
+        const requestStart = Date.now();
+        // extend telemetry data
+        const newProperties = {
+            endpoint: 'completions',
+            uiKind: fetch_1.CopilotUiKind.GhostText,
+            temperature: JSON.stringify(temperature),
+            n: JSON.stringify(n),
+            stop: JSON.stringify(postOptions['stop']) ?? 'unset',
+            logit_bias: JSON.stringify(null),
+        };
+        Object.assign(baseTelemetryData.properties, newProperties);
+        try {
+            const completionParams = {
+                prompt: requestContext.prompt,
+                languageId: requestContext.languageId,
+                repoInfo: requestContext.repoInfo,
+                ourRequestId: requestContext.ourRequestId,
+                engineModelId: requestContext.engineModelId,
+                count: n,
+                uiKind: fetch_1.CopilotUiKind.GhostText,
+                postOptions,
+                headers: requestContext.headers,
+                extra,
             };
+            const res = this.configurationService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.GhostTextUseCompletionsFetchService, this.expService)
+                ? await this.fetcherService.fetchAndStreamCompletions2(completionParams, baseTelemetryData, finishedCb, cancellationToken)
+                : await this.fetcherService.fetchAndStreamCompletions(completionParams, baseTelemetryData, finishedCb, cancellationToken);
+            if (res.type === 'failed') {
+                return {
+                    type: 'failed',
+                    reason: res.reason,
+                    telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
+                };
+            }
+            if (res.type === 'canceled') {
+                ghostTextLogger.debug(this.logTarget, 'Cancelled after awaiting fetchCompletions');
+                return {
+                    type: 'canceled',
+                    reason: res.reason,
+                    telemetryData: (0, telemetry_3.mkCanceledResultTelemetry)(baseTelemetryData),
+                };
+            }
+            return processChoices(requestStart, res.getProcessingTime(), res.choices);
         }
-        else {
-            instantiationService.invokeFunction(acc => ghostTextLogger.exception(acc, err, `Error on ghost text request`));
-            userErrorNotifier.notifyUser(err);
-            if (runtimeMode.shouldFailForDebugPurposes()) {
-                throw err;
+        catch (err) {
+            // If we cancelled a network request, we don't want to log an error
+            if ((0, networking_1.isAbortError)(err)) {
+                return {
+                    type: 'canceled',
+                    reason: 'network request aborted',
+                    telemetryData: (0, telemetry_3.mkCanceledResultTelemetry)(baseTelemetryData, {
+                        cancelledNetworkRequest: true,
+                    }),
+                };
+            }
+            else {
+                this.instantiationService.invokeFunction(acc => ghostTextLogger.exception(acc, err, `Error on ghost text request`));
+                this.userErrorNotifier.notifyUser(err);
+                if (this.runtimeMode.shouldFailForDebugPurposes()) {
+                    throw err;
+                }
+                // not including err in this result because it'll end up in standard telemetry
+                return {
+                    type: 'failed',
+                    reason: 'non-abort error on ghost text request',
+                    telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
+                };
             }
-            // not including err in this result because it'll end up in standard telemetry
-            return {
-                type: 'failed',
-                reason: 'non-abort error on ghost text request',
-                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
-            };
         }
     }
-}
+};
+exports.CompletionsFromNetwork = CompletionsFromNetwork;
+exports.CompletionsFromNetwork = CompletionsFromNetwork = __decorate([
+    __param(0, instantiation_1.IInstantiationService),
+    __param(1, fetch_1.ICompletionsOpenAIFetcherService),
+    __param(2, featuresService_1.ICompletionsFeaturesService),
+    __param(3, runtimeMode_1.ICompletionsRuntimeModeService),
+    __param(4, logger_1.ICompletionsLogTargetService),
+    __param(5, completionsCache_1.ICompletionsCacheService),
+    __param(6, userErrorNotifier_1.ICompletionsUserErrorNotifierService),
+    __param(7, configurationService_1.IConfigurationService),
+    __param(8, nullExperimentationService_1.IExperimentationService)
+], CompletionsFromNetwork);
 /**
  * Post-proceses a completion choice based on the current request context and existing choices.
  */
-function postProcessChoices(newChoice, requestContext, currentChoices) {
+function postProcessChoices(newChoice, currentChoices) {
     if (!currentChoices) {
         currentChoices = [];
     }
@@ -178,129 +324,6 @@ function postProcessChoices(newChoice, requestContext, currentChoices) {
     }
     return newChoice;
 }
-/** Requests new completion from OpenAI, should be called if and only if the completions for given prompt were not cached before.
- *  It returns only first completion, additional completions are added to the caches in the background.
- *  Copies from the base telemetry data are used as the basis for each choice's telemetry.
- */
-async function getCompletionsFromNetwork(accessor, requestContext, baseTelemetryData, cancellationToken, finishedCb) {
-    const instantiationService = accessor.get(instantiation_1.IInstantiationService);
-    const logTarget = accessor.get(logger_1.ICompletionsLogTargetService);
-    const runtimeMode = accessor.get(runtimeMode_1.ICompletionsRuntimeModeService);
-    return genericGetCompletionsFromNetwork(accessor, requestContext, baseTelemetryData, cancellationToken, finishedCb, 'completions', async (requestStart, processingTime, choicesStream) => {
-        const choicesIterator = choicesStream[Symbol.asyncIterator]();
-        const firstRes = await choicesIterator.next();
-        if (firstRes.done) {
-            ghostTextLogger.debug(logTarget, 'All choices redacted');
-            return {
-                type: 'empty',
-                reason: 'all choices redacted',
-                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
-            };
-        }
-        if (cancellationToken?.isCancellationRequested) {
-            ghostTextLogger.debug(logTarget, 'Cancelled after awaiting redactedChoices iterator');
-            return {
-                type: 'canceled',
-                reason: 'after awaiting redactedChoices iterator',
-                telemetryData: (0, telemetry_3.mkCanceledResultTelemetry)(baseTelemetryData),
-            };
-        }
-        const firstChoice = firstRes.value;
-        if (firstChoice === undefined) {
-            // This is probably unreachable given the firstRes.done check above
-            ghostTextLogger.debug(logTarget, 'Got undefined choice from redactedChoices iterator');
-            return {
-                type: 'empty',
-                reason: 'got undefined choice from redactedChoices iterator',
-                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
-            };
-        }
-        instantiationService.invokeFunction(telemetryPerformance, 'performance', firstChoice, requestStart, processingTime);
-        ghostTextLogger.debug(logTarget, `Awaited first result, id:  ${firstChoice.choiceIndex}`);
-        // Adds first result to cache
-        const processedFirstChoice = postProcessChoices(firstChoice, requestContext);
-        if (processedFirstChoice) {
-            instantiationService.invokeFunction(appendToCache, requestContext, processedFirstChoice);
-            ghostTextLogger.debug(logTarget, `GhostText first completion (index ${processedFirstChoice?.choiceIndex}): ${JSON.stringify(processedFirstChoice?.completionText)}`);
-        }
-        //Create promise for each result, don't `await` it (unless in test mode) but handle asynchronously with `.then()`
-        const cacheDone = (async () => {
-            const apiChoices = processedFirstChoice !== undefined ? [processedFirstChoice] : [];
-            for await (const choice of choicesStream) {
-                if (choice === undefined) {
-                    continue;
-                }
-                ghostTextLogger.debug(logTarget, `GhostText later completion (index ${choice?.choiceIndex}): ${JSON.stringify(choice.completionText)}`);
-                const processedChoice = postProcessChoices(choice, requestContext, apiChoices);
-                if (!processedChoice) {
-                    continue;
-                }
-                apiChoices.push(processedChoice);
-                instantiationService.invokeFunction(appendToCache, requestContext, processedChoice);
-            }
-        })();
-        if (runtimeMode.isRunningInTest()) {
-            await cacheDone;
-        }
-        if (processedFirstChoice) {
-            // Because we ask the server to stop at \n above, we don't need to force single line here
-            return {
-                type: 'success',
-                value: [makeGhostAPIChoice(processedFirstChoice, { forceSingleLine: false }), cacheDone],
-                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
-                telemetryBlob: baseTelemetryData,
-                resultType: ResultType.Network,
-            };
-        }
-        else {
-            return {
-                type: 'empty',
-                reason: 'got undefined processedFirstChoice',
-                telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
-            };
-        }
-    });
-}
-/** Requests new completion from OpenAI, should be called if and only if we are in the servers-side termination mode, and it's follow-up cycling request
- *  It returns all requested completions
- *  Copies from the base telemetry data are used as the basis for each choice's telemetry.
- */
-async function getAllCompletionsFromNetwork(accessor, requestContext, baseTelemetryData, cancellationToken, finishedCb) {
-    const logTarget = accessor.get(logger_1.ICompletionsLogTargetService);
-    const instantiationService = accessor.get(instantiation_1.IInstantiationService);
-    return genericGetCompletionsFromNetwork(accessor, requestContext, baseTelemetryData, cancellationToken, finishedCb, 'all completions', async (requestStart, processingTime, choicesStream) => {
-        const apiChoices = [];
-        for await (const choice of choicesStream) {
-            if (cancellationToken?.isCancellationRequested) {
-                ghostTextLogger.debug(logTarget, 'Cancelled after awaiting choices iterator');
-                return {
-                    type: 'canceled',
-                    reason: 'after awaiting choices iterator',
-                    telemetryData: (0, telemetry_3.mkCanceledResultTelemetry)(baseTelemetryData),
-                };
-            }
-            const processedChoice = postProcessChoices(choice, requestContext, apiChoices);
-            if (!processedChoice) {
-                continue;
-            }
-            apiChoices.push(processedChoice);
-        }
-        //Append results to current completions cache, and network cache
-        if (apiChoices.length > 0) {
-            for (const choice of apiChoices) {
-                instantiationService.invokeFunction(appendToCache, requestContext, choice);
-            }
-            instantiationService.invokeFunction(telemetryPerformance, 'cyclingPerformance', apiChoices[0], requestStart, processingTime);
-        }
-        return {
-            type: 'success',
-            value: [apiChoices, Promise.resolve()],
-            telemetryData: (0, telemetry_3.mkBasicResultTelemetry)(baseTelemetryData),
-            telemetryBlob: baseTelemetryData,
-            resultType: ResultType.Cycling,
-        };
-    });
-}
 function makeGhostAPIChoice(choice, options) {
     const ghostChoice = { ...choice };
     if (options.forceSingleLine) {
@@ -416,12 +439,13 @@ function buildFinishedCallback(accessor, blockMode, document, position, position
         const lookAhead = positionType === blockTrimmer_1.BlockPositionType.EmptyBlock || positionType === blockTrimmer_1.BlockPositionType.BlockEnd
             ? featuresService.longLookaheadSize(telemetryData)
             : featuresService.shortLookaheadSize(telemetryData);
+        const completionsCacheService = accessor.get(completionsCache_1.ICompletionsCacheService);
         const finishedCb = instantiationService.createInstance(streamedCompletionSplitter_1.StreamedCompletionSplitter, prefix, document.detectedLanguageId, false, lookAhead, (extraPrefix, item) => {
             const cacheContext = {
                 prefix: prefix + extraPrefix,
                 prompt: { ...prompt, prefix: prompt.prefix + extraPrefix },
             };
-            instantiationService.invokeFunction(appendToCache, cacheContext, item);
+            appendToCache(completionsCacheService, cacheContext, item);
         }).getFinishedCallback();
         return {
             finishedCb,
@@ -627,8 +651,9 @@ async function getGhostTextWithoutAbortHandling(accessor, completionState, ourRe
         }
         else {
             // No local choices, go to network
+            const completionsFromNetwork = instantiationService.createInstance(CompletionsFromNetwork);
             if (ghostTextOptions.isCycling) {
-                const networkChoices = await instantiationService.invokeFunction(getAllCompletionsFromNetwork, requestContext, telemetryData, cancellationToken, ghostTextStrategy.finishedCb);
+                const networkChoices = await completionsFromNetwork.getAllCompletionsFromNetwork(requestContext, telemetryData, cancellationToken, ghostTextStrategy.finishedCb);
                 // TODO: if we already had some choices cached from the initial non-cycling request,
                 // and then the cycling request returns no results for some reason, we need to still
                 // return the original choices to the editor to avoid the ghost text disappearing completely.
@@ -663,7 +688,7 @@ async function getGhostTextWithoutAbortHandling(accessor, completionState, ourRe
                     return ghostTextStrategy.finishedCb(text, delta);
                 };
                 const asyncCancellationTokenSource = new src_1.CancellationTokenSource();
-                const requestPromise = instantiationService.invokeFunction(getCompletionsFromNetwork, requestContext, telemetryData, asyncCancellationTokenSource.token, finishedCb);
+                const requestPromise = completionsFromNetwork.getCompletionsFromNetwork(requestContext, telemetryData, asyncCancellationTokenSource.token, finishedCb);
                 void asyncCompletionManager.queueCompletionRequest(ourRequestId, prefix, prompt.prompt, asyncCancellationTokenSource, requestPromise);
                 const c = await asyncCompletionManager.getFirstMatchingRequest(ourRequestId, prefix, prompt.prompt, ghostTextOptions.isSpeculative);
                 if (c === undefined) {
@@ -925,8 +950,8 @@ async function shouldRequestMultiline(accessor, blockMode, document, position, i
     return { requestMultiline: false };
 }
 /** Appends completions to existing entry in cache or creates new entry. */
-function appendToCache(accessor, requestContext, choice) {
-    accessor.get(completionsCache_1.ICompletionsCacheService).append(requestContext.prefix, requestContext.prompt.suffix, choice);
+function appendToCache(competionsCacheService, requestContext, choice) {
+    competionsCacheService.append(requestContext.prefix, requestContext.prompt.suffix, choice);
 }
 function adjustLeadingWhitespace(index, text, ws) {
     if (ws.length > 0) {