codex-multi-auth 0.1.2 → 0.1.4

package/README.md

@@ -129,11 +129,6 @@ codex auth doctor --fix
 | `codex auth fix --live --model gpt-5-codex` | Run repairs with live probe model |
 | `codex auth doctor --fix` | Diagnose and apply safe fixes |
 
-Compatibility aliases are also supported:
-- `codex multi auth ...`
-- `codex multi-auth ...`
-- `codex multiauth ...`
-
 ---
 
 ## Dashboard Hotkeys
@@ -226,7 +221,7 @@ codex auth login
 <details>
 <summary><b>Common symptoms</b></summary>
 
-- `codex auth` unrecognized: run `where codex`, then try `codex multi auth status`
+- `codex auth` unrecognized: run `where codex`, then follow `docs/troubleshooting.md` for routing fallback commands
 - Switch succeeds but wrong account appears active: run `codex auth switch <index>`, then restart session
 - OAuth callback on port `1455` fails: free the port and re-run `codex auth login`
 - `missing field id_token` / `token_expired` / `refresh_token_reused`: re-login affected account
@@ -259,6 +254,8 @@ codex auth doctor --json
 - Configuration: [docs/configuration.md](docs/configuration.md)
 - Troubleshooting: [docs/troubleshooting.md](docs/troubleshooting.md)
 - Commands reference: [docs/reference/commands.md](docs/reference/commands.md)
+- Public API contract: [docs/reference/public-api.md](docs/reference/public-api.md)
+- Error contracts: [docs/reference/error-contracts.md](docs/reference/error-contracts.md)
 - Settings reference: [docs/reference/settings.md](docs/reference/settings.md)
 - Storage paths: [docs/reference/storage-paths.md](docs/reference/storage-paths.md)
 - Upgrade guide: [docs/upgrade.md](docs/upgrade.md)
@@ -268,9 +265,9 @@ codex auth doctor --json
 
 ## Release Notes
 
-- Current stable: [docs/releases/v0.1.2.md](docs/releases/v0.1.2.md)
-- Previous stable: [docs/releases/v0.1.1.md](docs/releases/v0.1.1.md)
-- Earlier stable: [docs/releases/v0.1.0.md](docs/releases/v0.1.0.md)
+- Current stable: [docs/releases/v0.1.4.md](docs/releases/v0.1.4.md)
+- Previous stable: [docs/releases/v0.1.3.md](docs/releases/v0.1.3.md)
+- Earlier stable: [docs/releases/v0.1.2.md](docs/releases/v0.1.2.md)
 - Archived prerelease: [docs/releases/v0.1.0-beta.0.md](docs/releases/v0.1.0-beta.0.md)
 
 ## License

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,kBAAkB,CAAC;AAmL5D;;;;;;;;;;;;;;;GAeG;AAEH,eAAO,MAAM,iBAAiB,EAAE,MAwzH/B,CAAC;AAEF,eAAO,MAAM,gBAAgB,KAAoB,CAAC;AAElD,eAAe,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,kBAAkB,CAAC;AAmL5D;;;;;;;;;;;;;;;GAeG;AAEH,eAAO,MAAM,iBAAiB,EAAE,MAg2H/B,CAAC;AAEF,eAAO,MAAM,gBAAgB,KAAoB,CAAC;AAElD,eAAe,iBAAiB,CAAC"}

package/dist/index.js

@@ -117,6 +117,38 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
         const parsed = Number.parseInt(value, 10);
         return Number.isFinite(parsed) ? parsed : undefined;
     };
