refactor(adapters): consolidate abort/sleep helpers into upstream-retry

google-http and cursor transport-retry carried byte-identical copies of
abortError/sleepWithAbort; both now import the canonical helpers from the
upstream-retry leaf module. abortAwareSleep stays as a compat re-export.
Behavior-neutral; retry delay calculators stay local (different constants).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: lidge-jun

src/adapters/cursor/transport-retry.ts

@@ -1,5 +1,9 @@
 import type { CursorRunRequest, CursorServerMessage } from "./types";
 import type { CursorTransport, CursorTransportFactory, CursorTransportFactoryInput } from "./transport";
+import { abortError, sleepWithAbort } from "../../upstream-retry";
+
+// Compat: historical name for the shared abortable sleep, kept for external callers.
+export { sleepWithAbort as abortAwareSleep } from "../../upstream-retry";
 
 export const CURSOR_RETRY_ATTEMPTS = 3;
 export const CURSOR_RETRY_BASE_MS = 250;
@@ -36,31 +40,6 @@ export function cursorRetryDelayMs(attempt: number): number {
   return Math.floor(exp * (0.8 + Math.random() * 0.4));
 }
 
-function abortError(signal?: AbortSignal): unknown {
-  return signal?.reason ?? new DOMException("The operation was aborted", "AbortError");
-}
-
-export async function abortAwareSleep(ms: number, signal?: AbortSignal): Promise<void> {
-  if (ms <= 0) return;
-  if (signal?.aborted) throw abortError(signal);
-  await new Promise<void>((resolve, reject) => {
-    let timer: ReturnType<typeof setTimeout>;
-    const cleanup = () => {
-      clearTimeout(timer);
-      signal?.removeEventListener("abort", onAbort);
-    };
-    const onAbort = () => {
-      cleanup();
-      reject(abortError(signal));
-    };
-    timer = setTimeout(() => {
-      cleanup();
-      resolve();
-    }, ms);
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
-
 /**
  * A transport is safe to retry only if it explicitly reports the run request was never committed.
  * A transport without `requestCommitted` is treated as committed (not retryable) — fail safe.
@@ -105,7 +84,7 @@ export async function runCursorTurnWithRetry(
         requestUncommitted(transport) &&
         isRetryableCursorError(err);
       if (!canRetry) throw err;
-      await abortAwareSleep(cursorRetryDelayMs(attempt), signal);
+      await sleepWithAbort(cursorRetryDelayMs(attempt), signal);
     } finally {
       await transport.close?.();
     }

src/adapters/google-http.ts

@@ -1,5 +1,6 @@
 import type { AdapterFetchContext, AdapterRequest } from "./base";
 import { isQuotaExhaustedBody, retryableGoogleStatus, safeGoogleHttpErrorMessage } from "./google-errors";
+import { abortError, sleepWithAbort } from "../upstream-retry";
 
 const GOOGLE_RETRY_ATTEMPTS = 3;
 const GOOGLE_RETRY_BASE_MS = 250;
@@ -22,22 +23,6 @@ function retryDelayMs(attempt: number, headers?: Headers): number {
   return Math.floor(exp * (0.8 + Math.random() * 0.4));
 }
 
-function abortError(signal?: AbortSignal): unknown {
-  return signal?.reason ?? new DOMException("The operation was aborted", "AbortError");
-}
-
-async function sleepWithAbort(ms: number, signal?: AbortSignal): Promise<void> {
-  if (ms <= 0) return;
-  if (signal?.aborted) throw abortError(signal);
-  await new Promise<void>((resolve, reject) => {
-    let timer: ReturnType<typeof setTimeout>;
-    const cleanup = () => { clearTimeout(timer); signal?.removeEventListener("abort", onAbort); };
-    const onAbort = () => { cleanup(); reject(abortError(signal)); };
-    timer = setTimeout(() => { cleanup(); resolve(); }, ms);
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
-
 function signalWithAttemptTimeout(parent: AbortSignal | undefined, timeoutMs: number): AbortSignal {
   const timeout = AbortSignal.timeout(timeoutMs);
   return parent ? AbortSignal.any([parent, timeout]) : timeout;