opencode-copilot-account-switcher 0.11.0 → 0.12.0

package/dist/copilot-network-retry.js

@@ -1,19 +1,7 @@
 import { appendFileSync } from "node:fs";
-const RETRYABLE_MESSAGES = [
-    "load failed",
-    "failed to fetch",
-    "network request failed",
-    "unable to connect",
-    "econnreset",
-    "etimedout",
-    "socket hang up",
-    "unknown certificate",
-    "self signed certificate",
-    "unable to verify the first certificate",
-    "self-signed certificate in certificate chain",
-];
-const AI_ERROR_MARKER = Symbol.for("vercel.ai.error");
-const API_CALL_ERROR_MARKER = Symbol.for("vercel.ai.error.AI_APICallError");
+import { getSharedErrorMessage, noopSharedRetryNotifier, notifySharedRetryEvent, runSharedFailOpenBoundary, runSharedRetryScheduler, } from "./retry/shared-engine.js";
+import { createNetworkRetryEngine } from "./network-retry-engine.js";
+import { createCopilotRetryPolicy, isRetryableCopilotTransportError, } from "./retry/copilot-policy.js";
 const INTERNAL_SESSION_HEADER = "x-opencode-session-id";
 const INTERNAL_DEBUG_LINK_HEADER = "x-opencode-debug-link-id";
 export const INTERNAL_SESSION_CONTEXT_KEY = "__opencodeInternalSessionID";
@@ -44,7 +32,7 @@ function isAbortError(error) {
     return error instanceof Error && error.name === "AbortError";
 }
 function getErrorMessage(error) {
-    return String(error instanceof Error ? error.message : error).toLowerCase();
+    return getSharedErrorMessage(error);
 }
 function isInputIdTooLongErrorBody(payload) {
     if (!payload || typeof payload !== "object")
@@ -422,21 +410,6 @@ function buildRetryInit(init, payload) {
         body: JSON.stringify(payload),
     };
 }
-const noopNotifier = {
-    started: async () => { },
-    progress: async () => { },
-    repairWarning: async () => { },
-    completed: async () => { },
-    stopped: async () => { },
-};
-async function notify(notifier, event, remaining) {
-    try {
-        await notifier[event]({ remaining });
-    }
-    catch (error) {
-        console.warn(`[copilot-network-retry] notifier ${event} failed`, error);
-    }
-}
 function stripInternalSessionHeaderFromRequest(request) {
     if (!(request instanceof Request))
         return request;
@@ -705,52 +678,21 @@ async function repairSessionParts(sessionID, itemIds, ctx) {
     }
     return patchedAll;
 }
