zevairouter 1.0.120 → 1.0.121

package/src/sse/services/auth.js

@@ -1,6 +1,6 @@
-import { getProviderConnections, validateApiKey, updateProviderConnection, getSettings, getQuotaSnapshot, getProxyPools } from "@/lib/localDb";
+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 } from "open-sse/services/accountFallback.js";
+import { formatRetryAfter, checkFallbackError, isModelLockActive, 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";
@@ -68,9 +68,19 @@ export async function getProviderCredentials(provider, excludeConnectionIds = nu
       return null;
     }
 
+    const quotaExhausted = new Map();
+    if (providerId === "codebuddy-cn") {
+      const snapshots = await getAllQuotaSnapshots(providerId);
+      for (const snapshot of snapshots) {
+        const until = getQuotaExhaustedUntil(snapshot.usage);
+        if (until) quotaExhausted.set(snapshot.connectionId, until);
+      }
+    }
+
     const baseAvailableConnections = connections.filter(c => {
       if (excludeSet.has(c.id)) return false;
       if (isModelLockActive(c, model)) return false;
+      if (quotaExhausted.has(c.id)) return false;
       return true;
     });
 
@@ -88,8 +98,13 @@ 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)) {
-        const retryAfter = getEarliestModelLockUntil(preferred);
+      if (isModelLockActive(preferred, model) || quotaExhausted.has(preferred.id)) {
+        const retryAfter = [
+          getEarliestModelLockUntil(preferred),
+          quotaExhausted.has(preferred.id)
+            ? new Date(quotaExhausted.get(preferred.id)).toISOString()
+            : null,
+        ].filter(Boolean).sort()[0];
         return {
           allRateLimited: true,
           retryAfter,
@@ -105,16 +120,20 @@ export async function getProviderCredentials(provider, excludeConnectionIds = nu
     connections.forEach(c => {
       const excluded = excludeSet.has(c.id);
       const locked = isModelLockActive(c, model);
-      if (excluded || locked) {
+      const exhaustedUntil = quotaExhausted.get(c.id);
+      if (excluded || locked || exhaustedUntil) {
         const lockUntil = getEarliestModelLockUntil(c);
-        log.debug("AUTH", `  \u2192 ${c.id?.slice(0, 8)} | ${excluded ? "excluded" : ""} ${locked ? `modelLocked(${model}) until ${lockUntil}` : ""}`);
+        log.debug("AUTH", `  \u2192 ${c.id?.slice(0, 8)} | ${excluded ? "excluded" : ""} ${locked ? `modelLocked(${model}) until ${lockUntil}` : ""} ${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 expiries = lockedConns.map(c => getEarliestModelLockUntil(c)).filter(Boolean);
+      const expiries = [
+        ...lockedConns.map(c => getEarliestModelLockUntil(c)).filter(Boolean),
+        ...quotaExhausted.values().map(timestamp => new Date(timestamp).toISOString()),
+      ];
       const earliest = expiries.sort()[0] || null;
       if (earliest) {
         const earliestConn = lockedConns[0];
@@ -314,6 +333,18 @@ export async function markAccountUnavailable(connectionId, status, errorText, pr
   const connections = await getProviderConnections({ provider });
   const conn = connections.find(c => c.id === connectionId);
   const backoffLevel = conn?.backoffLevel || 0;
+  const providerErrorCode = extractProviderErrorCode(errorText);
+
+  // CodeBuddy quota/eligibility errors are model-specific. Re-probe after the
+  // real quota-cycle reset instead of retrying every generic 403 cooldown.
+  const isCodeBuddyModelError =
+    provider === "codebuddy-cn" &&
+    (providerErrorCode === 14018 || providerErrorCode === 11140);
+
+  if (isCodeBuddyModelError) {
+    const snapshot = await getQuotaSnapshot(connectionId);
+    resetsAtMs = getQuotaResetAt(snapshot?.usage) || resetsAtMs;
+  }
 
   // Provider-specific precise cooldown (e.g. codex usage_limit_reached resets_at) overrides backoff
   let shouldFallback, cooldownMs, newBackoffLevel;
@@ -334,6 +365,8 @@ export async function markAccountUnavailable(connectionId, status, errorText, pr
     testStatus: "unavailable",
     lastError: reason,
     errorCode: status,
+    providerErrorCode,
+    modelLockReason: model ? { model, providerErrorCode, reason, resetsAt: new Date(Date.now() + cooldownMs).toISOString() } : null,
     lastErrorAt: new Date().toISOString(),
     backoffLevel: newBackoffLevel ?? backoffLevel
   });
@@ -367,7 +400,7 @@ export async function markAccountUnavailable(connectionId, status, errorText, pr
     "insufficient_quota", "quota exceeded", "payment required",
   ];
 
-  if (TERMINAL_AUTH_STATUSES.has(status)) {
+  if (TERMINAL_AUTH_STATUSES.has(status) && !isCodeBuddyModelError) {
     const lowerError = (typeof errorText === "string" ? errorText : "").toLowerCase();
     const isTerminalError = TERMINAL_ERROR_MARKERS.some(marker => lowerError.includes(marker));
 
@@ -439,7 +472,16 @@ export async function clearAccountError(connectionId, currentConnection, model =
 
   // Only reset error state if no active locks remain
   if (remainingActiveLocks.length === 0) {
-    Object.assign(clearObj, { testStatus: "active", lastError: null, lastErrorAt: null, backoffLevel: 0, consecutiveAuthFailures: 0 });
+    Object.assign(clearObj, {
+      testStatus: "active",
+      lastError: null,
+      errorCode: null,
+      providerErrorCode: null,
+      modelLockReason: null,
+      lastErrorAt: null,
+      backoffLevel: 0,
+      consecutiveAuthFailures: 0
+    });
   }
 
   await updateProviderConnection(connectionId, clearObj);