zevairouter 1.0.151 → 1.0.152

package/cli/app/CHANGELOG.md

@@ -1,3 +1,9 @@
+# v1.0.152 (2026-07-27)
+
+## Fixes
+- **Accurate Codex quota recovery**: a newer quota snapshot that explicitly reports capacity can now supersede a stale per-model lock instead of returning a false long-lived 429 while quota remains available.
+- **Bounded recovery probes**: recovered accounts are retried once only when the quota snapshot is newer than the locking error; a fresh upstream failure immediately restores the lock and prevents retry loops.
+
 # v1.0.151 (2026-07-27)
 
 ## Fixes

package/cli/app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter",
-  "version": "1.0.151",
+  "version": "1.0.152",
   "description": "Self-hosted AI router: many providers, one OpenAI-compatible /v1 endpoint and dashboard",
   "bin": {
     "zevai": "./cli/cli.js"

package/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter-cli",
-  "version": "1.0.151",
+  "version": "1.0.152",
   "description": "ZevaiRouter CLI - Start and manage ZevaiRouter server",
   "bin": {
     "zevai": "./cli.js"

package/open-sse/services/accountFallback.js

@@ -53,6 +53,43 @@ export function getQuotaExhaustedUntil(usage) {
   return getQuotaResetAt(usage);
 }
 
+/**
+ * Return true only when a quota snapshot explicitly says every known window
+ * still has capacity. Requiring all windows avoids treating an account with an
+ * exhausted weekly window as recovered just because its short window is open.
+ */
+export function hasAvailableQuota(usage) {
+  if (!usage || usage.limitReached === true) return false;
+  const quotas = Object.values(usage.quotas || {});
+  const remaining = quotas.map((quota) => {
+    if (Number.isFinite(quota?.remaining)) return quota.remaining;
+    if (Number.isFinite(quota?.remainingPercentage)) return quota.remainingPercentage;
+    return null;
+  }).filter((value) => value !== null);
+
+  return remaining.length > 0
+    && remaining.length === quotas.length
+    && remaining.every((value) => value > 0);
+}
+
+/**
+ * A successful quota poll newer than the error which created a model lock is
+ * authoritative evidence that a Codex account recovered. The caller may probe
+ * the account once; a fresh upstream failure updates lastErrorAt and makes the
+ * same snapshot too old to bypass the replacement lock.
+ */
+export function isModelLockRecoveredByQuota(connection, model, snapshot) {
+  if (!isModelLockActive(connection, model) || !hasAvailableQuota(snapshot?.usage)) {
+    return false;
+  }
+
+  const fetchedAt = Date.parse(snapshot?.fetchedAt);
+  const errorAt = Date.parse(connection?.lastErrorAt);
+  return Number.isFinite(fetchedAt)
+    && Number.isFinite(errorAt)
+    && fetchedAt > errorAt;
+}
+
 /**
  * Calculate exponential backoff cooldown for rate limits (429)
  * Level 1: 1s, Level 2: 2s, Level 3: 4s... → max 4 min

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter",
-  "version": "1.0.151",
+  "version": "1.0.152",
   "description": "Self-hosted AI router: many providers, one OpenAI-compatible /v1 endpoint and dashboard",
   "bin": {
     "zevai": "./cli/cli.js"

package/src/sse/services/auth.js

@@ -1,6 +1,6 @@
 import { getProviderConnections, validateApiKey, updateProviderConnection, getSettings, getQuotaSnapshot, getAllQuotaSnapshots, getProxyPools } from "@/lib/localDb";
 import { resolveConnectionProxyConfig, pickProxyPoolId } from "@/lib/network/connectionProxy";
-import { formatRetryAfter, checkFallbackError, isModelLockActive, buildModelLockUpdate, getEarliestModelLockUntil, isNonAccountError, extractProviderErrorCode, getQuotaResetAt, getQuotaExhaustedUntil } from "open-sse/services/accountFallback.js";
+import { formatRetryAfter, checkFallbackError, isModelLockActive, isModelLockRecoveredByQuota, buildModelLockUpdate, getEarliestModelLockUntil, isNonAccountError, extractProviderErrorCode, getQuotaResetAt, getQuotaExhaustedUntil } from "open-sse/services/accountFallback.js";
 import { MAX_RATE_LIMIT_COOLDOWN_MS } from "open-sse/config/errorConfig.js";
 import { resolveProviderId, FREE_PROVIDERS } from "@/shared/constants/providers.js";
 import * as log from "../utils/logger.js";
@@ -77,9 +77,29 @@ export async function getProviderCredentials(provider, excludeConnectionIds = nu
       }
     }
 
+    // Codex can return a precise usage-limit reset which creates a long-lived
+    // model lock. If a newer quota poll explicitly reports capacity again, let
+    // that account be probed once instead of serving a stale all-rate-limited
+    // response until the old reset timestamp. A new failure is newer than the
+    // snapshot, so it immediately restores the lock without a retry loop.
+    const recoveredModelLocks = new Set();
+    if (providerId === "codex" && model) {
+      const snapshots = await getAllQuotaSnapshots(providerId);
+      const byConnection = new Map(snapshots.map((snapshot) => [snapshot.connectionId, snapshot]));
+      for (const connection of connections) {
+        if (isModelLockRecoveredByQuota(connection, model, byConnection.get(connection.id))) {
+          recoveredModelLocks.add(connection.id);
+        }
+      }
+    }
+
+    const hasBlockingModelLock = (connection) => (
+      isModelLockActive(connection, model) && !recoveredModelLocks.has(connection.id)
+    );
+
     const baseAvailableConnections = connections.filter(c => {
       if (excludeSet.has(c.id)) return false;
-      if (isModelLockActive(c, model)) return false;
+      if (hasBlockingModelLock(c)) return false;
       if (quotaExhausted.has(c.id)) return false;
       return true;
     });
@@ -98,7 +118,7 @@ export async function getProviderCredentials(provider, excludeConnectionIds = nu
         log.warn("AUTH", `${provider} | pinned account excluded after failure: ${preferred.id?.slice(0, 8)}`);
         return null;
       }
-      if (isModelLockActive(preferred, model) || quotaExhausted.has(preferred.id)) {
+      if (hasBlockingModelLock(preferred) || quotaExhausted.has(preferred.id)) {
         const retryAfter = [
           getEarliestModelLockUntil(preferred),
           quotaExhausted.has(preferred.id)
@@ -119,17 +139,18 @@ export async function getProviderCredentials(provider, excludeConnectionIds = nu
     log.debug("AUTH", `${provider} | available: ${availableConnections.length}/${connections.length}`);
     connections.forEach(c => {
       const excluded = excludeSet.has(c.id);
-      const locked = isModelLockActive(c, model);
+      const locked = hasBlockingModelLock(c);
+      const recovered = recoveredModelLocks.has(c.id);
       const exhaustedUntil = quotaExhausted.get(c.id);
-      if (excluded || locked || exhaustedUntil) {
+      if (excluded || locked || exhaustedUntil || recovered) {
         const lockUntil = getEarliestModelLockUntil(c);
-        log.debug("AUTH", `  \u2192 ${c.id?.slice(0, 8)} | ${excluded ? "excluded" : ""} ${locked ? `modelLocked(${model}) until ${lockUntil}` : ""} ${exhaustedUntil ? `quotaExhausted until ${new Date(exhaustedUntil).toISOString()}` : ""}`);
+        log.debug("AUTH", `  \u2192 ${c.id?.slice(0, 8)} | ${excluded ? "excluded" : ""} ${locked ? `modelLocked(${model}) until ${lockUntil}` : ""} ${recovered ? `staleLockRecovered(${model})` : ""} ${exhaustedUntil ? `quotaExhausted until ${new Date(exhaustedUntil).toISOString()}` : ""}`);
       }
     });
 
     if (availableConnections.length === 0) {
       // Find earliest lock expiry across all connections for retry timing
-      const lockedConns = connections.filter(c => isModelLockActive(c, model));
+      const lockedConns = connections.filter(c => hasBlockingModelLock(c));
       const expiries = [
         ...lockedConns.map(c => getEarliestModelLockUntil(c)).filter(Boolean),
         ...quotaExhausted.values().map(timestamp => new Date(timestamp).toISOString()),