fix: make all retry delays abort-aware to unblock sendPromise

Rename skippableDelay to delay and thread AbortSignal into all three
retry delay sites (rate-limit, invalid-stream, content-error). When the
request's AbortSignal fires during any countdown, the delay promise
rejects, the generator exits via its finally block, and sendPromise is
released so the next sendMessageStream call can proceed immediately.

Previously, cancelling during a rate-limit countdown (up to 60s) would
leave the generator blocked on the delay, preventing any subsequent
request from starting due to sendPromise serialization.

Author: huww98

packages/core/src/core/geminiChat.test.ts

@@ -1172,6 +1172,88 @@ describe('GeminiChat', async () => {
       }
     });
 
+    it('should exit retry loop when aborted during rate-limit delay', async () => {
+      vi.useFakeTimers();
+
+      try {
+        const tpmError = new StreamContentError(
+          '{"error":{"code":"429","message":"Throttling: TPM(1/1)"}}',
+        );
+        async function* failingStreamGenerator() {
+          throw tpmError;
+
+          yield {} as GenerateContentResponse;
+        }
+
+        const abortController = new AbortController();
+
+        vi.mocked(mockContentGenerator.generateContentStream)
+          .mockResolvedValueOnce(failingStreamGenerator())
+          // Should never be called — abort should prevent the second attempt
+          .mockResolvedValueOnce(failingStreamGenerator());
+
+        const stream = await chat.sendMessageStream(
+          'test-model',
+          { message: 'test', config: { abortSignal: abortController.signal } },
+          'prompt-id-abort-delay',
+        );
+
+        const iterator = stream[Symbol.asyncIterator]();
+        // First event: RETRY with retryInfo
+        const first = await iterator.next();
+        expect(first.value.type).toBe(StreamEventType.RETRY);
+
+        // Abort while the generator is awaiting the 60s delay
+        const nextPromise = iterator.next();
+        abortController.abort();
+
+        // The generator should throw the abort error
+        await expect(nextPromise).rejects.toThrow();
+
+        // Only one API call should have been made (no retry after abort)
+        expect(
+          mockContentGenerator.generateContentStream,
+        ).toHaveBeenCalledTimes(1);
+
+        // Verify the next sendMessageStream is not blocked by the old delay.
+        // If sendPromise were still pending, this would hang until the 60s
+        // timer fires — which never happens under fake timers, causing a timeout.
+        const nextStream = (async function* () {
+          yield {
+            candidates: [
+              {
+                content: { parts: [{ text: 'Next request OK' }] },
+                finishReason: 'STOP',
+              },
+            ],
+          } as unknown as GenerateContentResponse;
+        })();
+        vi.mocked(mockContentGenerator.generateContentStream)
+          .mockReset()
+          .mockResolvedValueOnce(nextStream);
+
+        const stream2 = await chat.sendMessageStream(
+          'test-model',
+          { message: 'follow-up' },
+          'prompt-id-after-abort',
+        );
+        const events: StreamEvent[] = [];
+        for await (const e of stream2) {
+          events.push(e);
+        }
+        expect(
+          events.some(
+            (e) =>
+              e.type === StreamEventType.CHUNK &&
+              e.value.candidates?.[0]?.content?.parts?.[0]?.text ===
+                'Next request OK',
+          ),
+        ).toBe(true);
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
     it('should retry on GLM rate limit StreamContentError with backoff delay', async () => {
       vi.useFakeTimers();
 

packages/core/src/core/geminiChat.ts

@@ -87,17 +87,41 @@ const RATE_LIMIT_RETRY_OPTIONS = {
 /**
  * Creates a promise that resolves after the specified delay, but can be
  * resolved early by calling the returned `skip` function.
+ *
+ * If an `AbortSignal` is provided and it fires before the delay completes,
+ * the promise rejects so the caller's `await` throws and normal error
+ * propagation takes over (e.g. the retry loop breaks and the generator exits).
  */
-function skippableDelay(delayMs: number): {
+function delay(
+  delayMs: number,
+  signal?: AbortSignal,
+): {
   promise: Promise<void>;
   skip: () => void;
 } {
   let resolveRef: () => void;
   let timeoutId: ReturnType<typeof setTimeout>;
-  const promise = new Promise<void>((resolve) => {
+
+  const promise = new Promise<void>((resolve, reject) => {
     resolveRef = resolve;
+
+    if (signal?.aborted) {
+      reject(signal.reason);
+      return;
+    }
+
     timeoutId = setTimeout(resolve, delayMs);
+
+    signal?.addEventListener(
+      'abort',
+      () => {
+        clearTimeout(timeoutId);
+        reject(signal.reason);
+      },
+      { once: true },
+    );
   });
+
   return {
     promise,
     skip: () => {
@@ -371,7 +395,10 @@ export class GeminiChat {
                 `Rate limit throttling detected (retry ${rateLimitRetryCount}/${maxRateLimitRetries}). ` +
                   `Waiting ${delayMs / 1000}s before retrying...`,
               );
-              const { promise: delayPromise, skip } = skippableDelay(delayMs);
+              const { promise: delayPromise, skip } = delay(
+                delayMs,
+                params.config?.abortSignal,
+              );
               yield {
                 type: StreamEventType.RETRY,
                 retryInfo: {
@@ -417,7 +444,7 @@ export class GeminiChat {
               yield { type: StreamEventType.RETRY };
               // Don't count transient retries against content retry limit.
               attempt--;
-              await new Promise((res) => setTimeout(res, delayMs));
+              await delay(delayMs, params.config?.abortSignal).promise;
               continue;
             }
             // Transient budget exhausted — stop immediately.
@@ -438,13 +465,10 @@ export class GeminiChat {
                     model,
                   ),
                 );
-                await new Promise((res) =>
-                  setTimeout(
-                    res,
-                    INVALID_CONTENT_RETRY_OPTIONS.initialDelayMs *
-                      (attempt + 1),
-                  ),
-                );
+                await delay(
+                  INVALID_CONTENT_RETRY_OPTIONS.initialDelayMs * (attempt + 1),
+                  params.config?.abortSignal,
+                ).promise;
                 continue;
               }
             }