@vscode/chat-lib 0.1.2 → 0.1.3-0

package/dist/src/_internal/extension/prompt/node/chatMLFetcher.js

@@ -47,30 +47,41 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChatMLFetcherImpl = exports.AbstractChatMLFetcher = void 0;
+exports.createTelemetryData = createTelemetryData;
+exports.locationToIntent = locationToIntent;
 const prompt_tsx_1 = require("@vscode/prompt-tsx");
+const authentication_1 = require("../../../platform/authentication/common/authentication");
 const chatMLFetcher_1 = require("../../../platform/chat/common/chatMLFetcher");
+const chatQuotaService_1 = require("../../../platform/chat/common/chatQuotaService");
 const commonTypes_1 = require("../../../platform/chat/common/commonTypes");
 const conversationOptions_1 = require("../../../platform/chat/common/conversationOptions");
 const globalStringUtils_1 = require("../../../platform/chat/common/globalStringUtils");
+const interactionService_1 = require("../../../platform/chat/common/interactionService");
 const configurationService_1 = require("../../../platform/configuration/common/configurationService");
+const capiClient_1 = require("../../../platform/endpoint/common/capiClient");
 const autoChatEndpoint_1 = require("../../../platform/endpoint/node/autoChatEndpoint");
 const logService_1 = require("../../../platform/log/common/logService");
+const fetch_1 = require("../../../platform/networking/common/fetch");
 const fetcherService_1 = require("../../../platform/networking/common/fetcherService");
+const networking_1 = require("../../../platform/networking/common/networking");
 const openai_1 = require("../../../platform/networking/common/openai");
-const fetch_1 = require("../../../platform/openai/node/fetch");
+const chatStream_1 = require("../../../platform/networking/node/chatStream");
+const stream_1 = require("../../../platform/networking/node/stream");
+const fetch_2 = require("../../../platform/openai/node/fetch");
 const requestLogger_1 = require("../../../platform/requestLogger/node/requestLogger");
+const nullExperimentationService_1 = require("../../../platform/telemetry/common/nullExperimentationService");
 const telemetry_1 = require("../../../platform/telemetry/common/telemetry");
 const telemetryData_1 = require("../../../platform/telemetry/common/telemetryData");
 const anomalyDetection_1 = require("../../../util/common/anomalyDetection");
+const crypto_1 = require("../../../util/common/crypto");
 const errorsUtil = __importStar(require("../../../util/common/errors"));
 const errors_1 = require("../../../util/vs/base/common/errors");
 const event_1 = require("../../../util/vs/base/common/event");
+const strings_1 = require("../../../util/vs/base/common/strings");
 const uuid_1 = require("../../../util/vs/base/common/uuid");
-const instantiation_1 = require("../../../util/vs/platform/instantiation/common/instantiation");
 const openAIEndpoint_1 = require("../../byok/node/openAIEndpoint");
 const constants_1 = require("../../common/constants");
