Skip to content

Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors

fix(api): guard rotating providers in manual token-refresh route (Codex family-revocation)

diegosouzapwac5ac0c2a794
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ac6e0c6200..44e2f31617 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -63,6 +63,15 @@
### Fixed
+- **codex/providers:** `POST /api/providers/[id]/refresh` (the manual/auto "refresh
+ token" endpoint) no longer rotates rotating-refresh providers (Codex/OpenAI share
+ one Auth0 `client_id`). This was the last unguarded proactive-refresh entry point:
+ when the dashboard auto-refreshed every expiring connection on a page load (or an
+ old cached frontend bulk-called it), each Codex account's single-use refresh_token
+ was rotated, and Auth0 revoked the whole token family (`openai/codex#9648`) — every
+ account but the last died with `[403] <!DOCTYPE`. The endpoint now skips proactive
+ rotation for rotating providers and defers to the reactive, serialized 401 path
+ (same guard as `refreshAndUpdateCredentials` and the connection-test route).
- **codex/quota:** opening the Quota / Providers dashboard no longer disconnects
Codex multi-account setups. The quota-sync path
(`refreshAndUpdateCredentials`) proactively refreshed every connection — for
diff --git a/src/app/api/providers/[id]/refresh/route.ts b/src/app/api/providers/[id]/refresh/route.ts
index bbe3bd6cef..1e40bccf63 100644
--- a/src/app/api/providers/[id]/refresh/route.ts
+++ b/src/app/api/providers/[id]/refresh/route.ts
@@ -1,6 +1,7 @@
import { NextResponse } from "next/server";
import { getProviderConnectionById, updateProviderConnection } from "@/lib/db/providers";
import { getAccessToken, updateProviderCredentials } from "@/sse/services/tokenRefresh";
+import { rotationGroupFor } from "@omniroute/open-sse/services/refreshSerializer.ts";
type RefreshResult = {
accessToken?: string;
@@ -44,6 +45,33 @@ export async function POST(_request: Request, { params }: { params: Promise<{ id
}
const provider = connection.provider;
+
+ // Codex multi-account family-revocation cascade guard.
+ // Rotating-refresh providers (Codex/OpenAI share one Auth0 client_id, etc.)
+ // mint a single-use refresh_token on every refresh. This endpoint is invoked
+ // per-connection by the dashboard (incl. an OLD cached frontend that bulk-
+ // refreshes every expiring connection on a page load); rotating several
+ // sibling accounts makes Auth0 revoke the whole token family
+ // (openai/codex#9648), killing every account but the last. Never proactively
+ // rotate a rotating provider here — the access_token is reused as-is and
+ // genuine expiry is handled by the reactive, serialized 401 path on the next
+ // real request. This was the last unguarded proactive-refresh entry point
+ // (refreshAndUpdateCredentials and the connection-test route are already
+ // guarded). Non-rotating providers keep refreshing on demand below.
+ if (rotationGroupFor(provider) !== null) {
+ return NextResponse.json({
+ success: true,
+ skipped: true,
+ connectionId: id,
+ provider,
+ message:
+ "Rotating-refresh provider: the token refreshes automatically on the next request. " +
+ "Manual/bulk refresh is intentionally skipped to avoid Auth0 token-family revocation.",
+ expiresAt: connection.tokenExpiresAt || connection.expiresAt || null,
+ refreshedAt: new Date().toISOString(),
+ });
+ }
+
const credentials = {
connectionId: id,
accessToken: connection.accessToken,
diff --git a/tests/unit/codex-manual-refresh-rotating-guard.test.ts b/tests/unit/codex-manual-refresh-rotating-guard.test.ts
new file mode 100644
index 0000000000..8ba3cc8ef3
--- /dev/null
+++ b/tests/unit/codex-manual-refresh-rotating-guard.test.ts
@@ -0,0 +1,59 @@
+/**
+ * Codex multi-account family-revocation cascade — manual/auto token refresh guard.
+ *
+ * `POST /api/providers/[id]/refresh` is the explicit "refresh this token" endpoint.
+ * It rotates the refresh_token via getAccessToken. For rotating-refresh providers
+ * (Codex/OpenAI share one Auth0 client_id) rotating several sibling accounts —
+ * which happens when the dashboard auto-refreshes every expiring connection on a
+ * page load, or when an OLD cached frontend bulk-calls this endpoint — makes Auth0
+ * revoke the whole token family (openai/codex#9648) and kills every account but
+ * the last. This was the LAST unguarded proactive-refresh entry point for rotating
+ * providers (refreshAndUpdateCredentials and the connection-test route are already
+ * guarded). It must skip the proactive refresh and defer to the reactive,
+ * serialized 401 path. Non-rotating providers keep refreshing on demand.
+ *
+ * Mirrors the source-assertion style of token-refresh-race-comprehensive.test.ts.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+
+const root = path.resolve(import.meta.dirname, "../..");
+const ROUTE = path.join(root, "src/app/api/providers/[id]/refresh/route.ts");
+const read = () => readFile(ROUTE, "utf8");
+
+test("manual refresh route imports rotationGroupFor", async () => {
+ const src = await read();
+ assert.match(
+ src,
+ /import\s*\{[^}]*rotationGroupFor[^}]*\}\s*from\s*["'][^"']*refreshSerializer/,
+ "refresh route must import rotationGroupFor to detect rotating providers"
+ );
+});
+
+test("manual refresh route skips proactive refresh for rotating providers BEFORE calling getAccessToken", async () => {
+ const src = await read();
+
+ const guardIdx = src.search(/rotationGroupFor\s*\(\s*[\w.]*provider[\w.]*\s*\)\s*!==\s*null/);
+ assert.ok(
+ guardIdx >= 0,
+ "refresh route must guard with `rotationGroupFor(provider) !== null` to skip rotating providers"
+ );
+
+ const getAccessTokenIdx = src.indexOf("getAccessToken(");
+ assert.ok(getAccessTokenIdx >= 0, "refresh route still calls getAccessToken for non-rotating providers");
+
+ assert.ok(
+ guardIdx < getAccessTokenIdx,
+ "the rotating-provider guard must run BEFORE getAccessToken so the rotating refresh_token is never exercised"
+ );
+
+ // The guard short-circuits with an early return (no token rotation).
+ const guardBlock = src.slice(guardIdx, getAccessTokenIdx);
+ assert.match(
+ guardBlock,
+ /return\b/,
+ "the rotating-provider guard must return early (defer to the reactive 401 path) instead of refreshing"
+ );
+});