fix(codex): tighten quota rejection classification

Author: luvs01

src/codex/quota-rejection.ts

@@ -45,24 +45,42 @@ function rejection(
   };
 }
 
+function hasOwnField(container: Record<string, unknown>, field: string): boolean {
+  return Object.prototype.hasOwnProperty.call(container, field);
+}
+
+function exactResetEligibleCode(
+  container: Record<string, unknown>,
+): CodexResetEligibleExhaustionCode | undefined {
+  const hasCode = hasOwnField(container, "code");
+  const hasType = hasOwnField(container, "type");
+  if (!hasCode && !hasType) return undefined;
+
+  const code = hasCode ? container.code : undefined;
+  const type = hasType ? container.type : undefined;
+  if ((hasCode && typeof code !== "string") || (hasType && typeof type !== "string")) {
+    return undefined;
+  }
+  if (hasCode && hasType && code !== type) return undefined;
+
+  const value = hasCode ? code : type;
+  if (typeof value !== "string") return undefined;
+  return RESET_ELIGIBLE_CODES.has(value as CodexResetEligibleExhaustionCode)
+    ? value as CodexResetEligibleExhaustionCode
+    : undefined;
+}
+
 function structuredResetEligibleCode(payload: unknown): CodexResetEligibleExhaustionCode | undefined {
   if (!payload || typeof payload !== "object" || Array.isArray(payload)) return undefined;
   const root = payload as Record<string, unknown>;
-  const containers: Record<string, unknown>[] = [root];
-  if (root.error && typeof root.error === "object" && !Array.isArray(root.error)) {
-    containers.push(root.error as Record<string, unknown>);
-  }
-  for (const container of containers) {
-    for (const field of ["code", "type"] as const) {
-      const value = container[field];
-      if (typeof value !== "string") continue;
-      const normalized = value.trim().toLowerCase();
-      if (RESET_ELIGIBLE_CODES.has(normalized as CodexResetEligibleExhaustionCode)) {
-        return normalized as CodexResetEligibleExhaustionCode;
-      }
-    }
-  }
-  return undefined;
+  const hasRootDiscriminator = hasOwnField(root, "code") || hasOwnField(root, "type");
+
+  if (!hasOwnField(root, "error")) return exactResetEligibleCode(root);
+  if (hasRootDiscriminator) return undefined;
+
+  const nested = root.error;
+  if (!nested || typeof nested !== "object" || Array.isArray(nested)) return undefined;
+  return exactResetEligibleCode(nested as Record<string, unknown>);
 }
 
 async function resetEligibleCodeFromResponse(

tests/codex-quota-rejection.test.ts

@@ -5,13 +5,27 @@ function jsonRejection(status: number, error: Record<string, unknown>): Response
   return Response.json({ error }, { status });
 }
 
+function jsonPayload(status: number, payload: Record<string, unknown>): Response {
+  return Response.json(payload, { status });
+}
+
 describe("Codex pre-stream quota rejection classification", () => {
   test.each([
-    [429, "code", "usage_limit_exceeded"],
-    [429, "type", "insufficient_quota"],
-    [402, "code", "insufficient_quota"],
-  ] as const)("accepts structured reset-eligible exhaustion on HTTP %i", async (status, field, code) => {
-    const result = await classifyCodexPreStreamRejection(jsonRejection(status, { [field]: code }));
+    [429, "nested code", { error: { code: "usage_limit_exceeded" } }, "usage_limit_exceeded"],
+    [429, "nested type", { error: { type: "insufficient_quota" } }, "insufficient_quota"],
+    [402, "nested code", { error: { code: "insufficient_quota" } }, "insufficient_quota"],
+    [429, "root code", { code: "usage_limit_exceeded" }, "usage_limit_exceeded"],
+    [402, "root type", { type: "insufficient_quota" }, "insufficient_quota"],
+    [429, "matching code and type", {
+      error: { code: "usage_limit_exceeded", type: "usage_limit_exceeded" },
+    }, "usage_limit_exceeded"],
+  ] as const)("accepts exact %s reset-eligible exhaustion on HTTP %i", async (
+    status,
+    _schema,
+    payload,
+    code,
+  ) => {
+    const result = await classifyCodexPreStreamRejection(jsonPayload(status, payload));
     expect(result).toEqual({
       kind: "reset-eligible-exhaustion",
       status,
@@ -21,6 +35,72 @@ describe("Codex pre-stream quota rejection classification", () => {
     });
   });
 
+  test.each([
+    ["leading and trailing whitespace", { error: { code: " usage_limit_exceeded " } }],
+    ["uppercase", { error: { code: "USAGE_LIMIT_EXCEEDED" } }],
+    ["mixed case", { type: "Insufficient_Quota" }],
+    ["trailing whitespace at the root", { code: "insufficient_quota " }],
+  ] as const)("rejects the %s near-miss", async (_case, payload) => {
+    const result = await classifyCodexPreStreamRejection(jsonPayload(429, payload));
+    expect(result).toMatchObject({
+      kind: "generic-rate-limit",
+      alternateRetryEligible: true,
+      resetCreditEligible: false,
+    });
+    expect(result).not.toHaveProperty("semanticCode");
+  });
+
+  test.each([
+    ["primitive error with a root code", {
+      error: "opaque",
+      code: "usage_limit_exceeded",
+    }],
+    ["matching root and nested codes", {
+      code: "usage_limit_exceeded",
+      error: { code: "usage_limit_exceeded" },
+    }],
+    ["unknown root and eligible nested codes", {
+      code: "unknown",
+      error: { code: "usage_limit_exceeded" },
+    }],
+    ["eligible root code with an empty nested error", {
+      code: "usage_limit_exceeded",
+      error: {},
+    }],
+  ] as const)("fails closed for ambiguous schemas: %s", async (_case, payload) => {
+    const result = await classifyCodexPreStreamRejection(jsonPayload(429, payload));
+    expect(result).toMatchObject({
+      kind: "generic-rate-limit",
+      alternateRetryEligible: true,
+      resetCreditEligible: false,
+    });
+    expect(result).not.toHaveProperty("semanticCode");
+  });
+
+  test.each([
+    ["nested unknown code and eligible type", {
+      error: { code: "unknown", type: "insufficient_quota" },
+    }],
+    ["root eligible code and unrelated type", {
+      code: "usage_limit_exceeded",
+      type: "rate_limit_error",
+    }],
+    ["two different eligible values", {
+      error: { code: "usage_limit_exceeded", type: "insufficient_quota" },
+    }],
+    ["eligible code and non-string type", {
+      error: { code: "usage_limit_exceeded", type: null },
+    }],
+  ] as const)("fails closed for code/type disagreement: %s", async (_case, payload) => {
+    const result = await classifyCodexPreStreamRejection(jsonPayload(429, payload));
+    expect(result).toMatchObject({
+      kind: "generic-rate-limit",
+      alternateRetryEligible: true,
+      resetCreditEligible: false,
+    });
+    expect(result).not.toHaveProperty("semanticCode");
+  });
+
   test("keeps a generic 429 with Retry-After out of reset-credit eligibility", async () => {
     const response = jsonRejection(429, {
       type: "rate_limit_error",