-const authentication_1 = require("../../../platform/authentication/common/authentication");
-const strings_1 = require("../../../util/vs/base/common/strings");
+const chatMLFetcherTelemetry_1 = require("./chatMLFetcherTelemetry");
 class AbstractChatMLFetcher {
     constructor(options) {
         this.options = options;
@@ -99,14 +110,18 @@ class AbstractChatMLFetcher {
 }
 exports.AbstractChatMLFetcher = AbstractChatMLFetcher;
 let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
-    constructor(_fetcherService, _telemetryService, _requestLogger, _logService, _authenticationService, _instantiationService, options) {
+    constructor(_fetcherService, _telemetryService, _requestLogger, _logService, _authenticationService, _interactionService, _chatQuotaService, _capiClientService, options, _configurationService, _experimentationService) {
         super(options);
         this._fetcherService = _fetcherService;
         this._telemetryService = _telemetryService;
         this._requestLogger = _requestLogger;
         this._logService = _logService;
         this._authenticationService = _authenticationService;
-        this._instantiationService = _instantiationService;
+        this._interactionService = _interactionService;
+        this._chatQuotaService = _chatQuotaService;
+        this._capiClientService = _capiClientService;
+        this._configurationService = _configurationService;
+        this._experimentationService = _experimentationService;
     }
     /**
      * Note: the returned array of strings may be less than `n` (e.g., in case there were errors during streaming)
@@ -130,7 +145,7 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
             delete requestOptions['prediction'];
         }
         const postOptions = this.preparePostOptions(requestOptions);
-        const requestBody = await chatEndpoint.createRequestBody({
+        const requestBody = chatEndpoint.createRequestBody({
             ...opts,
             requestId: ourRequestId,
             postOptions
@@ -151,19 +166,22 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
         let tokenCount = -1;
         const streamRecorder = new chatMLFetcher_1.FetchStreamRecorder(finishedCb);
         const enableRetryOnError = opts.enableRetryOnError ?? opts.enableRetryOnFilter;
+        let usernameToScrub;
         try {
             let response;
             const payloadValidationResult = isValidChatPayload(opts.messages, postOptions);
             if (!payloadValidationResult.isValid) {
                 response = {
-                    type: fetch_1.FetchResponseKind.Failed,
+                    type: fetch_2.FetchResponseKind.Failed,
                     modelRequestId: undefined,
-                    failKind: fetch_1.ChatFailKind.ValidationFailed,
+                    failKind: fetch_2.ChatFailKind.ValidationFailed,
                     reason: payloadValidationResult.reason,
                 };
             }
             else {
-                response = await this._instantiationService.invokeFunction(accessor => (0, fetch_1.fetchAndStreamChat)(accessor, chatEndpoint, requestBody, baseTelemetry, streamRecorder.callback, requestOptions.secretKey, opts.location, ourRequestId, postOptions.n, userInitiatedRequest, token, telemetryProperties, opts.useFetcher));
+                const copilotToken = await this._authenticationService.getCopilotToken();
+                usernameToScrub = copilotToken.username;
+                response = await this._fetchAndStreamChat(chatEndpoint, requestBody, baseTelemetry, streamRecorder.callback, requestOptions.secretKey, copilotToken, opts.location, ourRequestId, postOptions.n, token, userInitiatedRequest, telemetryProperties, opts.useFetcher);
                 tokenCount = await chatEndpoint.acquireTokenizer().countMessagesTokens(messages);
                 const extensionId = source?.extensionId ?? constants_1.EXTENSION_ID;
                 this._onDidMakeChatMLRequest.fire({
@@ -176,7 +194,7 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
             const timeToFirstToken = Date.now() - baseTelemetry.issuedTime;
             pendingLoggedChatRequest?.markTimeToFirstToken(timeToFirstToken);
             switch (response.type) {
-                case fetch_1.FetchResponseKind.Success: {
+                case fetch_2.FetchResponseKind.Success: {
                     const result = await this.processSuccessfulResponse(response, messages, requestBody, ourRequestId, maxResponseTokens, tokenCount, timeToFirstToken, streamRecorder, baseTelemetry, chatEndpoint, userInitiatedRequest);
                     // Handle FilteredRetry case with augmented messages
                     if (result.type === commonTypes_1.ChatFetchResponseType.FilteredRetry) {
@@ -226,15 +244,17 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
                     pendingLoggedChatRequest?.resolve(result, streamRecorder.deltas);
                     return result;
                 }
-                case fetch_1.FetchResponseKind.Canceled:
-                    this._sendCancellationTelemetry({
+                case fetch_2.FetchResponseKind.Canceled:
+                    chatMLFetcherTelemetry_1.ChatMLFetcherTelemetrySender.sendCancellationTelemetry(this._telemetryService, {
                         source: telemetryProperties.messageSource ?? 'unknown',
                         requestId: ourRequestId,
                         model: chatEndpoint.model,
                         apiType: chatEndpoint.apiType,
                         associatedRequestId: telemetryProperties.associatedRequestId,
-                        ...(telemetryProperties.retryAfterErrorCategory ? { retryAfterErrorCategory: telemetryProperties.retryAfterErrorCategory } : {}),
-                        ...(telemetryProperties.retryAfterFilterCategory ? { retryAfterFilterCategory: telemetryProperties.retryAfterFilterCategory } : {}),
+                        retryAfterErrorCategory: telemetryProperties.retryAfterErrorCategory,
+                        retryAfterError: telemetryProperties.retryAfterError,
+                        connectivityTestError: telemetryProperties.connectivityTestError,
+                        retryAfterFilterCategory: telemetryProperties.retryAfterFilterCategory,
                     }, {
                         totalTokenMax: chatEndpoint.modelMaxPromptTokens ?? -1,
                         promptTokenCount: tokenCount,
@@ -248,9 +268,9 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
                     });
                     pendingLoggedChatRequest?.resolveWithCancelation();
                     return this.processCanceledResponse(response, ourRequestId);
-                case fetch_1.FetchResponseKind.Failed: {
+                case fetch_2.FetchResponseKind.Failed: {
                     const processed = this.processFailedResponse(response, ourRequestId);
-                    this._sendResponseErrorTelemetry(processed, telemetryProperties, ourRequestId, chatEndpoint, requestBody, tokenCount, maxResponseTokens, timeToFirstToken, this.filterImageMessages(messages));
+                    chatMLFetcherTelemetry_1.ChatMLFetcherTelemetrySender.sendResponseErrorTelemetry(this._telemetryService, processed, telemetryProperties, chatEndpoint, requestBody, tokenCount, maxResponseTokens, timeToFirstToken, this.filterImageMessages(messages));
                     pendingLoggedChatRequest?.resolve(processed);
                     return processed;
                 }
@@ -258,38 +278,59 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
         }
         catch (err) {
             const timeToError = Date.now() - baseTelemetry.issuedTime;
-            const processed = this.processError(err, ourRequestId);
-            if (['darwin', 'linux'].includes(process.platform) && processed.type === commonTypes_1.ChatFetchResponseType.NetworkError && processed.reason.indexOf('net::ERR_NETWORK_CHANGED') !== -1) {
-                if (enableRetryOnError) {
-                    this._logService.info('Retrying chat request with node-fetch after net::ERR_NETWORK_CHANGED error.');
-                    streamRecorder.callback('', 0, { text: '', retryReason: 'network_error' });
-                    // Retry with other fetchers
-                    const retryResult = await this.fetchMany({
-                        ...opts,
-                        debugName: 'retry-error-' + debugName,
-                        messages,
-                        finishedCb,
-                        location,
-                        endpoint: chatEndpoint,
-                        source,
-                        requestOptions,
-                        userInitiatedRequest: false, // do not mark the retry as user initiated
-                        telemetryProperties: { ...telemetryProperties, retryAfterErrorCategory: 'electron-network-changed' },
-                        enableRetryOnFilter: opts.enableRetryOnFilter,
-                        enableRetryOnError: false,
-                        useFetcher: 'node-fetch',
-                    }, token);
-                    pendingLoggedChatRequest?.resolve(retryResult, streamRecorder.deltas);
-                    return retryResult;
+            const processed = this.processError(err, ourRequestId, usernameToScrub);
+            let connectivityTestError = telemetryProperties.connectivityTestError;
+            if (processed.type === commonTypes_1.ChatFetchResponseType.NetworkError && enableRetryOnError) {
+                // Keep existing handling of net::ERR_NETWORK_CHANGED: https://github.com/microsoft/vscode/issues/260297
+                const isNetworkChangedError = ['darwin', 'linux'].includes(process.platform) && processed.reason.indexOf('net::ERR_NETWORK_CHANGED') !== -1;
+                const isRetryNetworkErrorEnabled = this._configurationService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.RetryNetworkErrors, this._experimentationService);
+                if (isNetworkChangedError || isRetryNetworkErrorEnabled) {
+                    const useFetcher = isNetworkChangedError ? 'node-fetch' : opts.useFetcher;
+                    this._logService.info(`Retrying chat request with ${useFetcher || 'default'} fetcher after: ${processed.reasonDetail || processed.reason}`);
+                    // Keep existing handling of net::ERR_NETWORK_CHANGED if setting is not enabled: https://github.com/microsoft/vscode/issues/260297
+                    const connectivity = !isRetryNetworkErrorEnabled ? { retryRequest: true } : await this._checkNetworkConnectivity(useFetcher);
+                    connectivityTestError = connectivity.connectivityTestError ? this.scrubErrorDetail(connectivity.connectivityTestError, usernameToScrub) : undefined;
+                    if (connectivity.retryRequest) {
+                        streamRecorder.callback('', 0, { text: '', retryReason: 'network_error' });
+                        const retryResult = await this.fetchMany({
+                            ...opts,
+                            debugName: 'retry-error-' + debugName,
+                            messages,
+                            finishedCb,
+                            location,
+                            endpoint: chatEndpoint,
+                            source,
+                            requestOptions,
+                            userInitiatedRequest: false, // do not mark the retry as user initiated
+                            telemetryProperties: {
+                                ...telemetryProperties,
+                                retryAfterErrorCategory: processed.reasonDetail || processed.reason,
+                                retryAfterError: processed.reasonDetail || processed.reason,
+                                connectivityTestError,
+                            },
+                            enableRetryOnFilter: opts.enableRetryOnFilter,
+                            enableRetryOnError: false,
+                            useFetcher,
+                        }, token);
+                        pendingLoggedChatRequest?.resolve(retryResult, streamRecorder.deltas);
+                        return retryResult;
+                    }
+                    else {
+                        this._logService.info(`Not retrying chat request as network connectivity could not be re-established.`);
+                    }
                 }
             }
             if (processed.type === commonTypes_1.ChatFetchResponseType.Canceled) {
-                this._sendCancellationTelemetry({
+                chatMLFetcherTelemetry_1.ChatMLFetcherTelemetrySender.sendCancellationTelemetry(this._telemetryService, {
                     source: telemetryProperties.messageSource ?? 'unknown',
                     requestId: ourRequestId,
                     model: chatEndpoint.model,
                     apiType: chatEndpoint.apiType,
-                    associatedRequestId: telemetryProperties.associatedRequestId
+                    associatedRequestId: telemetryProperties.associatedRequestId,
+                    retryAfterErrorCategory: telemetryProperties.retryAfterErrorCategory,
+                    retryAfterError: telemetryProperties.retryAfterError,
+                    connectivityTestError,
+                    retryAfterFilterCategory: telemetryProperties.retryAfterFilterCategory,
                 }, {
                     totalTokenMax: chatEndpoint.modelMaxPromptTokens ?? -1,
                     promptTokenCount: tokenCount,
@@ -302,170 +343,407 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
                 });
             }
             else {
-                this._sendResponseErrorTelemetry(processed, telemetryProperties, ourRequestId, chatEndpoint, requestBody, tokenCount, maxResponseTokens, timeToError, this.filterImageMessages(messages));
+                chatMLFetcherTelemetry_1.ChatMLFetcherTelemetrySender.sendResponseErrorTelemetry(this._telemetryService, processed, { ...telemetryProperties, connectivityTestError }, chatEndpoint, requestBody, tokenCount, maxResponseTokens, timeToError, this.filterImageMessages(messages));
             }
             pendingLoggedChatRequest?.resolve(processed);
             return processed;
         }
     }
-    _sendCancellationTelemetry({ source, requestId, model, apiType, associatedRequestId }, { totalTokenMax, promptTokenCount, tokenCountMax, timeToFirstToken, timeToFirstTokenEmitted, timeToCancelled, isVisionRequest, isBYOK, isAuto }) {
-        /* __GDPR__
-            "response.cancelled" : {
-                "owner": "digitarald",
-                "comment": "Report canceled service responses for quality.",
-                "model": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Model selection for the response" },
-                "apiType": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "API type for the response- chat completions or responses" },
-                "source": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Source for why the request was made" },
-                "requestId": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Id of the request" },
-                "associatedRequestId": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Another request ID that this request is associated with (eg, the originating request of a summarization request)." },
-                "totalTokenMax": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Maximum total token window", "isMeasurement": true },
-                "promptTokenCount": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Number of prompt tokens", "isMeasurement": true },
-                "tokenCountMax": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Maximum generated tokens", "isMeasurement": true },
-                "timeToFirstToken": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Time to first token", "isMeasurement": true },
-                "timeToFirstTokenEmitted": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Time to first token emitted (visible text)", "isMeasurement": true },
-                "timeToCancelled": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Time to first token", "isMeasurement": true },
-                "isVisionRequest": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Whether the request was for a vision model", "isMeasurement": true },
-                "isBYOK": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Whether the request was for a BYOK model", "isMeasurement": true },
-                "isAuto": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Whether the request was for an Auto model", "isMeasurement": true },
-                "retryAfterErrorCategory": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "If the response failed and this is a retry attempt, this contains the error category." },
-                "retryAfterFilterCategory": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "If the response was filtered and this is a retry attempt, this contains the original filtered content category." }
+    async _checkNetworkConnectivity(useFetcher) {
+        // Ping CAPI to check network connectivity before retrying
+        const delays = [1000, 10000, 10000];
+        let connectivityTestError = undefined;
+        for (const delay of delays) {
+            this._logService.info(`Waiting ${delay}ms before pinging CAPI to check network connectivity...`);
+            await new Promise(resolve => setTimeout(resolve, delay));
+            try {
+                const isGHEnterprise = this._capiClientService.dotcomAPIURL !== 'https://api.github.com';
+                const url = this._capiClientService.capiPingURL;
+                const headers = await this._getAuthHeaders(isGHEnterprise, url);
+                const res = await this._fetcherService.fetch(url, {
+                    headers,
+                    useFetcher,
+                });
+                if (res.status >= 200 && res.status < 300) {
+                    this._logService.info(`CAPI ping successful, proceeding with chat request retry...`);
+                    return { retryRequest: true, connectivityTestError };
+                }
+                else {
+                    connectivityTestError = `Status ${res.status}: ${res.statusText}`;
+                    this._logService.info(`CAPI ping returned status ${res.status}, retrying ping...`);
+                }
             }
-        */
-        this._telemetryService.sendTelemetryEvent('response.cancelled', { github: true, microsoft: true }, {
-            apiType,
-            source,
-            requestId,
-            model,
-            associatedRequestId,
-        }, {
-            totalTokenMax,
-            promptTokenCount,
-            tokenCountMax,
-            timeToFirstToken,
-            timeToFirstTokenEmitted,
-            timeToCancelled,
-            isVisionRequest,
-            isBYOK,
-            isAuto
-        });
+            catch (err) {
+                connectivityTestError = (0, logService_1.collectSingleLineErrorMessage)(err);
+                this._logService.info(`CAPI ping failed with error, retrying ping: ${connectivityTestError}`);
+            }
+        }
+        return { retryRequest: false, connectivityTestError };
     }
-    _sendResponseErrorTelemetry(processed, telemetryProperties, ourRequestId, chatEndpointInfo, requestBody, tokenCount, maxResponseTokens, timeToFirstToken, isVisionRequest) {
-        /* __GDPR__
-            "response.error" : {
-                "owner": "digitarald",
-                "comment": "Report quality issue for when a service response failed.",
-                "type": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Type of issue" },
-                "reason": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Reason of issue" },
-                "model": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Model selection for the response" },
-                "apiType": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "API type for the response- chat completions or responses" },
-                "source": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Source for why the request was made" },
-                "requestId": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Id of the request" },
-                "associatedRequestId": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Another request ID that this request is associated with (eg, the originating request of a summarization request)." },
-                "reasoningEffort": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Reasoning effort level" },
-                "reasoningSummary": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Reasoning summary level" },
-                "totalTokenMax": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Maximum total token window", "isMeasurement": true },
-                "promptTokenCount": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Number of prompt tokens", "isMeasurement": true },
-                "tokenCountMax": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Maximum generated tokens", "isMeasurement": true },
-                "timeToFirstToken": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Time to first token", "isMeasurement": true },
-                "timeToFirstTokenEmitted": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Time to first token emitted (visible text)", "isMeasurement": true },
-                "isVisionRequest": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Whether the request was for a vision model", "isMeasurement": true },
-                "isBYOK": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Whether the request was for a BYOK model", "isMeasurement": true },
-                "isAuto": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Whether the request was for an Auto model", "isMeasurement": true },
-                "retryAfterErrorCategory": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "If the response failed and this is a retry attempt, this contains the error category." },
-                "retryAfterFilterCategory": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "If the response was filtered and this is a retry attempt, this contains the original filtered content category." }
+    async _getAuthHeaders(isGHEnterprise, url) {
+        const authHeaders = {};
+        if (isGHEnterprise) {
+            let token = '';
+            if (url === this._capiClientService.dotcomAPIURL) {
+                token = this._authenticationService.anyGitHubSession?.accessToken || '';
             }
-        */
-        this._telemetryService.sendTelemetryEvent('response.error', { github: true, microsoft: true }, {
-            type: processed.type,
-            reason: processed.reasonDetail || processed.reason,
-            source: telemetryProperties?.messageSource ?? 'unknown',
-            requestId: ourRequestId,
-            model: chatEndpointInfo.model,
-            apiType: chatEndpointInfo.apiType,
-            reasoningEffort: requestBody.reasoning?.effort,
-            reasoningSummary: requestBody.reasoning?.summary,
-            associatedRequestId: telemetryProperties?.associatedRequestId,
-            ...(telemetryProperties?.retryAfterErrorCategory ? { retryAfterErrorCategory: telemetryProperties.retryAfterErrorCategory } : {}),
-            ...(telemetryProperties?.retryAfterFilterCategory ? { retryAfterFilterCategory: telemetryProperties.retryAfterFilterCategory } : {})
+            else {
+                try {
+                    token = (await this._authenticationService.getCopilotToken()).token;
+                }
+                catch (_err) {
+                    // Ignore error
+                    token = '';
+                }
+            }
+            authHeaders['Authorization'] = `Bearer ${token}`;
+        }
+        return authHeaders;
+    }
+    async _fetchAndStreamChat(chatEndpointInfo, request, baseTelemetryData, finishedCb, secretKey, copilotToken, location, ourRequestId, nChoices, cancellationToken, userInitiatedRequest, telemetryProperties, useFetcher) {
+        if (cancellationToken.isCancellationRequested) {
+            return { type: fetch_2.FetchResponseKind.Canceled, reason: 'before fetch request' };
+        }
+        this._logService.debug(`modelMaxPromptTokens ${chatEndpointInfo.modelMaxPromptTokens}`);
+        this._logService.debug(`modelMaxResponseTokens ${request.max_tokens ?? 2048}`);
+        this._logService.debug(`chat model ${chatEndpointInfo.model}`);
+        secretKey ??= copilotToken.token;
+        if (!secretKey) {
+            // If no key is set we error
+            const urlOrRequestMetadata = (0, networking_1.stringifyUrlOrRequestMetadata)(chatEndpointInfo.urlOrRequestMetadata);
+            this._logService.error(`Failed to send request to ${urlOrRequestMetadata} due to missing key`);
+            (0, stream_1.sendCommunicationErrorTelemetry)(this._telemetryService, `Failed to send request to ${urlOrRequestMetadata} due to missing key`);
+            return {
+                type: fetch_2.FetchResponseKind.Failed,
+                modelRequestId: undefined,
+                failKind: fetch_2.ChatFailKind.TokenExpiredOrInvalid,
+                reason: 'key is missing'
+            };
+        }
+        // Generate unique ID to link input and output messages
+        const modelCallId = (0, uuid_1.generateUuid)();
+        const response = await this._fetchWithInstrumentation(chatEndpointInfo, ourRequestId, request, secretKey, location, cancellationToken, userInitiatedRequest, { ...telemetryProperties, modelCallId }, useFetcher);
+        if (cancellationToken.isCancellationRequested) {
+            const body = await response.body();
+            try {
+                // Destroy the stream so that the server is hopefully notified we don't want any more data
+                // and can cancel/forget about the request itself.
+                body.destroy();
+            }
+            catch (e) {
+                this._logService.error(e, `Error destroying stream`);
+                this._telemetryService.sendGHTelemetryException(e, 'Error destroying stream');
+            }
+            return { type: fetch_2.FetchResponseKind.Canceled, reason: 'after fetch request' };
+        }
+        if (response.status === 200 && this._authenticationService.copilotToken?.isFreeUser && this._authenticationService.copilotToken?.isChatQuotaExceeded) {
+            this._authenticationService.resetCopilotToken();
+        }
+        if (response.status !== 200) {
+            const telemetryData = createTelemetryData(chatEndpointInfo, location, ourRequestId);
+            this._logService.info('Request ID for failed request: ' + ourRequestId);
+            return this._handleError(telemetryData, response, ourRequestId);
+        }
+        // Extend baseTelemetryData with modelCallId for output messages
+        const extendedBaseTelemetryData = baseTelemetryData.extendedBy({ modelCallId });
+        const chatCompletions = await chatEndpointInfo.processResponseFromChatEndpoint(this._telemetryService, this._logService, response, nChoices ?? /* OpenAI's default */ 1, finishedCb, extendedBaseTelemetryData, cancellationToken);
+        // CAPI will return us a Copilot Edits Session Header which is our token to using the speculative decoding endpoint
+        // We should store this in the auth service for easy use later
+        if (response.headers.get('Copilot-Edits-Session')) {
+            this._authenticationService.speculativeDecodingEndpointToken = response.headers.get('Copilot-Edits-Session') ?? undefined;
+        }
+        this._chatQuotaService.processQuotaHeaders(response.headers);
+        return {
+            type: fetch_2.FetchResponseKind.Success,
+            chatCompletions,
+        };
+    }
+    async _fetchWithInstrumentation(chatEndpoint, ourRequestId, request, secretKey, location, cancellationToken, userInitiatedRequest, telemetryProperties, useFetcher) {
+        // If request contains an image, we include this header.
+        const additionalHeaders = {
+            'X-Interaction-Id': this._interactionService.interactionId,
+            'X-Initiator': userInitiatedRequest ? 'user' : 'agent', // Agent = a system request / not the primary user query.
+        };
+        if (request.messages?.some((m) => Array.isArray(m.content) ? m.content.some(c => 'image_url' in c) : false) && chatEndpoint.supportsVision) {
+            additionalHeaders['Copilot-Vision-Request'] = 'true';
+        }
+        const telemetryData = telemetryData_1.TelemetryData.createAndMarkAsIssued({
+            endpoint: 'completions',
+            engineName: 'chat',
+            uiKind: commonTypes_1.ChatLocation.toString(location),
+            ...telemetryProperties // This includes the modelCallId from fetchAndStreamChat
         }, {
-            totalTokenMax: chatEndpointInfo.modelMaxPromptTokens ?? -1,
-            promptTokenCount: tokenCount,
-            tokenCountMax: maxResponseTokens,
-            timeToFirstToken,
-            isVisionRequest: isVisionRequest ? 1 : -1,
-            isBYOK: (0, openAIEndpoint_1.isBYOKModel)(chatEndpointInfo),
-            isAuto: (0, autoChatEndpoint_1.isAutoModel)(chatEndpointInfo)
+            maxTokenWindow: chatEndpoint.modelMaxPromptTokens
         });
+        for (const [key, value] of Object.entries(request)) {
+            if (key === 'messages' || key === 'input') {
+                continue;
+            } // Skip messages (PII)
+            telemetryData.properties[`request.option.${key}`] = JSON.stringify(value) ?? 'undefined';
+        }
+        // The request ID we are passed in is sent in the request to the proxy, and included in our pre-request telemetry.
+        // We hope (but do not rely on) that the model will use the same ID in the response, allowing us to correlate
+        // the request and response.
+        telemetryData.properties['headerRequestId'] = ourRequestId;
+        this._telemetryService.sendGHTelemetryEvent('request.sent', telemetryData.properties, telemetryData.measurements);
+        const requestStart = Date.now();
+        const intent = locationToIntent(location);
+        // Wrap the Promise with success/error callbacks so we can log/measure it
+        return (0, networking_1.postRequest)(this._fetcherService, this._telemetryService, this._capiClientService, chatEndpoint, secretKey, await (0, crypto_1.createRequestHMAC)(process.env.HMAC_SECRET), intent, ourRequestId, request, additionalHeaders, cancellationToken, useFetcher).then(response => {
+            const apim = response.headers.get('apim-request-id');
+            if (apim) {
+                this._logService.debug(`APIM request id: ${apim}`);
+            }
+            const ghRequestId = response.headers.get('x-github-request-id');
+            if (ghRequestId) {
+                this._logService.debug(`GH request id: ${ghRequestId}`);
+            }
+            // This ID is hopefully the one the same as ourRequestId, but it is not guaranteed.
+            // If they are different then we will override the original one we set in telemetryData above.
+            const modelRequestId = (0, fetch_1.getRequestId)(response, undefined);
+            telemetryData.extendWithRequestId(modelRequestId);
+            // TODO: Add response length (requires parsing)
+            const totalTimeMs = Date.now() - requestStart;
+            telemetryData.measurements.totalTimeMs = totalTimeMs;
+            this._logService.debug(`request.response: [${(0, networking_1.stringifyUrlOrRequestMetadata)(chatEndpoint.urlOrRequestMetadata)}], took ${totalTimeMs} ms`);
+            this._telemetryService.sendGHTelemetryEvent('request.response', telemetryData.properties, telemetryData.measurements);
+            return response;
+        })
+            .catch(error => {
+            if (this._fetcherService.isAbortError(error)) {
+                // If we cancelled a network request, we don't want to log a `request.error`
+                throw error;
+            }
+            const warningTelemetry = telemetryData.extendedBy({ error: 'Network exception' });
+            this._telemetryService.sendGHTelemetryEvent('request.shownWarning', warningTelemetry.properties, warningTelemetry.measurements);
+            telemetryData.properties.code = String(error.code ?? '');
+            telemetryData.properties.errno = String(error.errno ?? '');
+            telemetryData.properties.message = String(error.message ?? '');
+            telemetryData.properties.type = String(error.type ?? '');
+            const totalTimeMs = Date.now() - requestStart;
+            telemetryData.measurements.totalTimeMs = totalTimeMs;
+            this._logService.debug(`request.response: [${(0, networking_1.stringifyUrlOrRequestMetadata)(chatEndpoint.urlOrRequestMetadata)}] took ${totalTimeMs} ms`);
+            this._telemetryService.sendGHTelemetryEvent('request.error', telemetryData.properties, telemetryData.measurements);
+            throw error;
+        })
+            .finally(() => {
+            (0, chatStream_1.sendEngineMessagesTelemetry)(this._telemetryService, request.messages ?? [], telemetryData, false, this._logService);
+        });
+    }
+    async _handleError(telemetryData, response, requestId) {
+        const modelRequestIdObj = (0, fetch_1.getRequestId)(response, undefined);
+        requestId = modelRequestIdObj.headerRequestId || requestId;
+        modelRequestIdObj.headerRequestId = requestId;
+        telemetryData.properties.error = `Response status was ${response.status}`;
+        telemetryData.properties.status = String(response.status);
+        this._telemetryService.sendGHTelemetryEvent('request.shownWarning', telemetryData.properties, telemetryData.measurements);
+        const text = await response.text();
+        let jsonData;
+        try {
+            jsonData = JSON.parse(text);
+            jsonData = jsonData?.error ?? jsonData; // Extract nested error object if it exists
+        }
+        catch {
+            // JSON parsing failed, it's not json content.
+        }
+        const reasonNoText = `Server error: ${response.status}`;
+        const reason = `${reasonNoText} ${text}`;
+        this._logService.error(reason);
+        if (400 <= response.status && response.status < 500) {
+            if (response.status === 400 && text.includes('off_topic')) {
+                return {
+                    type: fetch_2.FetchResponseKind.Failed,
+                    modelRequestId: modelRequestIdObj,
+                    failKind: fetch_2.ChatFailKind.OffTopic,
+                    reason: 'filtered as off_topic by intent classifier: message was not programming related',
+                };
+            }
+            if (response.status === 401 && text.includes('authorize_url') && jsonData?.authorize_url) {
+                return {
+                    type: fetch_2.FetchResponseKind.Failed,
+                    modelRequestId: modelRequestIdObj,
+                    failKind: fetch_2.ChatFailKind.AgentUnauthorized,
+                    reason: response.statusText || response.statusText,
+                    data: jsonData
+                };
+            }
+            if (response.status === 400 && jsonData?.code === 'previous_response_not_found') {
+                return {
+                    type: fetch_2.FetchResponseKind.Failed,
+                    modelRequestId: modelRequestIdObj,
+                    failKind: fetch_2.ChatFailKind.InvalidPreviousResponseId,
+                    reason: jsonData.message || 'Invalid previous response ID',
+                    data: jsonData,
+                };
+            }
+            if (response.status === 401 || response.status === 403) {
+                // Token has expired or invalid, fetch a new one on next request
+                // TODO(drifkin): these actions should probably happen in vsc specific code
+                this._authenticationService.resetCopilotToken(response.status);
+                return {
+                    type: fetch_2.FetchResponseKind.Failed,
+                    modelRequestId: modelRequestIdObj,
+                    failKind: fetch_2.ChatFailKind.TokenExpiredOrInvalid,
+                    reason: jsonData?.message || `token expired or invalid: ${response.status}`,
+                };
+            }
+            if (response.status === 402) {
+                // When we receive a 402, we have exceed a quota
+                // This is stored on the token so let's refresh it
+                this._authenticationService.resetCopilotToken(response.status);
+                const retryAfter = response.headers.get('retry-after');
+                const convertToDate = (retryAfterString) => {
+                    if (!retryAfterString) {
+                        return undefined;
+                    }
+                    // Try treating it as a date
+                    const retryAfterDate = new Date(retryAfterString);
+                    if (!isNaN(retryAfterDate.getDate())) {
+                        return retryAfterDate;
+                    }
+                    // It is not a date, try treating it as a duration from the current date
+                    const retryAfterDuration = parseInt(retryAfterString, 10);
+                    if (isNaN(retryAfterDuration)) {
+                        return undefined;
+                    }
+                    return new Date(Date.now() + retryAfterDuration * 1000);
+                };
+                const retryAfterDate = convertToDate(retryAfter);
+                return {
+                    type: fetch_2.FetchResponseKind.Failed,
+                    modelRequestId: modelRequestIdObj,
+                    failKind: fetch_2.ChatFailKind.QuotaExceeded,
+                    reason: jsonData?.message ?? 'Free tier quota exceeded',
+                    data: {
+                        capiError: jsonData,
+                        retryAfter: retryAfterDate
+                    }
+                };
+            }
+            if (response.status === 404) {
+                let errorReason;
+                // Check if response body is valid JSON
+                if (!jsonData) {
+                    errorReason = text;
+                }
+                else {
+                    errorReason = JSON.stringify(jsonData);
+                }
+                return {
+                    type: fetch_2.FetchResponseKind.Failed,
+                    modelRequestId: modelRequestIdObj,
+                    failKind: fetch_2.ChatFailKind.NotFound,
+                    reason: errorReason
+                };
+            }
+            if (response.status === 422) {
+                return {
+                    type: fetch_2.FetchResponseKind.Failed,
+                    modelRequestId: modelRequestIdObj,
+                    failKind: fetch_2.ChatFailKind.ContentFilter,
+                    reason: 'Filtered by Responsible AI Service\n\n' + text,
+                };
+            }
+            if (response.status === 424) {
+                return {
+                    type: fetch_2.FetchResponseKind.Failed,
+                    modelRequestId: modelRequestIdObj,
+                    failKind: fetch_2.ChatFailKind.AgentFailedDependency,
+                    reason: text
+                };
+            }
+            if (response.status === 429) {
+                let rateLimitReason = text;
+                rateLimitReason = jsonData?.message ?? jsonData?.code;
+                if (text.includes('extension_blocked') && jsonData?.code === 'extension_blocked' && jsonData?.type === 'rate_limit_error') {
+                    return {
+                        type: fetch_2.FetchResponseKind.Failed,
+                        modelRequestId: modelRequestIdObj,
+                        failKind: fetch_2.ChatFailKind.ExtensionBlocked,
+                        reason: 'Extension blocked',
+                        data: {
+                            ...jsonData?.message,
+                            retryAfter: response.headers.get('retry-after'),
+                        }
+                    };
+                }
+                // HTTP 429 Too Many Requests
+                return {
+                    type: fetch_2.FetchResponseKind.Failed,
+                    modelRequestId: modelRequestIdObj,
+                    failKind: fetch_2.ChatFailKind.RateLimited,
+                    reason: rateLimitReason,
+                    data: {
+                        retryAfter: response.headers.get('retry-after'),
+                        rateLimitKey: response.headers.get('x-ratelimit-exceeded'),
+                        capiError: jsonData
+                    }
+                };
+            }
+            if (response.status === 466) {
+                this._logService.info(text);
+                return {
+                    type: fetch_2.FetchResponseKind.Failed,
+                    modelRequestId: modelRequestIdObj,
+                    failKind: fetch_2.ChatFailKind.ClientNotSupported,
+                    reason: `client not supported: ${text}`
+                };
+            }
+            if (response.status === 499) {
+                this._logService.info('Cancelled by server');
+                return {
+                    type: fetch_2.FetchResponseKind.Failed,
+                    modelRequestId: modelRequestIdObj,
+                    failKind: fetch_2.ChatFailKind.ServerCanceled,
+                    reason: 'canceled by server'
+                };
+            }
+        }
+        else if (500 <= response.status && response.status < 600) {
+            if (response.status === 503) {
+                return {
+                    type: fetch_2.FetchResponseKind.Failed,
+                    modelRequestId: modelRequestIdObj,
+                    failKind: fetch_2.ChatFailKind.RateLimited,
+                    reason: 'Upstream provider rate limit hit',
+                    data: {
+                        retryAfter: null,
+                        rateLimitKey: null,
+                        capiError: { code: 'upstream_provider_rate_limit', message: text }
+                    }
+                };
+            }
+            // HTTP 5xx Server Error
+            return {
+                type: fetch_2.FetchResponseKind.Failed,
+                modelRequestId: modelRequestIdObj,
+                failKind: fetch_2.ChatFailKind.ServerError,
+                reason: reasonNoText,
+            };
+        }
+        this._logService.error(`Request Failed: ${response.status} ${text}`);
+        (0, stream_1.sendCommunicationErrorTelemetry)(this._telemetryService, 'Unhandled status from server: ' + response.status, text);
+        return {
+            type: fetch_2.FetchResponseKind.Failed,
+            modelRequestId: modelRequestIdObj,
+            failKind: fetch_2.ChatFailKind.Unknown,
+            reason: `Request Failed: ${response.status} ${text}`
+        };
     }
     async processSuccessfulResponse(response, messages, requestBody, requestId, maxResponseTokens, promptTokenCount, timeToFirstToken, streamRecorder, baseTelemetry, chatEndpointInfo, userInitiatedRequest) {
         const completions = [];
         for await (const chatCompletion of response.chatCompletions) {
-            /* __GDPR__
-                "response.success" : {
-                    "owner": "digitarald",
-                    "comment": "Report quality details for a successful service response.",
-                    "reason": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Reason for why a response finished" },
-                    "filterReason": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Reason for why a response was filtered" },
-                    "source": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Source of the initial request" },
-                    "initiatorType": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Whether the request was initiated by a user or an agent" },
-                    "model": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Model selection for the response" },
-                    "modelInvoked": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Actual model invoked for the response" },
-                    "apiType": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "API type for the response- chat completions or responses" },
-                    "requestId": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Id of the current turn request" },
-                    "associatedRequestId": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Another request ID that this request is associated with (eg, the originating request of a summarization request)." },
-                    "reasoningEffort": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Reasoning effort level" },
-                    "reasoningSummary": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Reasoning summary level" },
-                    "totalTokenMax": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Maximum total token window", "isMeasurement": true },
-                    "clientPromptTokenCount": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Number of prompt tokens, locally counted", "isMeasurement": true },
-                    "promptTokenCount": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Number of prompt tokens, server side counted", "isMeasurement": true },
-                    "promptCacheTokenCount": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Number of prompt tokens hitting cache as reported by server", "isMeasurement": true },
-                    "tokenCountMax": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Maximum generated tokens", "isMeasurement": true },
-                    "tokenCount": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Number of generated tokens", "isMeasurement": true },
-                    "reasoningTokens": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Number of reasoning tokens", "isMeasurement": true },
-                    "acceptedPredictionTokens": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Number of tokens in the prediction that appeared in the completion", "isMeasurement": true },
-                    "rejectedPredictionTokens": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Number of tokens in the prediction that appeared in the completion", "isMeasurement": true },
-                    "completionTokens": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Number of tokens in the output", "isMeasurement": true },
-                    "timeToFirstToken": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Time to first token", "isMeasurement": true },
-                    "timeToFirstTokenEmitted": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Time to first token emitted (visible text)", "isMeasurement": true },
-                    "timeToComplete": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Time to complete the request", "isMeasurement": true },
-                    "isVisionRequest": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "comment": "Whether the request was for a vision model", "isMeasurement": true },
-                    "isBYOK": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Whether the request was for a BYOK model", "isMeasurement": true },
-                    "isAuto": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Whether the request was for an Auto model", "isMeasurement": true },
-                    "retryAfterErrorCategory": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "If the response failed and this is a retry attempt, this contains the error category." },
-                    "retryAfterFilterCategory": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "If the response was filtered and this is a retry attempt, this contains the original filtered content category." }
-                }
-            */
-            this._telemetryService.sendTelemetryEvent('response.success', { github: true, microsoft: true }, {
-                reason: chatCompletion.finishReason,
-                filterReason: chatCompletion.filterReason,
-                source: baseTelemetry?.properties.messageSource ?? 'unknown',
-                initiatorType: userInitiatedRequest ? 'user' : 'agent',
-                model: chatEndpointInfo?.model,
-                modelInvoked: chatCompletion.model,
-                apiType: chatEndpointInfo?.apiType,
-                requestId,
-                associatedRequestId: baseTelemetry?.properties.associatedRequestId,
-                reasoningEffort: requestBody.reasoning?.effort,
-                reasoningSummary: requestBody.reasoning?.summary,
-                ...(baseTelemetry?.properties.retryAfterErrorCategory ? { retryAfterErrorCategory: baseTelemetry.properties.retryAfterErrorCategory } : {}),
-                ...(baseTelemetry?.properties.retryAfterFilterCategory ? { retryAfterFilterCategory: baseTelemetry.properties.retryAfterFilterCategory } : {}),
-            }, {
-                totalTokenMax: chatEndpointInfo?.modelMaxPromptTokens ?? -1,
-                tokenCountMax: maxResponseTokens,
-                promptTokenCount: chatCompletion.usage?.prompt_tokens,
-                promptCacheTokenCount: chatCompletion.usage?.prompt_tokens_details?.cached_tokens,
-                clientPromptTokenCount: promptTokenCount,
-                tokenCount: chatCompletion.usage?.total_tokens,
-                reasoningTokens: chatCompletion.usage?.completion_tokens_details?.reasoning_tokens,
-                acceptedPredictionTokens: chatCompletion.usage?.completion_tokens_details?.accepted_prediction_tokens,
-                rejectedPredictionTokens: chatCompletion.usage?.completion_tokens_details?.rejected_prediction_tokens,
-                completionTokens: chatCompletion.usage?.completion_tokens,
+            chatMLFetcherTelemetry_1.ChatMLFetcherTelemetrySender.sendSuccessTelemetry(this._telemetryService, {
+                chatCompletion,
+                baseTelemetry,
+                userInitiatedRequest,
+                chatEndpointInfo,
+                requestBody,
+                maxResponseTokens,
+                promptTokenCount,
                 timeToFirstToken,
                 timeToFirstTokenEmitted: (baseTelemetry && streamRecorder.firstTokenEmittedTime) ? streamRecorder.firstTokenEmittedTime - baseTelemetry.issuedTime : -1,
-                timeToComplete: baseTelemetry ? Date.now() - baseTelemetry.issuedTime : -1,
-                isVisionRequest: this.filterImageMessages(messages) ? 1 : -1,
-                isBYOK: (0, openAIEndpoint_1.isBYOKModel)(chatEndpointInfo),
-                isAuto: (0, autoChatEndpoint_1.isAutoModel)(chatEndpointInfo)
+                hasImageMessages: this.filterImageMessages(messages),
             });
             if (!this.isRepetitive(chatCompletion, baseTelemetry?.properties)) {
                 completions.push(chatCompletion);
@@ -564,43 +842,43 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
     processFailedResponse(response, requestId) {
         const serverRequestId = response.modelRequestId?.gitHubRequestId;
         const reason = response.reason;
-        if (response.failKind === fetch_1.ChatFailKind.RateLimited) {
+        if (response.failKind === fetch_2.ChatFailKind.RateLimited) {
             return { type: commonTypes_1.ChatFetchResponseType.RateLimited, reason, requestId, serverRequestId, retryAfter: response.data?.retryAfter, rateLimitKey: (response.data?.rateLimitKey || ''), capiError: response.data?.capiError };
         }
-        if (response.failKind === fetch_1.ChatFailKind.QuotaExceeded) {
+        if (response.failKind === fetch_2.ChatFailKind.QuotaExceeded) {
             return { type: commonTypes_1.ChatFetchResponseType.QuotaExceeded, reason, requestId, serverRequestId, retryAfter: response.data?.retryAfter, capiError: response.data?.capiError };
         }
-        if (response.failKind === fetch_1.ChatFailKind.OffTopic) {
+        if (response.failKind === fetch_2.ChatFailKind.OffTopic) {
             return { type: commonTypes_1.ChatFetchResponseType.OffTopic, reason, requestId, serverRequestId };
         }
-        if (response.failKind === fetch_1.ChatFailKind.TokenExpiredOrInvalid || response.failKind === fetch_1.ChatFailKind.ClientNotSupported || reason.includes('Bad request: ')) {
+        if (response.failKind === fetch_2.ChatFailKind.TokenExpiredOrInvalid || response.failKind === fetch_2.ChatFailKind.ClientNotSupported || reason.includes('Bad request: ')) {
             return { type: commonTypes_1.ChatFetchResponseType.BadRequest, reason, requestId, serverRequestId };
         }
-        if (response.failKind === fetch_1.ChatFailKind.ServerError) {
+        if (response.failKind === fetch_2.ChatFailKind.ServerError) {
             return { type: commonTypes_1.ChatFetchResponseType.Failed, reason, requestId, serverRequestId };
         }
-        if (response.failKind === fetch_1.ChatFailKind.ContentFilter) {
+        if (response.failKind === fetch_2.ChatFailKind.ContentFilter) {
             return { type: commonTypes_1.ChatFetchResponseType.PromptFiltered, reason, category: openai_1.FilterReason.Prompt, requestId, serverRequestId };
         }
-        if (response.failKind === fetch_1.ChatFailKind.AgentUnauthorized) {
+        if (response.failKind === fetch_2.ChatFailKind.AgentUnauthorized) {
             return { type: commonTypes_1.ChatFetchResponseType.AgentUnauthorized, reason, authorizationUrl: response.data.authorize_url, requestId, serverRequestId };
         }
-        if (response.failKind === fetch_1.ChatFailKind.AgentFailedDependency) {
+        if (response.failKind === fetch_2.ChatFailKind.AgentFailedDependency) {
             return { type: commonTypes_1.ChatFetchResponseType.AgentFailedDependency, reason, requestId, serverRequestId };
         }
-        if (response.failKind === fetch_1.ChatFailKind.ExtensionBlocked) {
+        if (response.failKind === fetch_2.ChatFailKind.ExtensionBlocked) {
             const retryAfter = typeof response.data?.retryAfter === 'number' ? response.data.retryAfter : 300;
             return { type: commonTypes_1.ChatFetchResponseType.ExtensionBlocked, reason, requestId, retryAfter, learnMoreLink: response.data?.learnMoreLink ?? '', serverRequestId };
         }
-        if (response.failKind === fetch_1.ChatFailKind.NotFound) {
+        if (response.failKind === fetch_2.ChatFailKind.NotFound) {
             return { type: commonTypes_1.ChatFetchResponseType.NotFound, reason, requestId, serverRequestId };
         }
-        if (response.failKind === fetch_1.ChatFailKind.InvalidPreviousResponseId) {
+        if (response.failKind === fetch_2.ChatFailKind.InvalidPreviousResponseId) {
             return { type: commonTypes_1.ChatFetchResponseType.InvalidStatefulMarker, reason, requestId, serverRequestId };
         }
         return { type: commonTypes_1.ChatFetchResponseType.Failed, reason, requestId, serverRequestId };
     }
-    processError(err, requestId) {
+    processError(err, requestId, usernameToScrub) {
         const fetcher = this._fetcherService;
         // If we cancelled a network request, we don't want to log an error
         if (fetcher.isAbortError(err)) {
@@ -631,7 +909,7 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
         this._logService.error(errorsUtil.fromUnknown(err), `Error on conversation request`);
         this._telemetryService.sendGHTelemetryException(err, 'Error on conversation request');
         const errorDetail = fetcher.getUserMessageForFetcherError(err);
-        const scrubbedErrorDetail = this.scrubErrorDetail(errorDetail);
+        const scrubbedErrorDetail = this.scrubErrorDetail(errorDetail, usernameToScrub);
         if (fetcher.isInternetDisconnectedError(err)) {
             return {
                 type: commonTypes_1.ChatFetchResponseType.NetworkError,
@@ -660,14 +938,12 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
             };
         }
     }
-    scrubErrorDetail(errorDetail) {
-        errorDetail = errorDetail.replaceAll(/(logged in as )([^\s]+)/ig, '$1<login>');
-        const username = this._authenticationService.copilotToken?.username;
-        if (!username) {
-            return errorDetail;
-        }
-        const regex = new RegExp((0, strings_1.escapeRegExpCharacters)(username), 'ig');
-        return errorDetail.replaceAll(regex, '<login>');
+    scrubErrorDetail(errorDetail, usernameToScrub) {
+        if (usernameToScrub) {
+            const regex = new RegExp((0, strings_1.escapeRegExpCharacters)(usernameToScrub), 'ig');
+            errorDetail = errorDetail.replaceAll(regex, '<login>');
+        }
+        return errorDetail.replaceAll(/(?<=logged in as )(?!<login>)[^\s]+/ig, '!<login>!'); // marking fallback with !
     }
 };
 exports.ChatMLFetcherImpl = ChatMLFetcherImpl;
@@ -677,8 +953,12 @@ exports.ChatMLFetcherImpl = ChatMLFetcherImpl = __decorate([
     __param(2, requestLogger_1.IRequestLogger),
     __param(3, logService_1.ILogService),
     __param(4, authentication_1.IAuthenticationService),
-    __param(5, instantiation_1.IInstantiationService),
-    __param(6, conversationOptions_1.IConversationOptions)
+    __param(5, interactionService_1.IInteractionService),
+    __param(6, chatQuotaService_1.IChatQuotaService),
+    __param(7, capiClient_1.ICAPIClientService),
+    __param(8, conversationOptions_1.IConversationOptions),
+    __param(9, configurationService_1.IConfigurationService),
+    __param(10, nullExperimentationService_1.IExperimentationService)
 ], ChatMLFetcherImpl);
 /**
  * Validates a chat request payload to ensure it is valid
@@ -705,4 +985,37 @@ function isValidChatPayload(messages, postOptions) {
 function asUnexpected(reason) {
     return `Prompt failed validation with the reason: ${reason}. Please file an issue.`;
 }
+function createTelemetryData(chatEndpointInfo, location, headerRequestId) {
+    return telemetryData_1.TelemetryData.createAndMarkAsIssued({
+        endpoint: 'completions',
+        engineName: 'chat',
+        uiKind: commonTypes_1.ChatLocation.toString(location),
+        headerRequestId
+    });
+}
+/**
+ * WARNING: The value that is returned from this function drives the disablement of RAI for full-file rewrite requests
+ * in Copilot Edits, Copilot Chat, Agent Mode, and Inline Chat.
+ * If your chat location generates full-file rewrite requests and you are unsure if changing something here will cause problems, please talk to @roblourens
+ */
+function locationToIntent(location) {
+    switch (location) {
+        case commonTypes_1.ChatLocation.Panel:
+            return 'conversation-panel';
+        case commonTypes_1.ChatLocation.Editor:
+            return 'conversation-inline';
+        case commonTypes_1.ChatLocation.EditingSession:
+            return 'conversation-edits';
+        case commonTypes_1.ChatLocation.Notebook:
+            return 'conversation-notebook';
+        case commonTypes_1.ChatLocation.Terminal:
+            return 'conversation-terminal';
+        case commonTypes_1.ChatLocation.Other:
+            return 'conversation-other';
+        case commonTypes_1.ChatLocation.Agent:
+            return 'conversation-agent';
+        case commonTypes_1.ChatLocation.ResponsesProxy:
+            return 'responses-proxy';
+    }
+}
 //# sourceMappingURL=chatMLFetcher.js.map