fix: 覆盖 Codex retry 503 分类

src/selftest/cases/30-codex-stdio.ts

@@ -36,17 +36,18 @@ const selfTest: SelfTestCase = async (context) => {
     await runFailureCase({ client, managerUrl: server.baseUrl, context, mode: "missing-turn-result", expectedStatus: "failed", expectedFailureKind: "backend-response-invalid" });
     await runFailureCase({ client, managerUrl: server.baseUrl, context, mode: "provider-503-rpc-error", expectedStatus: "failed", expectedFailureKind: "provider-unavailable" });
     await runFailureCase({ client, managerUrl: server.baseUrl, context, mode: "provider-503-terminal", expectedStatus: "failed", expectedFailureKind: "provider-unavailable" });
+    await runFailureCase({ client, managerUrl: server.baseUrl, context, mode: "provider-503-retry-event", expectedStatus: "failed", expectedFailureKind: "provider-unavailable", expectRetryError: true });
     await runFailureCase({ client, managerUrl: server.baseUrl, context, mode: "invalid-json", expectedStatus: "failed", expectedFailureKind: "backend-json-parse-error" });
     await runFailureCase({ client, managerUrl: server.baseUrl, context, mode: "missing-terminal", expectedStatus: "failed", expectedFailureKind: "backend-timeout", timeoutMs: 500 });
     await runSpawnFailureCase({ client, managerUrl: server.baseUrl, context });
 
-    return { name: "codex-stdio", tests: ["runner-lease-heartbeat", "codex-stdio-fake-turn", "codex-stdio-projected-writable-home", "codex-stdio-missing-turn-result", "codex-stdio-provider-503-rpc-error", "codex-stdio-provider-503-terminal", "codex-stdio-invalid-json", "codex-stdio-timeout", "codex-stdio-spawn-failure"] };
+    return { name: "codex-stdio", tests: ["runner-lease-heartbeat", "codex-stdio-fake-turn", "codex-stdio-projected-writable-home", "codex-stdio-missing-turn-result", "codex-stdio-provider-503-rpc-error", "codex-stdio-provider-503-terminal", "codex-stdio-provider-503-retry-event", "codex-stdio-invalid-json", "codex-stdio-timeout", "codex-stdio-spawn-failure"] };
   } finally {
     await new Promise<void>((resolve) => server.server.close(() => resolve()));
   }
 };
 
-async function runFailureCase(options: { client: ManagerClient; managerUrl: string; context: SelfTestContext; mode: string; expectedStatus: TerminalStatus; expectedFailureKind: FailureKind; timeoutMs?: number }): Promise<void> {
+async function runFailureCase(options: { client: ManagerClient; managerUrl: string; context: SelfTestContext; mode: string; expectedStatus: TerminalStatus; expectedFailureKind: FailureKind; timeoutMs?: number; expectRetryError?: boolean }): Promise<void> {
   const item = await createRunWithCommand(options.client, options.context, `failure ${options.mode}`, `selftest-${options.mode}`, options.timeoutMs ?? 3_000);
   const result = await runOnce({
     managerUrl: options.managerUrl,
@@ -60,11 +61,22 @@ async function runFailureCase(options: { client: ManagerClient; managerUrl: stri
   assert.equal(result.failureKind, options.expectedFailureKind, options.mode);
   const events = await options.client.get(`/api/v1/runs/${item.runId}/events?afterSeq=0&limit=100`) as { items?: Array<{ type: string; payload: unknown }> };
   assert.ok(events.items?.some((event) => event.type === "error"), options.mode);
+  assert.ok(events.items?.some((event) => event.type === "error" && eventPayload(event).failureKind === options.expectedFailureKind), `${options.mode} expected error event failureKind ${options.expectedFailureKind}`);
+  if (options.expectRetryError) {
+    assert.ok(events.items?.some((event) => {
+      const payload = eventPayload(event);
+      return event.type === "error" && payload.willRetry === true && payload.failureKind === options.expectedFailureKind;
+    }), `${options.mode} expected retry error event failureKind ${options.expectedFailureKind}`);
+  }
   const command = await options.client.get(`/api/v1/runs/${item.runId}/commands/${item.commandId}`) as { state?: string };
   assert.equal(command.state, "failed", options.mode);
   assertNoSecretLeak(events);
 }
 
+function eventPayload(event: { payload: unknown }): JsonRecord {
+  return typeof event.payload === "object" && event.payload !== null && !Array.isArray(event.payload) ? event.payload as JsonRecord : {};
+}
+
 async function runSpawnFailureCase(options: { client: ManagerClient; managerUrl: string; context: SelfTestContext }): Promise<void> {
   const item = await createRunWithCommand(options.client, options.context, "failure spawn", "selftest-spawn-failure", 3_000);
   const result = await runOnce({

src/selftest/fake-codex-app-server.ts

@@ -54,6 +54,29 @@ for await (const line of rl) {
       respond(message.id, { turn });
       continue;
     }
+    if (mode === "provider-503-retry-event") {
+      turnCounter += 1;
+      const turn = {
+        id: `turn_selftest_${turnCounter}`,
+        status: "failed",
+        error: {
+          message: "unexpected status 503 Service Unavailable: Service temporarily unavailable",
+          codexErrorInfo: { responseStreamDisconnected: { httpStatusCode: 503 } },
+        },
+      };
+      notify("turn/started", { turn: { id: turn.id, status: "running" } });
+      notify("error", {
+        willRetry: true,
+        error: {
+          message: "Reconnecting... 1/5",
+          codexErrorInfo: { responseStreamDisconnected: { httpStatusCode: 503 } },
+          additionalDetails: "unexpected status 503 Service Unavailable: Service temporarily unavailable, url: https://hyueapi.com/responses",
+        },
+      });
+      notify("turn/completed", { turn });
+      respond(message.id, { turn });
+      continue;
+    }
     turnCounter += 1;
     const turn = { id: `turn_selftest_${turnCounter}`, status: "completed" };
     notify("turn/started", { turn });