@vscode/chat-lib 0.3.0 → 0.3.1-0

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

@@ -123,6 +123,11 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
         this._capiClientService = _capiClientService;
         this._configurationService = _configurationService;
         this._experimentationService = _experimentationService;
+        /**
+         * Delays (in ms) between connectivity check attempts before retrying a failed request.
+         * Configurable for testing purposes.
+         */
+        this.connectivityCheckDelays = [1000, 10000, 10000];
     }
     /**
      * Note: the returned array of strings may be less than `n` (e.g., in case there were errors during streaming)
@@ -168,8 +173,11 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
         let tokenCount = -1;
         const streamRecorder = new chatMLFetcher_1.FetchStreamRecorder(finishedCb);
         const enableRetryOnError = opts.enableRetryOnError ?? opts.enableRetryOnFilter;
+        const canRetryOnce = opts.canRetryOnceWithoutRollback ?? !(opts.enableRetryOnFilter || opts.enableRetryOnError);
         let usernameToScrub;
         let actualFetcher;
+        let actualBytesReceived;
+        let actualStatusCode;
         try {
             let response;
             const payloadValidationResult = isValidChatPayload(opts.messages, postOptions);
@@ -184,9 +192,11 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
             else {
                 const copilotToken = await this._authenticationService.getCopilotToken();
                 usernameToScrub = copilotToken.username;
-                const fetchResult = await this._fetchAndStreamChat(chatEndpoint, requestBody, baseTelemetry, streamRecorder.callback, requestOptions.secretKey, copilotToken, opts.location, ourRequestId, postOptions.n, token, userInitiatedRequest, telemetryProperties, opts.useFetcher);
+                const fetchResult = await this._fetchAndStreamChat(chatEndpoint, requestBody, baseTelemetry, streamRecorder.callback, requestOptions.secretKey, copilotToken, opts.location, ourRequestId, postOptions.n, token, userInitiatedRequest, telemetryProperties, opts.useFetcher, canRetryOnce);
                 response = fetchResult.result;
                 actualFetcher = fetchResult.fetcher;
+                actualBytesReceived = fetchResult.bytesReceived;
+                actualStatusCode = fetchResult.statusCode;
                 tokenCount = await chatEndpoint.acquireTokenizer().countMessagesTokens(messages);
                 const extensionId = source?.extensionId ?? constants_1.EXTENSION_ID;
                 this._onDidMakeChatMLRequest.fire({
@@ -200,7 +210,7 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
             pendingLoggedChatRequest?.markTimeToFirstToken(timeToFirstToken);
             switch (response.type) {
                 case fetch_2.FetchResponseKind.Success: {
-                    const result = await this.processSuccessfulResponse(response, messages, requestBody, ourRequestId, maxResponseTokens, tokenCount, timeToFirstToken, streamRecorder, baseTelemetry, chatEndpoint, userInitiatedRequest, actualFetcher);
+                    const result = await this.processSuccessfulResponse(response, messages, requestBody, ourRequestId, maxResponseTokens, tokenCount, timeToFirstToken, streamRecorder, baseTelemetry, chatEndpoint, userInitiatedRequest, actualFetcher, actualBytesReceived);
                     // Handle FilteredRetry case with augmented messages
                     if (result.type === commonTypes_1.ChatFetchResponseType.FilteredRetry) {
                         if (opts.enableRetryOnFilter) {
@@ -230,6 +240,7 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
                                     userInitiatedRequest: false, // do not mark the retry as user initiated
                                     telemetryProperties: { ...telemetryProperties, retryAfterFilterCategory: result.category ?? 'uncategorized' },
                                     enableRetryOnFilter: false,
+                                    canRetryOnceWithoutRollback: false,
                                     enableRetryOnError,
                                 }, token);
                                 pendingLoggedChatRequest?.resolve(retryResult, streamRecorder.deltas);
@@ -256,7 +267,6 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
                         model: chatEndpoint.model,
                         apiType: chatEndpoint.apiType,
                         associatedRequestId: telemetryProperties.associatedRequestId,
-                        retryAfterErrorCategory: telemetryProperties.retryAfterErrorCategory,
                         retryAfterError: telemetryProperties.retryAfterError,
                         retryAfterErrorGitHubRequestId: telemetryProperties.retryAfterErrorGitHubRequestId,
                         connectivityTestError: telemetryProperties.connectivityTestError,
@@ -269,16 +279,46 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
                         tokenCountMax: maxResponseTokens,
                         timeToFirstToken,
                         timeToFirstTokenEmitted: (baseTelemetry && streamRecorder.firstTokenEmittedTime) ? streamRecorder.firstTokenEmittedTime - baseTelemetry.issuedTime : -1,
-                        timeToCancelled: baseTelemetry ? Date.now() - baseTelemetry.issuedTime : -1,
+                        timeToCancelled: Date.now() - baseTelemetry.issuedTime,
                         isVisionRequest: this.filterImageMessages(messages) ? 1 : -1,
                         isBYOK: (0, openAIEndpoint_1.isBYOKModel)(chatEndpoint),
-                        isAuto: (0, autoChatEndpoint_1.isAutoModel)(chatEndpoint)
+                        isAuto: (0, autoChatEndpoint_1.isAutoModel)(chatEndpoint),
+                        bytesReceived: actualBytesReceived,
+                        issuedTime: baseTelemetry.issuedTime,
                     });
                     pendingLoggedChatRequest?.resolveWithCancelation();
-                    return this.processCanceledResponse(response, ourRequestId);
+                    return this.processCanceledResponse(response, ourRequestId, streamRecorder, telemetryProperties);
                 case fetch_2.FetchResponseKind.Failed: {
                     const processed = this.processFailedResponse(response, ourRequestId);
-                    chatMLFetcherTelemetry_1.ChatMLFetcherTelemetrySender.sendResponseErrorTelemetry(this._telemetryService, processed, telemetryProperties, chatEndpoint, requestBody, tokenCount, maxResponseTokens, timeToFirstToken, this.filterImageMessages(messages), actualFetcher);
+                    // Retry on server errors based on configured status codes
+                    const retryServerErrorStatusCodes = this._configurationService.getExperimentBasedConfig(configurationService_1.ConfigKey.TeamInternal.RetryServerErrorStatusCodes, this._experimentationService);
+                    const statusCodesToRetry = retryServerErrorStatusCodes
+                        .split(',')
+                        .map(s => parseInt(s.trim(), 10));
+                    if (enableRetryOnError && actualStatusCode !== undefined && statusCodesToRetry.includes(actualStatusCode)) {
+                        const { retryResult } = await this._retryAfterError({
+                            opts,
+                            processed,
+                            telemetryProperties,
+                            requestBody,
+                            tokenCount,
+                            maxResponseTokens,
+                            timeToError: timeToFirstToken,
+                            actualFetcher,
+                            bytesReceived: actualBytesReceived,
+                            baseTelemetry,
+                            streamRecorder,
+                            retryReason: 'server_error',
+                            debugNamePrefix: 'retry-server-error-',
+                            pendingLoggedChatRequest,
+                            token,
+                            usernameToScrub,
+                        });
+                        if (retryResult) {
+                            return retryResult;
+                        }
+                    }
+                    chatMLFetcherTelemetry_1.ChatMLFetcherTelemetrySender.sendResponseErrorTelemetry(this._telemetryService, processed, telemetryProperties, chatEndpoint, requestBody, tokenCount, maxResponseTokens, timeToFirstToken, this.filterImageMessages(messages), actualFetcher, actualBytesReceived, baseTelemetry.issuedTime);
                     pendingLoggedChatRequest?.resolve(processed);
                     return processed;
                 }
@@ -290,49 +330,31 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
                 actualFetcher = err.fetcherId;
             }
             const processed = this.processError(err, ourRequestId, err.gitHubRequestId, usernameToScrub);
-            let connectivityTestError = telemetryProperties.connectivityTestError;
-            let connectivityTestErrorGitHubRequestId = telemetryProperties.connectivityTestErrorGitHubRequestId;
             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;
-                    connectivityTestErrorGitHubRequestId = connectivity.connectivityTestErrorGitHubRequestId;
-                    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,
-                                retryAfterErrorGitHubRequestId: processed.serverRequestId,
-                                connectivityTestError,
-                                connectivityTestErrorGitHubRequestId,
-                            },
-                            enableRetryOnFilter: opts.enableRetryOnFilter,
-                            enableRetryOnError: false,
-                            useFetcher,
-                        }, token);
-                        pendingLoggedChatRequest?.resolve(retryResult, streamRecorder.deltas);
+                if (isRetryNetworkErrorEnabled) {
+                    const { retryResult, connectivityTestError, connectivityTestErrorGitHubRequestId } = await this._retryAfterError({
+                        opts,
+                        processed,
+                        telemetryProperties,
+                        requestBody,
+                        tokenCount,
+                        maxResponseTokens,
+                        timeToError,
+                        actualFetcher,
+                        bytesReceived: err.bytesReceived,
+                        baseTelemetry,
+                        streamRecorder,
+                        retryReason: 'network_error',
+                        debugNamePrefix: 'retry-error-',
+                        pendingLoggedChatRequest,
+                        token,
+                        usernameToScrub,
+                    });
+                    if (retryResult) {
                         return retryResult;
                     }
-                    else {
-                        this._logService.info(`Not retrying chat request as network connectivity could not be re-established.`);
-                    }
+                    telemetryProperties = { ...telemetryProperties, connectivityTestError, connectivityTestErrorGitHubRequestId };
                 }
             }
             if (processed.type === commonTypes_1.ChatFetchResponseType.Canceled) {
@@ -342,11 +364,10 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
                     model: chatEndpoint.model,
                     apiType: chatEndpoint.apiType,
                     associatedRequestId: telemetryProperties.associatedRequestId,
-                    retryAfterErrorCategory: telemetryProperties.retryAfterErrorCategory,
                     retryAfterError: telemetryProperties.retryAfterError,
                     retryAfterErrorGitHubRequestId: telemetryProperties.retryAfterErrorGitHubRequestId,
-                    connectivityTestError,
-                    connectivityTestErrorGitHubRequestId,
+                    connectivityTestError: telemetryProperties.connectivityTestError,
+                    connectivityTestErrorGitHubRequestId: telemetryProperties.connectivityTestErrorGitHubRequestId,
                     retryAfterFilterCategory: telemetryProperties.retryAfterFilterCategory,
                     fetcher: actualFetcher,
                 }, {
@@ -357,11 +378,13 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
                     timeToCancelled: timeToError,
                     isVisionRequest: this.filterImageMessages(messages) ? 1 : -1,
                     isBYOK: (0, openAIEndpoint_1.isBYOKModel)(chatEndpoint),
-                    isAuto: (0, autoChatEndpoint_1.isAutoModel)(chatEndpoint)
+                    isAuto: (0, autoChatEndpoint_1.isAutoModel)(chatEndpoint),
+                    bytesReceived: err.bytesReceived,
+                    issuedTime: baseTelemetry.issuedTime,
                 });
             }
             else {
-                chatMLFetcherTelemetry_1.ChatMLFetcherTelemetrySender.sendResponseErrorTelemetry(this._telemetryService, processed, { ...telemetryProperties, connectivityTestError, connectivityTestErrorGitHubRequestId }, chatEndpoint, requestBody, tokenCount, maxResponseTokens, timeToError, this.filterImageMessages(messages), actualFetcher);
+                chatMLFetcherTelemetry_1.ChatMLFetcherTelemetrySender.sendResponseErrorTelemetry(this._telemetryService, processed, telemetryProperties, chatEndpoint, requestBody, tokenCount, maxResponseTokens, timeToError, this.filterImageMessages(messages), actualFetcher, err.bytesReceived, baseTelemetry.issuedTime);
             }
             pendingLoggedChatRequest?.resolve(processed);
             return processed;
@@ -369,7 +392,7 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
     }
     async _checkNetworkConnectivity(useFetcher) {
         // Ping CAPI to check network connectivity before retrying
-        const delays = [1000, 10000, 10000];
+        const delays = this.connectivityCheckDelays;
         let connectivityTestError = undefined;
         let connectivityTestErrorGitHubRequestId = undefined;
         for (const delay of delays) {
@@ -421,7 +444,39 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
         }
         return authHeaders;
     }
-    async _fetchAndStreamChat(chatEndpointInfo, request, baseTelemetryData, finishedCb, secretKey, copilotToken, location, ourRequestId, nChoices, cancellationToken, userInitiatedRequest, telemetryProperties, useFetcher) {
+    async _retryAfterError(params) {
+        const { opts, processed, telemetryProperties, requestBody, tokenCount, maxResponseTokens, timeToError, actualFetcher, bytesReceived, baseTelemetry, streamRecorder, retryReason, debugNamePrefix, pendingLoggedChatRequest, token, usernameToScrub, } = params;
+        // 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 useFetcher = isNetworkChangedError ? 'node-fetch' : opts.useFetcher;
+        this._logService.info(`Retrying chat request with ${useFetcher || 'default'} fetcher after: ${processed.reasonDetail || processed.reason}`);
+        const connectivity = await this._checkNetworkConnectivity(useFetcher);
+        const connectivityTestError = connectivity.connectivityTestError ? this.scrubErrorDetail(connectivity.connectivityTestError, usernameToScrub) : undefined;
+        const connectivityTestErrorGitHubRequestId = connectivity.connectivityTestErrorGitHubRequestId;
+        if (!connectivity.retryRequest) {
+            this._logService.info(`Not retrying chat request as network connectivity could not be re-established.`);
+            return { connectivityTestError, connectivityTestErrorGitHubRequestId };
+        }
+        chatMLFetcherTelemetry_1.ChatMLFetcherTelemetrySender.sendResponseErrorTelemetry(this._telemetryService, processed, telemetryProperties, opts.endpoint, requestBody, tokenCount, maxResponseTokens, timeToError, this.filterImageMessages(opts.messages), actualFetcher, bytesReceived, baseTelemetry.issuedTime, true);
+        streamRecorder.callback('', 0, { text: '', retryReason });
+        const retryResult = await this.fetchMany({
+            ...opts,
+            debugName: debugNamePrefix + opts.debugName,
+            userInitiatedRequest: false, // do not mark the retry as user initiated
+            telemetryProperties: {
+                ...telemetryProperties,
+                retryAfterError: processed.reasonDetail || processed.reason,
+                retryAfterErrorGitHubRequestId: processed.serverRequestId,
+                connectivityTestError,
+                connectivityTestErrorGitHubRequestId,
+            },
+            enableRetryOnError: false,
+            useFetcher,
+        }, token);
+        pendingLoggedChatRequest?.resolve(retryResult, streamRecorder.deltas);
+        return { retryResult, connectivityTestError, connectivityTestErrorGitHubRequestId };
+    }
+    async _fetchAndStreamChat(chatEndpointInfo, request, baseTelemetryData, finishedCb, secretKey, copilotToken, location, ourRequestId, nChoices, cancellationToken, userInitiatedRequest, telemetryProperties, useFetcher, canRetryOnce) {
         if (cancellationToken.isCancellationRequested) {
             return { result: { type: fetch_2.FetchResponseKind.Canceled, reason: 'before fetch request' } };
         }
@@ -445,13 +500,12 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
         }
         // 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);
+        const response = await this._fetchWithInstrumentation(chatEndpointInfo, ourRequestId, request, secretKey, location, cancellationToken, userInitiatedRequest, { ...telemetryProperties, modelCallId }, useFetcher, canRetryOnce);
         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();
+                await response.body.destroy();
             }
             catch (e) {
                 this._logService.error(e, `Error destroying stream`);
@@ -459,7 +513,8 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
             }
             return {
                 result: { type: fetch_2.FetchResponseKind.Canceled, reason: 'after fetch request' },
-                fetcher: response.fetcher
+                fetcher: response.fetcher,
+                bytesReceived: response.bytesReceived
             };
         }
         if (response.status === 200 && this._authenticationService.copilotToken?.isFreeUser && this._authenticationService.copilotToken?.isChatQuotaExceeded) {
@@ -470,7 +525,9 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
             this._logService.info('Request ID for failed request: ' + ourRequestId);
             return {
                 result: await this._handleError(telemetryData, response, ourRequestId),
-                fetcher: response.fetcher
+                fetcher: response.fetcher,
+                bytesReceived: response.bytesReceived,
+                statusCode: response.status
             };
         }
         // Extend baseTelemetryData with modelCallId for output messages
@@ -488,6 +545,7 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
                 catch (err) {
                     err.fetcherId = response.fetcher;
                     err.gitHubRequestId = gitHubRequestId;
+                    err.bytesReceived = response.bytesReceived;
                     throw err;
                 }
             });
@@ -495,6 +553,7 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
         catch (err) {
             err.fetcherId = response.fetcher;
             err.gitHubRequestId = gitHubRequestId;
+            err.bytesReceived = response.bytesReceived;
             throw err;
         }
         // CAPI will return us a Copilot Edits Session Header which is our token to using the speculative decoding endpoint
@@ -508,10 +567,11 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
                 type: fetch_2.FetchResponseKind.Success,
                 chatCompletions,
             },
-            fetcher: response.fetcher
+            fetcher: response.fetcher,
+            bytesReceived: response.bytesReceived
         };
     }
-    async _fetchWithInstrumentation(chatEndpoint, ourRequestId, request, secretKey, location, cancellationToken, userInitiatedRequest, telemetryProperties, useFetcher) {
+    async _fetchWithInstrumentation(chatEndpoint, ourRequestId, request, secretKey, location, cancellationToken, userInitiatedRequest, telemetryProperties, useFetcher, canRetryOnce) {
         // If request contains an image, we include this header.
         const additionalHeaders = {
             'X-Interaction-Id': this._interactionService.interactionId,
@@ -542,7 +602,7 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
         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 => {
+        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, canRetryOnce).then(response => {
             const apim = response.headers.get('apim-request-id');
             if (apim) {
                 this._logService.debug(`APIM request id: ${apim}`);
@@ -553,7 +613,7 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
             }
             // 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);
+            const modelRequestId = (0, fetch_1.getRequestId)(response.headers);
             telemetryData.extendWithRequestId(modelRequestId);
             // TODO: Add response length (requires parsing)
             const totalTimeMs = Date.now() - requestStart;
@@ -584,7 +644,7 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
         });
     }
     async _handleError(telemetryData, response, requestId) {
-        const modelRequestIdObj = (0, fetch_1.getRequestId)(response, undefined);
+        const modelRequestIdObj = (0, fetch_1.getRequestId)(response.headers);
         requestId = modelRequestIdObj.headerRequestId || requestId;
         modelRequestIdObj.headerRequestId = requestId;
         telemetryData.properties.error = `Response status was ${response.status}`;
@@ -643,7 +703,10 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
             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);
+                if (!this._authenticationService.copilotToken?.isChatQuotaExceeded) {
+                    this._authenticationService.resetCopilotToken(response.status);
+                    await this._authenticationService.getCopilotToken();
+                }
                 const retryAfter = response.headers.get('retry-after');
                 const convertToDate = (retryAfterString) => {
                     if (!retryAfterString) {
@@ -783,7 +846,7 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
             reason: `Request Failed: ${response.status} ${text}`
         };
     }
-    async processSuccessfulResponse(response, messages, requestBody, requestId, maxResponseTokens, promptTokenCount, timeToFirstToken, streamRecorder, baseTelemetry, chatEndpointInfo, userInitiatedRequest, fetcher) {
+    async processSuccessfulResponse(response, messages, requestBody, requestId, maxResponseTokens, promptTokenCount, timeToFirstToken, streamRecorder, baseTelemetry, chatEndpointInfo, userInitiatedRequest, fetcher, bytesReceived) {
         const completions = [];
         for await (const chatCompletion of response.chatCompletions) {
             chatMLFetcherTelemetry_1.ChatMLFetcherTelemetrySender.sendSuccessTelemetry(this._telemetryService, {
@@ -798,6 +861,7 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
                 timeToFirstTokenEmitted: (baseTelemetry && streamRecorder.firstTokenEmittedTime) ? streamRecorder.firstTokenEmittedTime - baseTelemetry.issuedTime : -1,
                 hasImageMessages: this.filterImageMessages(messages),
                 fetcher,
+                bytesReceived,
             });
             if (!this.isRepetitive(chatCompletion, baseTelemetry?.properties)) {
                 completions.push(chatCompletion);
@@ -885,7 +949,62 @@ let ChatMLFetcherImpl = class ChatMLFetcherImpl extends AbstractChatMLFetcher {
         }
         return hasRepetition;
     }
-    processCanceledResponse(response, requestId) {
+    /**
+     * Check for repetition in partial response deltas from a cancelled request.
+     *
+     * This method performs the same repetition detection as the `isRepetitive` method,
+     * but operates on partial response data collected before the request was cancelled.
+     *
+     * Key differences from completed requests:
+     * - Text is reconstructed from delta.text values instead of message.content
+     * - Tokens are approximated by splitting text on whitespace instead of using
+     *   the actual token array (which is only available in completed responses)
+     * - Enhanced telemetry won't include RequestId fields since we only have the
+     *   headerRequestId string, not the full RequestId object
+     * - The finishReason is marked as 'canceled' to distinguish from server-generated
+     *   finish reasons
+     */
+    checkRepetitionInDeltas(deltas, requestId, telemetryProperties) {
+        // Reconstruct the text content from deltas (filter out null, undefined, and empty text values)
+        const textContent = deltas.filter(delta => delta.text?.length > 0).map(delta => delta.text).join('');
+        // Early exit if no content
+        if (!textContent || textContent.trim().length === 0) {
+            return;
+        }
+        // For cancelled requests, we don't have the actual token array (only available in ChatCompletion),
+        // so we approximate by splitting text content on whitespace. This is less precise than actual
+        // tokenization but sufficient for detecting obvious repetition patterns.
+        const tokens = textContent.split(/\s+/).filter(t => t.length > 0);
+        // Check for line repetition
+        const lineRepetitionStats = (0, anomalyDetection_1.calculateLineRepetitionStats)(textContent);
+        // Check for token-level repetition
+        const hasRepetition = (0, anomalyDetection_1.isRepetitive)(tokens);
+        // Send telemetry if repetition is detected
+        if (hasRepetition) {
+            const telemetryData = telemetryData_1.TelemetryData.createAndMarkAsIssued();
+            const extended = telemetryData.extendedBy(telemetryProperties);
+            // Note: For cancelled requests, we don't have a full RequestId object,
+            // so we can't use extendWithRequestId like the non-cancelled path does.
+            // This means enhanced telemetry for cancelled requests won't include
+            // completionId, created, deploymentId, or serverExperiments fields.
+            this._telemetryService.sendEnhancedGHTelemetryEvent('conversation.repetition.detected', extended.properties, extended.measurements);
+        }
+        if (lineRepetitionStats.numberOfRepetitions >= 10) {
+            this._telemetryService.sendMSFTTelemetryEvent('conversation.repetition.detected', {
+                requestId: requestId,
+                finishReason: 'canceled', // Client-side finish reason to distinguish from server-generated reasons
+            }, {
+                numberOfRepetitions: lineRepetitionStats.numberOfRepetitions,
+                lengthOfLine: lineRepetitionStats.mostRepeatedLine.length,
+                totalLines: lineRepetitionStats.totalLines
+            });
+        }
+    }
+    processCanceledResponse(response, requestId, streamRecorder, telemetryProperties) {
+        // Check for repetition in the partial response before cancellation
+        if (streamRecorder && streamRecorder.deltas.length > 0) {
+            this.checkRepetitionInDeltas(streamRecorder.deltas, requestId, telemetryProperties);
+        }
         return {
             type: commonTypes_1.ChatFetchResponseType.Canceled,
             reason: response.reason,
@@ -1071,6 +1190,8 @@ function locationToIntent(location) {
             return 'conversation-agent';
         case commonTypes_1.ChatLocation.ResponsesProxy:
             return 'responses-proxy';
+        case commonTypes_1.ChatLocation.MessagesProxy:
+            return 'messages-proxy';
     }
 }
 //# sourceMappingURL=chatMLFetcher.js.map