+    const MAX_RETRY_HINT_MS = 5 * 60 * 1000;
+    const clampRetryHintMs = (value) => {
+        if (!Number.isFinite(value))
+            return null;
+        const normalized = Math.floor(value);
+        if (normalized <= 0)
+            return null;
+        return Math.min(normalized, MAX_RETRY_HINT_MS);
+    };
+    const parseRetryAfterHintMs = (headers) => {
+        const retryAfterMsHeader = headers.get("retry-after-ms")?.trim();
+        if (retryAfterMsHeader && /^\d+$/.test(retryAfterMsHeader)) {
+            return clampRetryHintMs(Number.parseInt(retryAfterMsHeader, 10));
+        }
+        const retryAfterHeader = headers.get("retry-after")?.trim();
+        if (retryAfterHeader && /^\d+$/.test(retryAfterHeader)) {
+            return clampRetryHintMs(Number.parseInt(retryAfterHeader, 10) * 1000);
+        }
+        if (retryAfterHeader) {
+            const retryAtMs = Date.parse(retryAfterHeader);
+            if (Number.isFinite(retryAtMs)) {
+                return clampRetryHintMs(retryAtMs - Date.now());
+            }
+        }
+        const resetAtHeader = headers.get("x-ratelimit-reset")?.trim();
+        if (resetAtHeader && /^\d+$/.test(resetAtHeader)) {
+            const resetRaw = Number.parseInt(resetAtHeader, 10);
+            const resetAtMs = resetRaw < 10_000_000_000 ? resetRaw * 1000 : resetRaw;
+            return clampRetryHintMs(resetAtMs - Date.now());
+        }
+        return null;
+    };
     const sanitizeResponseHeadersForLog = (headers) => {
         const allowed = new Set([
             "content-type",
@@ -1131,7 +1163,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                             runtimeMetrics.lastError =
                                                 `Local token bucket depleted for account ${account.index + 1} (${modelFamily}${model ? `:${model}` : ""})`;
                                             logWarn(`Skipping account ${account.index + 1}: local token bucket depleted for ${modelFamily}${model ? `:${model}` : ""}`);
-                                            break;
+                                            continue;
                                         }
                                         let sameAccountRetryCount = 0;
                                         let successAccountForResponse = account;
@@ -1141,7 +1173,12 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                             // Merge user AbortSignal with timeout (Node 18 compatible - no AbortSignal.any)
                                             const fetchController = new AbortController();
                                             const requestTimeoutMs = fetchTimeoutMs;
-                                            const fetchTimeoutId = setTimeout(() => fetchController.abort(new Error("Request timeout")), requestTimeoutMs);
+                                            let requestTimedOut = false;
+                                            const timeoutReason = new Error("Request timeout");
+                                            const fetchTimeoutId = setTimeout(() => {
+                                                requestTimedOut = true;
+                                                fetchController.abort(timeoutReason);
+                                            }, requestTimeoutMs);
                                             const onUserAbort = abortSignal
                                                 ? () => fetchController.abort(abortSignal.reason ?? new Error("Aborted by user"))
                                                 : null;
@@ -1161,14 +1198,19 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                                 });
                                             }
                                             catch (networkError) {
-                                                const isUserAbort = abortSignal?.aborted ||
-                                                    (networkError instanceof Error &&
-                                                        (networkError.name === "AbortError" || /abort/i.test(networkError.message)));
+                                                const fetchAbortReason = fetchController.signal.reason;
+                                                const isTimeoutAbort = requestTimedOut ||
+                                                    (fetchAbortReason instanceof Error &&
+                                                        fetchAbortReason.message === timeoutReason.message);
+                                                const isUserAbort = Boolean(abortSignal?.aborted) && !isTimeoutAbort;
                                                 if (isUserAbort) {
+                                                    accountManager.refundToken(account, modelFamily, model);
                                                     runtimeMetrics.userAborts++;
                                                     runtimeMetrics.lastError = "request aborted by user";
                                                     sessionAffinityStore?.forgetSession(sessionAffinityKey);
-                                                    break;
+                                                    throw (fetchAbortReason instanceof Error
+                                                        ? fetchAbortReason
+                                                        : new Error("Aborted by user"));
                                                 }
                                                 const errorMsg = networkError instanceof Error ? networkError.message : String(networkError);
                                                 logWarn(`Network error for account ${account.index + 1}: ${errorMsg}`);
@@ -1347,7 +1389,8 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                                     runtimeMetrics.serverErrors++;
                                                     runtimeMetrics.accountRotations++;
                                                     runtimeMetrics.lastError = `HTTP ${response.status}`;
-                                                    const policy = evaluateFailurePolicy({ kind: "server", failoverMode }, { serverCooldownMs: serverErrorCooldownMs });
+                                                    const serverRetryAfterMs = parseRetryAfterHintMs(response.headers);
+                                                    const policy = evaluateFailurePolicy({ kind: "server", failoverMode, serverRetryAfterMs: serverRetryAfterMs ?? undefined }, { serverCooldownMs: serverErrorCooldownMs });
                                                     if (policy.refundToken) {
                                                         accountManager.refundToken(account, modelFamily, model);
                                                     }
@@ -1491,12 +1534,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                                                     // Best effort cleanup before trying next fallback account.
                                                                 }
                                                                 if (fallbackResponse.status === 429) {
-                                                                    const retryAfterRaw = fallbackResponse.headers
-                                                                        .get("retry-after")
-                                                                        ?.trim();
-                                                                    const retryAfterMs = retryAfterRaw && /^\d+$/.test(retryAfterRaw)
-                                                                        ? Number.parseInt(retryAfterRaw, 10) * 1000
-                                                                        : 60_000;
+                                                                    const retryAfterMs = parseRetryAfterHintMs(fallbackResponse.headers) ?? 60_000;
                                                                     accountManager.markRateLimitedWithReason(fallbackAccount, retryAfterMs, modelFamily, "quota", model);
                                                                     accountManager.recordRateLimit(fallbackAccount, modelFamily, model);
                                                                 }