-async function maybeRetryConnectionMismatchItemIds(request, init, response, baseFetch, requestPayload, ctx, sessionID, startedNotified = false) {
-    if (response.ok) {
-        return {
-            response,
-            retried: false,
-            nextInit: init,
-            nextPayload: requestPayload,
-            retryState: undefined,
-        };
-    }
+async function maybeRetryConnectionMismatchItemIds(request, init, currentResponse, decision, baseFetch, requestPayload, ctx, sessionID, startedNotified = false) {
     const removableIds = collectInputItemIds(requestPayload);
     if (!requestPayload || removableIds.length === 0) {
         return {
-            response,
+            response: currentResponse,
             retried: false,
             nextInit: init,
             nextPayload: requestPayload,
             retryState: undefined,
         };
     }
-    const responseText = await response
-        .clone()
-        .text()
-        .catch(() => "");
+    const responseText = decision.responseText;
     if (!responseText) {
         return {
-            response,
-            retried: false,
-            nextInit: init,
-            nextPayload: requestPayload,
-            retryState: undefined,
-        };
-    }
-    let matched = isConnectionMismatchInputIdMessage(responseText);
-    if (!matched) {
-        try {
-            const bodyPayload = JSON.parse(responseText);
-            matched = isConnectionMismatchInputIdErrorBody(bodyPayload);
-        }
-        catch {
-            matched = false;
-        }
-    }
-    if (!matched) {
-        return {
-            response,
+            response: currentResponse,
             retried: false,
             nextInit: init,
             nextPayload: requestPayload,
@@ -760,13 +702,23 @@ async function maybeRetryConnectionMismatchItemIds(request, init, response, base
     const remainingBefore = countInputIdCandidates(requestPayload);
     const notifiedStarted = startedNotified || remainingBefore > 0;
     let repairFailed = false;
-    if (sessionID) {
-        repairFailed = !(await repairSessionParts(sessionID, removableIds, ctx).catch(() => false));
+    if (decision.shouldAttemptSessionRepair && sessionID) {
+        const repairResult = await runSharedFailOpenBoundary({
+            action: () => repairSessionParts(sessionID, removableIds, ctx),
+            isFailOpenError: () => true,
+            onFailOpen: (error) => {
+                debugLog("input-id retry session bulk repair failed-open", {
+                    sessionID,
+                    error: String(error instanceof Error ? error.message : error),
+                });
+            },
+        });
+        repairFailed = !(repairResult.ok ? repairResult.value : false);
     }
     const sanitized = stripAllInputIds(requestPayload);
     if (sanitized === requestPayload) {
         return {
-            response,
+            response: currentResponse,
             retried: false,
             nextInit: init,
             nextPayload: requestPayload,
@@ -803,20 +755,11 @@ async function maybeRetryConnectionMismatchItemIds(request, init, response, base
     });
     return { response: retried, retried: true, nextInit, nextPayload: sanitized, retryState };
 }
-async function maybeRetryInputIdTooLong(request, init, response, baseFetch, requestPayload, ctx, sessionID, startedNotified = false) {
-    if (response.ok) {
-        return {
-            response,
-            retried: false,
-            nextInit: init,
-            nextPayload: requestPayload,
-            retryState: undefined,
-        };
-    }
+async function maybeRetryInputIdTooLong(request, init, currentResponse, decision, baseFetch, requestPayload, ctx, sessionID, startedNotified = false) {
     if (!requestPayload || !hasLongInputIds(requestPayload)) {
         debugLog("skip input-id retry: request has no long ids");
         return {
-            response,
+            response: currentResponse,
             retried: false,
             nextInit: init,
             nextPayload: requestPayload,
@@ -824,38 +767,27 @@ async function maybeRetryInputIdTooLong(request, init, response, baseFetch, requ
         };
     }
     debugLog("input-id retry candidate", {
-        status: response.status,
-        contentType: response.headers.get("content-type") ?? undefined,
+        serverReportedIndex: decision.serverReportedIndex,
+        reportedLength: decision.reportedLength,
     });
-    const responseText = await response
-        .clone()
-        .text()
-        .catch(() => "");
+    const responseText = decision.responseText;
     if (!responseText) {
         debugLog("skip input-id retry: empty response body");
         return {
-            response,
+            response: currentResponse,
             retried: false,
             nextInit: init,
             nextPayload: requestPayload,
             retryState: undefined,
         };
     }
-    let parsed = parseInputIdTooLongDetails(responseText);
-    let matched = parsed.matched;
-    if (!matched) {
-        try {
-            const bodyPayload = JSON.parse(responseText);
-            const error = bodyPayload.error;
-            parsed = parseInputIdTooLongDetails(String(error?.message ?? ""));
-            matched = parsed.matched || isInputIdTooLongErrorBody(bodyPayload);
-        }
-        catch {
-            matched = false;
-        }
-    }
+    const parsed = {
+        matched: true,
+        serverReportedIndex: decision.serverReportedIndex,
+        reportedLength: decision.reportedLength,
+    };
     debugLog("input-id retry detection", {
-        matched,
+        matched: true,
         serverReportedIndex: parsed.serverReportedIndex,
         reportedLength: parsed.reportedLength,
         bodyPreview: responseText.slice(0, 200),
@@ -864,15 +796,6 @@ async function maybeRetryInputIdTooLong(request, init, response, baseFetch, requ
         serverReportedIndex: parsed.serverReportedIndex,
         reportedLength: parsed.reportedLength,
     });
-    if (!matched) {
-        return {
-            response,
-            retried: false,
-            nextInit: init,
-            nextPayload: requestPayload,
-            retryState: undefined,
-        };
-    }
     const payloadCandidates = getPayloadCandidates(requestPayload);
     const targetSelection = getTargetedLongInputIdSelection(requestPayload, parsed.serverReportedIndex, parsed.reportedLength);
     debugLog("input-id retry payload candidates", {
@@ -900,7 +823,7 @@ async function maybeRetryInputIdTooLong(request, init, response, baseFetch, requ
             reportedLengthMatched: targetSelection.reportedLengthMatched,
         });
         return {
-            response,
+            response: currentResponse,
             retried: false,
             nextInit: init,
             nextPayload: requestPayload,
@@ -918,14 +841,24 @@ async function maybeRetryInputIdTooLong(request, init, response, baseFetch, requ
     }
     const notifiedStarted = startedNotified || remainingBefore > 0;
     let repairFailed = false;
-    if (sessionID && failingId) {
-        repairFailed = !(await repairSessionPart(sessionID, failingId, ctx).catch(() => false));
+    if (decision.shouldAttemptSessionRepair && sessionID && failingId) {
+        const repairResult = await runSharedFailOpenBoundary({
+            action: () => repairSessionPart(sessionID, failingId, ctx),
+            isFailOpenError: () => true,
+            onFailOpen: (error) => {
+                debugLog("input-id retry session repair failed-open", {
+                    sessionID,
+                    error: String(error instanceof Error ? error.message : error),
+                });
+            },
+        });
+        repairFailed = !(repairResult.ok ? repairResult.value : false);
     }
     const sanitized = stripTargetedLongInputId(requestPayload, parsed.serverReportedIndex, parsed.reportedLength);
     if (sanitized === requestPayload) {
         debugLog("skip input-id retry: sanitize made no changes");
         return {
-            response,
+            response: currentResponse,
             retried: false,
             nextInit: init,
             nextPayload: requestPayload,
@@ -961,49 +894,6 @@ async function maybeRetryInputIdTooLong(request, init, response, baseFetch, requ
     });
     return { response: retried, retried: true, nextInit, nextPayload: sanitized, retryState };
 }
-function getRequestUrl(request) {
-    return request instanceof Request ? request.url : request instanceof URL ? request.href : String(request);
-}
-function buildRetryableApiCallMessage(group, detail) {
-    return `Copilot retryable error [${group}]: ${detail}`;
-}
-function toRetryableApiCallError(error, request, options) {
-    const base = error instanceof Error ? error : new Error(String(error));
-    const wrapped = new Error(buildRetryableApiCallMessage(options?.group ?? "transport", base.message));
-    wrapped.name = "AI_APICallError";
-    wrapped.url = getRequestUrl(request);
-    wrapped.requestBodyValues = options?.requestBodyValues ?? {};
-    wrapped.statusCode = options?.statusCode;
-    wrapped.responseHeaders = options?.responseHeaders instanceof Headers
-        ? Object.fromEntries(options.responseHeaders.entries())
-        : options?.responseHeaders;
-    wrapped.responseBody = options?.responseBody;
-    wrapped.isRetryable = true;
-    wrapped.cause = error;
-    wrapped[AI_ERROR_MARKER] = true;
-    wrapped[API_CALL_ERROR_MARKER] = true;
-    return wrapped;
-}
-function isRetryableApiCallError(error) {
-    return Boolean(error
-        && typeof error === "object"
-        && error[AI_ERROR_MARKER] === true
-        && error[API_CALL_ERROR_MARKER] === true);
-}
-function isRetryableCopilotStatus(status) {
-    return status === 499;
-}
-function isCopilotUrl(request) {
-    const raw = request instanceof Request ? request.url : request instanceof URL ? request.href : String(request);
-    try {
-        const url = new URL(raw);
-        const isCopilotHost = url.hostname === "api.githubcopilot.com" || url.hostname.startsWith("copilot-api.");
-        return isCopilotHost;
-    }
-    catch {
-        return false;
-    }
-}
 async function getInputIdRetryErrorDetails(response) {
     if (response.ok)
         return undefined;
@@ -1055,7 +945,7 @@ async function parseJsonRequestPayload(request, init) {
         return undefined;
     }
 }
-function withStreamDebugLogs(response, request) {
+function withStreamDebugLogs(response, request, policy) {
     const contentType = response.headers.get("content-type")?.toLowerCase() ?? "";
     if (!contentType.includes("text/event-stream") || !response.body)
         return response;
@@ -1077,8 +967,14 @@ function withStreamDebugLogs(response, request) {
                 }
                 catch (error) {
                     const message = getErrorMessage(error);
-                    const isSseReadTimeout = message.includes("sse read timed out");
-                    const retryable = RETRYABLE_MESSAGES.some((part) => message.includes(part));
+                    const normalized = policy.normalizeStreamError({
+                        error,
+                        request,
+                        statusCode: response.status,
+                        responseHeaders: response.headers,
+                    });
+                    const isSseReadTimeout = normalized === error && message.includes("sse read timed out");
+                    const retryable = normalized !== error;
                     if (isDebugEnabled()) {
                         debugLog("sse stream read error", {
                             url: rawUrl,
@@ -1087,15 +983,7 @@ function withStreamDebugLogs(response, request) {
                             bypassedTimeoutWrap: isSseReadTimeout,
                         });
                     }
-                    controller.error(isSseReadTimeout
-                        ? error
-                        : retryable
-                            ? toRetryableApiCallError(error, request, {
-                                group: "stream",
-                                statusCode: response.status,
-                                responseHeaders: response.headers,
-                            })
-                            : error);
+                    controller.error(isSseReadTimeout ? error : normalized);
                 }
             };
             void pump();
@@ -1108,10 +996,7 @@ function withStreamDebugLogs(response, request) {
     });
 }
 export function isRetryableCopilotFetchError(error) {
-    if (!error || isAbortError(error))
-        return false;
-    const message = getErrorMessage(error);
-    return RETRYABLE_MESSAGES.some((part) => message.includes(part));
+    return isRetryableCopilotTransportError(error);
 }
 function isRetryableCopilotJsonParseError(error) {
     if (!error || isAbortError(error))
@@ -1121,9 +1006,166 @@ function isRetryableCopilotJsonParseError(error) {
     const hasAiJsonParseSignature = name === "AI_JSONParseError" || message.includes("ai_jsonparseerror");
     return hasAiJsonParseSignature && message.includes("json parsing failed") && message.includes("text:");
 }
+function toRequestUrl(request) {
+    return request instanceof Request ? request.url : request instanceof URL ? request.href : String(request);
+}
+async function runCopilotRepairLoop(input) {
+    const state = {
+        currentResponse: input.response,
+        currentInit: input.effectiveInit,
+        currentPayload: input.currentPayload,
+        attempts: 0,
+        startedNotified: false,
+        finishedNotified: false,
+        repairWarningNotified: false,
+    };
+    const handleRetryResult = async (result) => {
+        state.currentResponse = result.response;
+        state.currentInit = result.nextInit;
+        state.currentPayload = result.nextPayload;
+        if (!result.retryState) {
+            return {
+                handled: false,
+                stop: false,
+                shouldContinue: false,
+            };
+        }
+        if (!state.startedNotified && result.retryState.notifiedStarted) {
+            state.startedNotified = true;
+            await notifySharedRetryEvent(input.notifier, "started", result.retryState.remainingLongIdCandidatesBefore);
+        }
+        if (result.retryState.repairFailed && !state.repairWarningNotified) {
+            await notifySharedRetryEvent(input.notifier, "repairWarning", result.retryState.remainingLongIdCandidatesBefore);
+            state.repairWarningNotified = true;
+        }
+        const currentError = await getInputIdRetryErrorDetails(state.currentResponse);
+        let stopReason = result.retryState.stopReason;
+        const madeProgress = result.retryState.remainingLongIdCandidatesAfter < result.retryState.remainingLongIdCandidatesBefore;
+        if (!stopReason && result.retryState.remainingLongIdCandidatesAfter >= result.retryState.remainingLongIdCandidatesBefore) {
+            stopReason = "remaining-candidates-not-reduced";
+        }
+        if (!stopReason
+            && currentError
+            && result.retryState.remainingLongIdCandidatesAfter > 0
+            && result.retryState.previousServerReportedIndex === currentError.serverReportedIndex
+            && result.retryState.previousReportedLength === currentError.reportedLength) {
+            stopReason = "same-server-item-persists";
+        }
+        if (!stopReason && currentError && result.retryState.remainingLongIdCandidatesAfter === 0) {
+            stopReason = "local-candidates-exhausted";
+        }
+        if ((currentError || stopReason) && stopReason !== "evidence-insufficient") {
+            debugLog("input-id retry progress", {
+                attempt: state.attempts + 1,
+                previousServerReportedIndex: result.retryState.previousServerReportedIndex,
+                currentServerReportedIndex: currentError?.serverReportedIndex,
+                serverIndexChanged: result.retryState.previousServerReportedIndex !== currentError?.serverReportedIndex,
+                previousErrorMessagePreview: result.retryState.previousErrorMessagePreview,
+                currentErrorMessagePreview: currentError?.errorMessagePreview,
+                remainingLongIdCandidatesBefore: result.retryState.remainingLongIdCandidatesBefore,
+                remainingLongIdCandidatesAfter: result.retryState.remainingLongIdCandidatesAfter,
+                stopReason,
+            });
+        }
+        if (stopReason === "local-candidates-exhausted") {
+            logCleanupStopped("local-candidates-exhausted", {
+                attempt: state.attempts + 1,
+                previousServerReportedIndex: result.retryState.previousServerReportedIndex,
+                currentServerReportedIndex: currentError?.serverReportedIndex,
+            });
+        }
+        if (stopReason) {
+            await notifySharedRetryEvent(input.notifier, "stopped", result.retryState.remainingLongIdCandidatesAfter);
+            state.finishedNotified = true;
+            return {
+                handled: true,
+                stop: true,
+                shouldContinue: false,
+            };
+        }
+        if (result.retried && madeProgress && result.retryState.remainingLongIdCandidatesAfter > 0) {
+            await notifySharedRetryEvent(input.notifier, "progress", result.retryState.remainingLongIdCandidatesAfter);
+        }
+        if (result.retried && result.retryState.remainingLongIdCandidatesAfter === 0 && state.currentResponse.ok) {
+            await notifySharedRetryEvent(input.notifier, "completed", 0);
+            state.finishedNotified = true;
+        }
+        if (result.retried && result.retryState.remainingLongIdCandidatesAfter === 0 && !state.currentResponse.ok) {
+            await notifySharedRetryEvent(input.notifier, "stopped", 0);
+            state.finishedNotified = true;
+        }
+        if (!result.retried) {
+            if (state.startedNotified && !state.finishedNotified) {
+                await notifySharedRetryEvent(input.notifier, "stopped", result.retryState.remainingLongIdCandidatesAfter);
+                state.finishedNotified = true;
+            }
+            return {
+                handled: true,
+                stop: true,
+                shouldContinue: false,
+            };
+        }
+        return {
+            handled: true,
+            stop: false,
+            shouldContinue: madeProgress && result.retryState.remainingLongIdCandidatesAfter > 0,
+        };
+    };
+    await runSharedRetryScheduler({
+        initialShouldContinue: countInputIdCandidates(state.currentPayload) > 0,
+        runIteration: async ({ attempts: scheduledAttempts }) => {
+            state.attempts = scheduledAttempts;
+            const decision = await input.policy.decideResponseRepair({
+                request: input.safeRequest,
+                response: state.currentResponse,
+                requestPayload: state.currentPayload,
+                sessionID: input.sessionID,
+            });
+            if (decision.kind === "skip") {
+                if (state.startedNotified && !state.finishedNotified) {
+                    await notifySharedRetryEvent(input.notifier, "stopped", countInputIdCandidates(state.currentPayload));
+                    state.finishedNotified = true;
+                }
+                return {
+                    handled: false,
+                    stop: true,
+                    shouldContinue: false,
+                };
+            }
+            const result = decision.kind === "connection-mismatch"
+                ? await maybeRetryConnectionMismatchItemIds(input.safeRequest, state.currentInit, state.currentResponse, decision, input.baseFetch, state.currentPayload, input.options, input.sessionID, state.startedNotified)
+                : await maybeRetryInputIdTooLong(input.safeRequest, state.currentInit, state.currentResponse, decision, input.baseFetch, state.currentPayload, input.options, input.sessionID, state.startedNotified);
+            const handled = await handleRetryResult(result);
+            if (handled.stop)
+                return handled;
+            if (!handled.handled) {
+                if (state.startedNotified && !state.finishedNotified) {
+                    await notifySharedRetryEvent(input.notifier, "stopped", countInputIdCandidates(state.currentPayload));
+                    state.finishedNotified = true;
+                }
+                return {
+                    handled: false,
+                    stop: true,
+                    shouldContinue: false,
+                };
+            }
+            return handled;
+        },
+    });
+    return {
+        response: state.currentResponse,
+        payload: state.currentPayload,
+    };
+}
 export function createCopilotRetryingFetch(baseFetch, options) {
-    const notifier = options?.notifier ?? noopNotifier;
-    return async function retryingFetch(request, init) {
+    const notifier = options?.notifier ?? noopSharedRetryNotifier;
+    const policy = createCopilotRetryPolicy({
+        extraRetryableClassifier: isRetryableCopilotJsonParseError,
+    });
+    const retryEngine = createNetworkRetryEngine({
+        policy,
+    });
+    return retryEngine(async (request, init) => {
         const sessionID = getHeader(request, init, INTERNAL_SESSION_HEADER);
         const headersBeforeWrapper = toHeaderRecord(init?.headers) ?? (request instanceof Request ? toHeaderRecord(request.headers) : undefined);
         debugLog("fetch headers before wrapper", {
@@ -1145,157 +1187,38 @@ export function createCopilotRetryingFetch(baseFetch, options) {
             removedInternalHeaders: strippedHeaders.removed,
             isRetry: false,
         });
+        const isCopilotRequest = policy.matchesRequest(safeRequest);
         debugLog("fetch start", {
             url: safeRequest instanceof Request ? safeRequest.url : safeRequest instanceof URL ? safeRequest.href : String(safeRequest),
-            isCopilot: isCopilotUrl(safeRequest),
+            isCopilot: isCopilotRequest,
         });
         debugLog("fetch headers before network", {
             headers: toHeaderRecord(effectiveInit?.headers) ?? (safeRequest instanceof Request ? toHeaderRecord(safeRequest.headers) : undefined),
             isRetry: false,
         });
-        let currentPayload = await parseJsonRequestPayload(safeRequest, effectiveInit);
+        const currentPayload = await parseJsonRequestPayload(safeRequest, effectiveInit);
         try {
             const response = await baseFetch(safeRequest, effectiveInit);
             debugLog("fetch resolved", {
                 status: response.status,
                 contentType: response.headers.get("content-type") ?? undefined,
             });
-            if (isCopilotUrl(safeRequest) && isRetryableCopilotStatus(response.status)) {
-                const responseBody = await response.clone().text().catch(() => "");
-                throw toRetryableApiCallError(new Error(responseBody || `status code ${response.status}`), safeRequest, {
-                    group: "status",
-                    requestBodyValues: currentPayload,
-                    statusCode: response.status,
-                    responseHeaders: response.headers,
-                    responseBody: responseBody || undefined,
+            if (isCopilotRequest && policy.shouldRunResponseRepair(safeRequest)) {
+                const repaired = await runCopilotRepairLoop({
+                    safeRequest,
+                    effectiveInit,
+                    response,
+                    baseFetch,
+                    policy,
+                    options,
+                    notifier,
+                    sessionID,
+                    currentPayload,
                 });
+                return withStreamDebugLogs(repaired.response, safeRequest, policy);
             }
-            if (isCopilotUrl(safeRequest)) {
-                let currentResponse = response;
-                let currentInit = effectiveInit;
-                let attempts = 0;
-                let shouldContinueInputIdRepair = countInputIdCandidates(currentPayload) > 0;
-                let startedNotified = false;
-                let finishedNotified = false;
-                let repairWarningNotified = false;
-                const handleRetryResult = async (result) => {
-                    currentResponse = result.response;
-                    currentInit = result.nextInit;
-                    currentPayload = result.nextPayload;
-                    if (!result.retryState) {
-                        return {
-                            handled: false,
-                            stop: false,
-                            shouldContinue: false,
-                        };
-                    }
-                    if (!startedNotified && result.retryState.notifiedStarted) {
-                        startedNotified = true;
-                        await notify(notifier, "started", result.retryState.remainingLongIdCandidatesBefore);
-                    }
-                    if (result.retryState.repairFailed && !repairWarningNotified) {
-                        await notify(notifier, "repairWarning", result.retryState.remainingLongIdCandidatesBefore);
-                        repairWarningNotified = true;
-                    }
-                    const currentError = await getInputIdRetryErrorDetails(currentResponse);
-                    let stopReason = result.retryState.stopReason;
-                    const madeProgress = result.retryState.remainingLongIdCandidatesAfter < result.retryState.remainingLongIdCandidatesBefore;
-                    if (!stopReason && result.retryState.remainingLongIdCandidatesAfter >= result.retryState.remainingLongIdCandidatesBefore) {
-                        stopReason = "remaining-candidates-not-reduced";
-                    }
-                    if (!stopReason &&
-                        currentError &&
-                        result.retryState.remainingLongIdCandidatesAfter > 0 &&
-                        result.retryState.previousServerReportedIndex === currentError.serverReportedIndex &&
-                        result.retryState.previousReportedLength === currentError.reportedLength) {
-                        stopReason = "same-server-item-persists";
-                    }
-                    if (!stopReason && currentError && result.retryState.remainingLongIdCandidatesAfter === 0) {
-                        stopReason = "local-candidates-exhausted";
-                    }
-                    if ((currentError || stopReason) && stopReason !== "evidence-insufficient") {
-                        debugLog("input-id retry progress", {
-                            attempt: attempts + 1,
-                            previousServerReportedIndex: result.retryState.previousServerReportedIndex,
-                            currentServerReportedIndex: currentError?.serverReportedIndex,
-                            serverIndexChanged: result.retryState.previousServerReportedIndex !== currentError?.serverReportedIndex,
-                            previousErrorMessagePreview: result.retryState.previousErrorMessagePreview,
-                            currentErrorMessagePreview: currentError?.errorMessagePreview,
-                            remainingLongIdCandidatesBefore: result.retryState.remainingLongIdCandidatesBefore,
-                            remainingLongIdCandidatesAfter: result.retryState.remainingLongIdCandidatesAfter,
-                            stopReason,
-                        });
-                    }
-                    if (stopReason === "local-candidates-exhausted") {
-                        logCleanupStopped("local-candidates-exhausted", {
-                            attempt: attempts + 1,
-                            previousServerReportedIndex: result.retryState.previousServerReportedIndex,
-                            currentServerReportedIndex: currentError?.serverReportedIndex,
-                        });
-                    }
-                    if (stopReason) {
-                        await notify(notifier, "stopped", result.retryState.remainingLongIdCandidatesAfter);
-                        finishedNotified = true;
-                        return {
-                            handled: true,
-                            stop: true,
-                            shouldContinue: false,
-                        };
-                    }
-                    if (result.retried && madeProgress && result.retryState.remainingLongIdCandidatesAfter > 0) {
-                        await notify(notifier, "progress", result.retryState.remainingLongIdCandidatesAfter);
-                    }
-                    if (result.retried && result.retryState.remainingLongIdCandidatesAfter === 0 && currentResponse.ok) {
-                        await notify(notifier, "completed", 0);
-                        finishedNotified = true;
-                    }
-                    if (result.retried && result.retryState.remainingLongIdCandidatesAfter === 0 && !currentResponse.ok) {
-                        await notify(notifier, "stopped", 0);
-                        finishedNotified = true;
-                    }
-                    if (!result.retried) {
-                        if (startedNotified && !finishedNotified) {
-                            await notify(notifier, "stopped", result.retryState.remainingLongIdCandidatesAfter);
-                            finishedNotified = true;
-                        }
-                        return {
-                            handled: true,
-                            stop: true,
-                            shouldContinue: false,
-                        };
-                    }
-                    return {
-                        handled: true,
-                        stop: false,
-                        shouldContinue: madeProgress && result.retryState.remainingLongIdCandidatesAfter > 0,
-                    };
-                };
-                while (shouldContinueInputIdRepair) {
-                    shouldContinueInputIdRepair = false;
-                    const connectionMismatchResult = await maybeRetryConnectionMismatchItemIds(safeRequest, currentInit, currentResponse, baseFetch, currentPayload, options, sessionID, startedNotified);
-                    const handledConnectionMismatch = await handleRetryResult(connectionMismatchResult);
-                    if (handledConnectionMismatch.stop)
-                        break;
-                    if (handledConnectionMismatch.handled) {
-                        attempts += 1;
-                        shouldContinueInputIdRepair = handledConnectionMismatch.shouldContinue;
-                        continue;
-                    }
-                    const result = await maybeRetryInputIdTooLong(safeRequest, currentInit, currentResponse, baseFetch, currentPayload, options, sessionID, startedNotified);
-                    const handled = await handleRetryResult(result);
-                    if (handled.stop)
-                        break;
-                    if (!handled.handled) {
-                        if (startedNotified && !finishedNotified) {
-                            await notify(notifier, "stopped", countInputIdCandidates(currentPayload));
-                            finishedNotified = true;
-                        }
-                        break;
-                    }
-                    attempts += 1;
-                    shouldContinueInputIdRepair = handled.shouldContinue;
-                }
-                return withStreamDebugLogs(currentResponse, safeRequest);
+            if (isCopilotRequest) {
+                return withStreamDebugLogs(response, safeRequest, policy);
             }
             return response;
         }
@@ -1307,16 +1230,7 @@ export function createCopilotRetryingFetch(baseFetch, options) {
                 retryableByMessage,
                 retryableCopilotJsonParse,
             });
-            if (!isCopilotUrl(safeRequest) || (!retryableByMessage && !retryableCopilotJsonParse)) {
-                throw error;
-            }
-            if (isRetryableApiCallError(error)) {
-                throw error;
-            }
-            throw toRetryableApiCallError(error, safeRequest, {
-                group: "transport",
-                requestBodyValues: currentPayload,
-            });
+            throw error;
         }
-    };
+    });
 }