fix(llm): allow cancelling retry waits

Author: MouseWW

RELEASE_NOTES.md

@@ -1,16 +1,16 @@
-# Anything Analyzer v3.6.21
+# Anything Analyzer v3.6.22
 
 ## 修复
 
-- **LLM 分析取消立即生效** — 修复分析任务取消后底层 LLM 请求仍继续执行的问题
-  - 普通补全和工具调用补全现在都会把 `AbortSignal` 传递到底层 `fetch`
-  - 取消请求时统一返回 `LLM 请求已取消`，避免被误判为网络故障
+- **LLM 限流重试可立即取消** — 修复 LLM 返回 429 后等待 `retry-after` 期间取消不生效的问题
+  - 重试等待现在会响应 `AbortSignal`，取消分析时不会继续卡在限流等待中
+  - Responses API 非流式 `status: "failed"` 现在返回明确的 `Responses API failed: ...` 错误
 
 ## 下载
 
 | 平台 | 文件 |
 |------|------|
-| Windows | Anything-Analyzer-Setup-3.6.21.exe |
-| macOS (Apple Silicon) | Anything-Analyzer-3.6.21-arm64.dmg |
-| macOS (Intel) | Anything-Analyzer-3.6.21-x64.dmg |
-| Linux | Anything-Analyzer-3.6.21.AppImage |
+| Windows | Anything-Analyzer-Setup-3.6.22.exe |
+| macOS (Apple Silicon) | Anything-Analyzer-3.6.22-arm64.dmg |
+| macOS (Intel) | Anything-Analyzer-3.6.22-x64.dmg |
+| Linux | Anything-Analyzer-3.6.22.AppImage |

package.json

