fix(http): preserve timeout race classification

Author: JerryNee

src/lib/http.test.ts

@@ -474,6 +474,33 @@ describe('HttpClient per-request timeout', () => {
     expect((err as Error).name).toBe('AbortError');
   });
 
+  it('preserves RequestTimeoutError when the caller aborts after the request timeout wins', async () => {
+    const controller = new AbortController();
+    const fetchImpl = vi.fn(async (_input: unknown, init?: { signal?: AbortSignal }) => {
+      return new Promise<Response>((_resolve, reject) => {
+        init?.signal?.addEventListener('abort', () => {
+          const reason = init.signal?.reason;
+          controller.abort(new Error('caller aborted after timeout'));
+          const err = new Error(reason?.message ?? 'timed out');
+          err.name = reason?.name ?? 'TimeoutError';
+          reject(err);
+        });
+      });
+    });
+    const client = new HttpClient({
+      baseUrl: 'https://api.example.com/api/cli/v1',
+      apiKey: 'sk-test',
+      fetchImpl: fetchImpl as unknown as typeof fetch,
+      sleep: () => Promise.resolve(),
+      random: () => 0,
+      requestTimeoutMs: 1,
+    });
+    const err = await client.get('/me', { signal: controller.signal }).catch(e => e);
+    expect(err).toBeInstanceOf(RequestTimeoutError);
+    expect((err as RequestTimeoutError).exitCode).toBe(7);
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+  });
+
   it('defaults to REQUEST_TIMEOUT_DEFAULT_MS when no requestTimeoutMs is supplied', () => {
     // Verify the default is wired without actually waiting 120s.
     // We test via the exported constant rather than exercising the stall.

src/lib/http.ts

@@ -395,9 +395,15 @@ export class HttpClient {
     timeoutSignal: AbortSignal,
     callerSignal: AbortSignal | undefined,
     requestId: string,
+    effectiveSignal: AbortSignal = timeoutSignal,
   ): void {
     if (isAbortError(err) || isTimeoutError(err)) {
-      if (timeoutSignal.aborted && (callerSignal == null || !callerSignal.aborted)) {
+      const timeoutWon =
+        timeoutSignal.aborted &&
+        (callerSignal == null ||
+          !callerSignal.aborted ||
+          effectiveSignal.reason === timeoutSignal.reason);
+      if (timeoutWon) {
         throw new RequestTimeoutError(this.requestTimeoutMs, requestId);
       }
       throw err;
@@ -451,7 +457,7 @@ export class HttpClient {
           // the caller hadn't already aborted, surface a clear RequestTimeoutError.
           // A timeout/abort during the fetch itself: classify it (RequestTimeoutError
           // when our deadline fired; otherwise rethrow the caller's abort unmodified).
-          this.rethrowIfAbort(err, timeoutSignal, options.signal, requestId);
+          this.rethrowIfAbort(err, timeoutSignal, options.signal, requestId, effectiveSignal);
           // If a RequestTimeoutError already propagated from somewhere (e.g. from a
           // nested call or from a test-injected fetchImpl), pass it through unchanged
           // rather than re-wrapping it as a TransportError.
@@ -500,7 +506,7 @@ export class HttpClient {
             return { body: (await response.json()) as T, requestId, status: response.status };
           } catch (err) {
             // A timeout/abort can fire mid-body-read (headers received, stream stalls).
-            this.rethrowIfAbort(err, timeoutSignal, options.signal, requestId);
+            this.rethrowIfAbort(err, timeoutSignal, options.signal, requestId, effectiveSignal);
             throw err;
           }
         }
@@ -511,7 +517,7 @@ export class HttpClient {
         } catch (err) {
           // safeReadJson rethrows aborts/timeouts (it swallows only non-abort parse
           // errors), so a timeout fired mid-body-read on a non-OK response lands here.
-          this.rethrowIfAbort(err, timeoutSignal, options.signal, requestId);
+          this.rethrowIfAbort(err, timeoutSignal, options.signal, requestId, effectiveSignal);
           throw err;
         }