fix: detect empty Codex responses and auto-retry with account rotation (#18)

* fix: detect empty Codex responses and auto-retry with account rotation

Codex API intermittently returns HTTP 200 with valid SSE events but zero
text deltas. Add EmptyResponseError detection in all three translation
layers (OpenAI, Anthropic, Gemini) and a retry loop in proxy-handler
that switches accounts on empty responses (up to 3 attempts).

- Non-streaming: catch EmptyResponseError → release account → acquire
new account → retry with fresh CodexApi (max 2 retries)
- Streaming: inject "[Error] Codex returned an empty response" text
chunk when response.completed fires with no content
- All retries exhausted → 502 with clear error message

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix: prevent double-release of account in empty-response retry loop

The outer catch block used the original entryId, which was already
released when EmptyResponseError switched to a new account. Introduce
activeEntryId to track the currently-active account across retries.
Also set EmptyResponseError.name for proper serialization.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: icebear0828 <icebear0828@users.noreply.github.com>
Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

CHANGELOG.md

@@ -8,6 +8,7 @@
 
 ### Added
 
+- 空响应检测 + 自动换号重试：Codex API 返回 HTTP 200 但无内容时，非流式自动切换账号重试（最多 3 次），流式注入错误提示文本
 - 自动提取 Chromium 版本：`extract-fingerprint.ts` 从 `package.json` 读取 Electron 版本，通过 `electron-to-chromium` 映射为 Chromium 大版本，`apply-update.ts` 自动更新 `chromium_version` 和 TLS impersonate profile
 - 动态模型列表：后台从 Codex 后端自动获取模型目录，与静态 YAML 合并（`src/models/model-store.ts`、`src/models/model-fetcher.ts`）
 - `/debug/models` 诊断端点，展示模型来源（static/backend）与刷新状态

src/routes/shared/proxy-handler.ts

@@ -12,6 +12,7 @@ import { stream } from "hono/streaming";
 import { randomUUID } from "crypto";
 import { CodexApi, CodexApiError } from "../../proxy/codex-api.js";
 import type { CodexResponsesRequest } from "../../proxy/codex-api.js";
+import { EmptyResponseError } from "../../translation/codex-event-extractor.js";
 import type { AccountPool } from "../../auth/account-pool.js";
 import type { SessionManager } from "../../session/manager.js";
 import type { CookieJar } from "../../proxy/cookie-jar.js";
@@ -72,6 +73,8 @@ export async function handleProxyRequest(
 
   const { entryId, token, accountId } = acquired;
   const codexApi = new CodexApi(token, accountId, cookieJar, entryId);
+  // Tracks which account the outer catch should release (updated by retry loop)
+  let activeEntryId = entryId;
 
   // 2. Session lookup for multi-turn
   const existingSession = sessionManager.findSession(req.sessionMessages);
@@ -145,51 +148,101 @@ export async function handleProxyRequest(
         }
       });
     } else {
-      try {
-        const result = await fmt.collectTranslator(
-          codexApi,
-          rawResponse,
-          req.model,
-        );
-        if (result.responseId) {
-          const taskId = `task-${randomUUID()}`;
-          sessionManager.storeSession(
-            taskId,
-            "turn-1",
-            req.sessionMessages,
+      // Non-streaming: retry loop for empty responses (switch accounts)
+      const MAX_EMPTY_RETRIES = 2;
+      let currentEntryId = entryId;
+      let currentCodexApi = codexApi;
+      let currentRawResponse = rawResponse;
+
+      for (let attempt = 1; ; attempt++) {
+        try {
+          const result = await fmt.collectTranslator(
+            currentCodexApi,
+            currentRawResponse,
+            req.model,
           );
-          sessionManager.updateResponseId(taskId, result.responseId);
+          if (result.responseId) {
+            const taskId = `task-${randomUUID()}`;
+            sessionManager.storeSession(
+              taskId,
+              "turn-1",
+              req.sessionMessages,
+            );
+            sessionManager.updateResponseId(taskId, result.responseId);
+          }
+          accountPool.release(currentEntryId, result.usage);
+          return c.json(result.response);
+        } catch (collectErr) {
+          if (collectErr instanceof EmptyResponseError && attempt <= MAX_EMPTY_RETRIES) {
+            console.warn(
+              `[${fmt.tag}] Account ${currentEntryId} | Empty response (attempt ${attempt}/${MAX_EMPTY_RETRIES + 1}), switching account...`,
+            );
+            accountPool.release(currentEntryId, collectErr.usage);
+
+            // Acquire a new account
+            const newAcquired = accountPool.acquire();
+            if (!newAcquired) {
+              console.warn(`[${fmt.tag}] No available account for retry`);
+              c.status(502);
+              return c.json(fmt.formatError(502, "Codex returned an empty response and no other accounts are available for retry"));
+            }
+
+            currentEntryId = newAcquired.entryId;
+            activeEntryId = currentEntryId;
+            currentCodexApi = new CodexApi(newAcquired.token, newAcquired.accountId, cookieJar, newAcquired.entryId);
+            try {
+              currentRawResponse = await withRetry(
+                () => currentCodexApi.createResponse(req.codexRequest, abortController.signal),
+                { tag: fmt.tag },
+              );
+            } catch (retryErr) {
+              accountPool.release(currentEntryId);
+              if (retryErr instanceof CodexApiError) {
+                const code = (retryErr.status >= 400 && retryErr.status < 600 ? retryErr.status : 502) as StatusCode;
+                c.status(code);
+                return c.json(fmt.formatError(code, retryErr.message));
+              }
+              throw retryErr;
+            }
+            continue;
+          }
+
+          // Not an empty response error, or retries exhausted
+          accountPool.release(currentEntryId);
+          if (collectErr instanceof EmptyResponseError) {
+            console.warn(
+              `[${fmt.tag}] Account ${currentEntryId} | Empty response (attempt ${attempt}/${MAX_EMPTY_RETRIES + 1}), all retries exhausted`,
+            );
+            c.status(502);
+            return c.json(fmt.formatError(502, "Codex returned empty responses across all available accounts"));
+          }
+          const msg = collectErr instanceof Error ? collectErr.message : "Unknown error";
+          c.status(502);
+          return c.json(fmt.formatError(502, msg));
         }
-        accountPool.release(entryId, result.usage);
-        return c.json(result.response);
-      } catch (collectErr) {
-        accountPool.release(entryId);
-        const msg = collectErr instanceof Error ? collectErr.message : "Unknown error";
-        c.status(502);
-        return c.json(fmt.formatError(502, msg));
       }
     }
   } catch (err) {
     // 5. Error handling with format-specific responses
     if (err instanceof CodexApiError) {
       console.error(
-        `[${fmt.tag}] Account ${entryId} | Codex API error:`,
+        `[${fmt.tag}] Account ${activeEntryId} | Codex API error:`,
         err.message,
       );
       if (err.status === 429) {
         // P1-6: Count 429s as requests via encapsulated API (no direct entry mutation)
-        accountPool.markRateLimited(entryId, { countRequest: true });
+        accountPool.markRateLimited(activeEntryId, { countRequest: true });
         c.status(429);
         return c.json(fmt.format429(err.message));
       }
-      accountPool.release(entryId);
+      accountPool.release(activeEntryId);
       const code = (
         err.status >= 400 && err.status < 600 ? err.status : 502
       ) as StatusCode;
       c.status(code);
       return c.json(fmt.formatError(code, err.message));
     }
-    accountPool.release(entryId);
+    accountPool.release(activeEntryId);
     throw err;
   }
 }

src/translation/codex-event-extractor.ts

@@ -33,6 +33,16 @@ export interface FunctionCallDone {
   arguments: string;
 }
 
+export class EmptyResponseError extends Error {
+  constructor(
+    public readonly responseId: string | null,
+    public readonly usage: UsageInfo | undefined,
+  ) {
+    super("Codex returned an empty response");
+    this.name = "EmptyResponseError";
+  }
+}
+
 export interface ExtractedEvent {
   typed: TypedCodexEvent;
   responseId?: string;

src/translation/codex-to-anthropic.ts

@@ -16,7 +16,7 @@ import type {
   AnthropicMessagesResponse,
   AnthropicUsage,
 } from "../types/anthropic.js";
-import { iterateCodexEvents } from "./codex-event-extractor.js";
+import { iterateCodexEvents, EmptyResponseError } from "./codex-event-extractor.js";
 
 export interface AnthropicUsageInfo {
   input_tokens: number;
@@ -43,6 +43,7 @@ export async function* streamCodexToAnthropic(
   let outputTokens = 0;
   let inputTokens = 0;
   let hasToolCalls = false;
+  let hasContent = false;
   let contentIndex = 0;
   let textBlockStarted = false;
   const callIdsWithDeltas = new Set<string>();
@@ -100,6 +101,7 @@ export async function* streamCodexToAnthropic(
     // Handle function call start → close text block, open tool_use block
     if (evt.functionCallStart) {
       hasToolCalls = true;
+      hasContent = true;
 
       // Close text block if still open
       if (textBlockStarted) {
@@ -156,6 +158,7 @@ export async function* streamCodexToAnthropic(
     switch (evt.typed.type) {
       case "response.output_text.delta": {
         if (evt.textDelta) {
+          hasContent = true;
           // Reopen a text block if the previous one was closed (e.g. after tool calls)
           if (!textBlockStarted) {
             yield formatSSE("content_block_start", {
@@ -180,6 +183,14 @@ export async function* streamCodexToAnthropic(
           outputTokens = evt.usage.output_tokens;
           onUsage?.({ input_tokens: inputTokens, output_tokens: outputTokens });
         }
+        // Inject error text if stream completed with no content
+        if (!hasContent && textBlockStarted) {
+          yield formatSSE("content_block_delta", {
+            type: "content_block_delta",
+            index: contentIndex,
+            delta: { type: "text_delta", text: "[Error] Codex returned an empty response. Please retry." },
+          });
+        }
         break;
       }
     }
@@ -252,6 +263,11 @@ export async function collectCodexToAnthropicResponse(
     }
   }
 
+  // Detect empty response (HTTP 200 but no content)
+  if (!fullText && toolUseBlocks.length === 0 && outputTokens === 0) {
+    throw new EmptyResponseError(responseId, { input_tokens: inputTokens, output_tokens: outputTokens });
+  }
+
   const hasToolCalls = toolUseBlocks.length > 0;
   const content: AnthropicContentBlock[] = [];
   if (fullText) {

src/translation/codex-to-gemini.ts

@@ -15,7 +15,7 @@ import type {
   GeminiUsageMetadata,
   GeminiPart,
 } from "../types/gemini.js";
-import { iterateCodexEvents } from "./codex-event-extractor.js";
+import { iterateCodexEvents, EmptyResponseError } from "./codex-event-extractor.js";
 
 export interface GeminiUsageInfo {
   input_tokens: number;
@@ -35,6 +35,7 @@ export async function* streamCodexToGemini(
 ): AsyncGenerator<string> {
   let inputTokens = 0;
   let outputTokens = 0;
+  let hasContent = false;
 
   for await (const evt of iterateCodexEvents(codexApi, rawResponse)) {
     if (evt.responseId) onResponseId?.(evt.responseId);
@@ -60,6 +61,7 @@ export async function* streamCodexToGemini(
 
     // Function call done → emit as a candidate with functionCall part
     if (evt.functionCallDone) {
+      hasContent = true;
       let args: Record<string, unknown> = {};
       try {
         args = JSON.parse(evt.functionCallDone.arguments) as Record<string, unknown>;
@@ -88,6 +90,7 @@ export async function* streamCodexToGemini(
     switch (evt.typed.type) {
       case "response.output_text.delta": {
         if (evt.textDelta) {
+          hasContent = true;
           const chunk: GeminiGenerateContentResponse = {
             candidates: [
               {
@@ -112,6 +115,23 @@ export async function* streamCodexToGemini(
           onUsage?.({ input_tokens: inputTokens, output_tokens: outputTokens });
         }
 
+        // Inject error text if stream completed with no content
+        if (!hasContent) {
+          const emptyErrChunk: GeminiGenerateContentResponse = {
+            candidates: [
+              {
+                content: {
+                  parts: [{ text: "[Error] Codex returned an empty response. Please retry." }],
+                  role: "model",
+                },
+                index: 0,
+              },
+            ],
+            modelVersion: model,
+          };
+          yield `data: ${JSON.stringify(emptyErrChunk)}\n\n`;
+        }
+
         // Final chunk with finishReason and usage
         const finalChunk: GeminiGenerateContentResponse = {
           candidates: [
@@ -189,6 +209,11 @@ export async function collectCodexToGeminiResponse(
     totalTokenCount: inputTokens + outputTokens,
   };
 
+  // Detect empty response (HTTP 200 but no content)
+  if (!fullText && functionCallParts.length === 0 && outputTokens === 0) {
+    throw new EmptyResponseError(responseId, { input_tokens: inputTokens, output_tokens: outputTokens });
+  }
+
   // Build response parts: text + function calls
   const parts: GeminiPart[] = [];
   if (fullText) {

src/translation/codex-to-openai.ts

@@ -18,7 +18,7 @@ import type {
   ChatCompletionToolCall,
   ChatCompletionChunkToolCall,
 } from "../types/openai.js";
-import { iterateCodexEvents, type UsageInfo } from "./codex-event-extractor.js";
+import { iterateCodexEvents, EmptyResponseError, type UsageInfo } from "./codex-event-extractor.js";
 
 export type { UsageInfo };
 
@@ -42,6 +42,7 @@ export async function* streamCodexToOpenAI(
   const chunkId = `chatcmpl-${randomUUID().replace(/-/g, "").slice(0, 24)}`;
   const created = Math.floor(Date.now() / 1000);
   let hasToolCalls = false;
+  let hasContent = false;
   // Track tool call indices by call_id
   const toolCallIndexMap = new Map<string, number>();
   let nextToolCallIndex = 0;
@@ -101,6 +102,7 @@ export async function* streamCodexToOpenAI(
     // Handle function call events
     if (evt.functionCallStart) {
       hasToolCalls = true;
+      hasContent = true;
       const idx = nextToolCallIndex++;
       toolCallIndexMap.set(evt.functionCallStart.callId, idx);
       const toolCall: ChatCompletionChunkToolCall = {
@@ -183,6 +185,7 @@ export async function* streamCodexToOpenAI(
     switch (evt.typed.type) {
       case "response.output_text.delta": {
         if (evt.textDelta) {
+          hasContent = true;
           yield formatSSE({
             id: chunkId,
             object: "chat.completion.chunk",
@@ -202,6 +205,22 @@ export async function* streamCodexToOpenAI(
 
       case "response.completed": {
         if (evt.usage) onUsage?.(evt.usage);
+        // Inject error text if stream completed with no content
+        if (!hasContent) {
+          yield formatSSE({
+            id: chunkId,
+            object: "chat.completion.chunk",
+            created,
+            model,
+            choices: [
+              {
+                index: 0,
+                delta: { content: "[Error] Codex returned an empty response. Please retry." },
+                finish_reason: null,
+              },
+            ],
+          });
+        }
         yield formatSSE({
           id: chunkId,
           object: "chat.completion.chunk",
@@ -265,6 +284,11 @@ export async function collectCodexResponse(
     }
   }
 
+  // Detect empty response (HTTP 200 but no content)
+  if (!fullText && toolCalls.length === 0 && completionTokens === 0) {
+    throw new EmptyResponseError(responseId, { input_tokens: promptTokens, output_tokens: completionTokens });
+  }
+
   const hasToolCalls = toolCalls.length > 0;
   const message: ChatCompletionResponse["choices"][0]["message"] = {
     role: "assistant",