@@ -1,6 +1,6 @@
 {
   "name": "anything-analyzer",
-  "version": "3.6.21",
+  "version": "3.6.22",
   "description": "Universal web protocol analyzer with embedded browser and AI-powered analysis",
   "packageManager": "pnpm@10.24.0",
   "main": "./out/main/index.js",

src/main/ai/llm-router.ts

@@ -67,20 +67,38 @@ function sanitizeForJson(obj: unknown): unknown {
  * Mask sensitive values in HTTP headers before logging.
  * "Bearer sk-1234567890abcdef" → "Bearer sk-****cdef"
  */
-function maskSensitiveHeaders(headers: Record<string, string>): Record<string, string> {
-  const masked = { ...headers };
-  for (const key of Object.keys(masked)) {
-    const lower = key.toLowerCase();
+function maskSensitiveHeaders(headers: Record<string, string>): Record<string, string> {
+  const masked = { ...headers };
+  for (const key of Object.keys(masked)) {
+    const lower = key.toLowerCase();
     if (lower === 'authorization' || lower === 'x-api-key' || lower === 'api-key') {
       masked[key] = masked[key].replace(/(\w{2,4})\w{4,}(\w{4})/, '$1****$2');
     }
   }
-  return masked;
-}
-
-/**
- * LLMRouter — Unified interface for calling different LLM providers.
- * Supports OpenAI, Anthropic, and OpenAI-compatible APIs.
+  return masked;
+}
+
+function delayWithAbort(ms: number, signal?: AbortSignal): Promise<void> {
+  if (signal?.aborted) return Promise.reject(signal.reason);
+
+  return new Promise((resolve, reject) => {
+    const cleanup = (): void => signal?.removeEventListener("abort", abort);
+    const timeout = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    const abort = (): void => {
+      clearTimeout(timeout);
+      cleanup();
+      reject(signal?.reason);
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+}
+
+/**
+ * LLMRouter — Unified interface for calling different LLM providers.
+ * Supports OpenAI, Anthropic, and OpenAI-compatible APIs.
  */
 export class LLMRouter {
   constructor(
@@ -111,10 +129,15 @@ export class LLMRouter {
       throw new Error(`LLM API 错误: ${err.type ?? 'unknown'} — ${err.message ?? JSON.stringify(err)}`);
     }
 
-    // OpenAI error format: { error: { message, type, code } }
-    if (typeof obj.error === 'object' && obj.error !== null && !obj.type) {
-      const err = obj.error as Record<string, unknown>;
-      throw new Error(`LLM API 错误: ${err.message ?? JSON.stringify(err)}`);
+    // Responses API failed payloads need endpoint-specific handling.
+    if (obj.status === "failed") {
+      return data as T;
+    }
+
+    // OpenAI error format: { error: { message, type, code } }
+    if (typeof obj.error === 'object' && obj.error !== null && !obj.type) {
+      const err = obj.error as Record<string, unknown>;
+      throw new Error(`LLM API 错误: ${err.message ?? JSON.stringify(err)}`);
     }
 
     return data as T;
@@ -573,18 +596,22 @@ export class LLMRouter {
 
     if (stream) return this.parseResponsesStream(response, onChunk!);
 
-    const data = await this.safeParseJson<{
+    const data = await this.safeParseJson<{
       status?: string;
       incomplete_details?: ResponsesIncompleteDetails;
-      output_text?: string;
-      usage?: { input_tokens: number; output_tokens: number };
-    }>(response);
+      error?: { message?: string };
+      output_text?: string;
+      usage?: { input_tokens: number; output_tokens: number };
+    }>(response);
     if (data.status === "incomplete") {
       throw new Error(`Responses API incomplete: ${data.incomplete_details?.reason || "unknown"}`);
     }
-    return {
-      content: data.output_text || "",
-      promptTokens: data.usage?.input_tokens || 0,
+    if (data.status === "failed") {
+      throw new Error(`Responses API failed: ${data.error?.message || "unknown"}`);
+    }
+    return {
+      content: data.output_text || "",
+      promptTokens: data.usage?.input_tokens || 0,
       completionTokens: data.usage?.output_tokens || 0,
     };
   }
@@ -833,12 +860,12 @@ export class LLMRouter {
       });
       clearTimeout(timeout);
 
-      if (response.status === 429 && retries > 0) {
+      if (response.status === 429 && retries > 0) {
         const retryAfter = parseInt(
           response.headers.get("retry-after") || "5",
           10,
         );
-        await new Promise((r) => setTimeout(r, retryAfter * 1000));
+        await delayWithAbort(retryAfter * 1000, signal);
         return this.fetchWithRetry(url, options, retries - 1, isStreaming, signal);
       }
 

tests/main/ai/llm-router.test.ts

@@ -67,11 +67,36 @@ describe("LLMRouter", () => {
     vi.stubGlobal("fetch", fetchSpy);
   });
 
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
   describe("routing", () => {
+    it("should abort while waiting to retry rate-limited requests", async () => {
+      vi.useFakeTimers();
+      const controller = new AbortController();
+      fetchSpy.mockResolvedValueOnce(
+        new Response("rate limited", {
+          status: 429,
+          headers: { "retry-after": "60" },
+        }),
+      );
+
+      const router = new LLMRouter(baseConfig);
+      const request = router.complete(
+        [{ role: "user", content: "test" }],
+        undefined,
+        controller.signal,
+      );
+      await vi.waitFor(() => expect(fetchSpy).toHaveBeenCalledTimes(1));
+
+      controller.abort();
+
+      await expect(request).rejects.toThrow("LLM 请求已取消");
+      expect(fetchSpy).toHaveBeenCalledTimes(1);
+    });
+
     it("should connect abort signal to standard LLM requests", async () => {
       const controller = new AbortController();
       fetchSpy.mockImplementationOnce((_url, options) => {
@@ -317,7 +342,22 @@ describe("LLMRouter", () => {
         router.complete([{ role: "user", content: "test" }]),
       ).rejects.toThrow("Responses API incomplete: max_output_tokens");
     });
-  });
+
+    it("should reject failed Responses API results", async () => {
+      const config: LLMProviderConfig = { ...baseConfig, apiType: "responses" };
+      fetchSpy.mockResolvedValueOnce(
+        createJSONResponse({
+          status: "failed",
+        }),
+      );
+
+      const router = new LLMRouter(config);
+
+      await expect(
+        router.complete([{ role: "user", content: "test" }]),
+      ).rejects.toThrow("Responses API failed: unknown");
+    });
+  });
 
   describe("completeResponses - streaming", () => {
     it("should parse SSE events with event: prefix and call onChunk", async () => {