oc-auth-switcher 0.3.0 → 0.5.0

package/dist/cli.js

@@ -171,8 +171,7 @@ function defaultState() {
     authFailures: {}
   };
 }
-function loadState() {
-  const raw = safeReadJSON(STATE_FILE, {});
+function normalizeState(raw) {
   const defaults = defaultState();
   const threshold = raw.config?.threshold;
   const migratedThreshold = typeof threshold === "object" && threshold !== null ? {
@@ -206,6 +205,9 @@ function loadState() {
     authFailures: raw.authFailures ?? defaults.authFailures
   };
 }
+function loadState() {
+  return normalizeState(safeReadJSON(STATE_FILE, {}));
+}
 function saveState(state) {
   safeWriteJSON(STATE_FILE, state);
 }
@@ -649,8 +651,8 @@ ${BOLD}${CYAN}=== Auth Switcher Configuration ===${RESET}
     const arg = args[i];
     if (arg === "--threshold" && args[i + 1]) {
       const val = parseFloat(args[++i]);
-      if (isNaN(val) || val < 0 || val > 1) {
-        console.error(`${RED}Threshold must be between 0 and 1 (e.g., 0.90)${RESET}`);
+      if (isNaN(val) || val <= 0 || val > 1) {
+        console.error(`${RED}Threshold must be greater than 0 and at most 1 (e.g., 0.90)${RESET}`);
         process.exit(1);
       }
       state.config.threshold = val;
@@ -662,6 +664,10 @@ ${BOLD}${CYAN}=== Auth Switcher Configuration ===${RESET}
         process.exit(1);
       }
       const normalized = parts.map((v) => v > 1 ? v / 100 : v);
+      if (normalized.some((v) => v <= 0 || v > 1)) {
+        console.error(`${RED}Thresholds must each be greater than 0 and at most 100%${RESET}`);
+        process.exit(1);
+      }
       const currentFableThreshold = getThresholds(state.config).weekly7dFable;
       state.config.threshold = {
         session5h: normalized[0],

package/dist/index.js

@@ -416,6 +416,12 @@ var STATE_FILE = path.join(configDir, "auth-switcher-state.json");
 var DEFAULT_THRESHOLD = 0.95;
 var DEFAULT_CHECK_INTERVAL = 60 * 60 * 1000;
 var AUTH_FAILURE_COOLDOWN = 10 * 60 * 1000;
+var METRIC_MODEL_FAMILY = {
+  session5h: null,
+  weekly7d: null,
+  weekly7dSonnet: "sonnet",
+  weekly7dFable: "fable"
+};
 
 // src/accounts.ts
 function normalizeAccount(raw) {
@@ -539,8 +545,7 @@ function defaultState() {
     authFailures: {}
   };
 }
-function loadState() {
-  const raw = safeReadJSON(STATE_FILE, {});
+function normalizeState(raw) {
   const defaults = defaultState();
   const threshold = raw.config?.threshold;
   const migratedThreshold = typeof threshold === "object" && threshold !== null ? {
@@ -574,6 +579,9 @@ function loadState() {
     authFailures: raw.authFailures ?? defaults.authFailures
   };
 }
+function loadState() {
+  return normalizeState(safeReadJSON(STATE_FILE, {}));
+}
 function saveState(state) {
   safeWriteJSON(STATE_FILE, state);
 }
@@ -711,7 +719,8 @@ function updateUsageFromHeaders(state, accountName, headers) {
     usage.rejected = {
       utilization: 1,
       reset: Math.max(usage.rejected.reset, reset),
-      status: "rejected"
+      status: "rejected",
+      prefix
     };
     updated = true;
   }
@@ -732,47 +741,70 @@ function isTemporarilyUnavailable(state, accountName) {
   }
   return true;
 }
-function isOverThreshold(usage, state) {
+function isOverThreshold(usage, state, modelFamily) {
   if (!usage)
     return false;
   const thresholds = getThresholds(state.config);
-  return usage.rejected.status?.toLowerCase() === "rejected" || usage.session5h.utilization > thresholds.session5h || usage.weekly7d.utilization > thresholds.weekly7d || usage.weekly7dSonnet.utilization > thresholds.weekly7dSonnet || usage.weekly7dFable.utilization > thresholds.weekly7dFable;
+  if (usage.rejected.status?.toLowerCase() === "rejected" && isRejectionRelevant(usage.rejected.prefix, modelFamily))
+    return true;
+  return metricEntries(usage, thresholds, modelFamily).some((metric) => metric.threshold > 0 && metric.util >= metric.threshold);
 }
-function getUtilizationScore(usage, state) {
+function getUtilizationScore(usage, state, modelFamily) {
   if (!usage)
     return 0;
   const thresholds = getThresholds(state.config);
-  if (usage.rejected.status?.toLowerCase() === "rejected")
+  if (usage.rejected.status?.toLowerCase() === "rejected" && isRejectionRelevant(usage.rejected.prefix, modelFamily))
     return Infinity;
-  return Math.max(usage.session5h.utilization / thresholds.session5h, usage.weekly7d.utilization / thresholds.weekly7d, usage.weekly7dSonnet.utilization / thresholds.weekly7dSonnet, usage.weekly7dFable.utilization / thresholds.weekly7dFable);
+  const scores = metricEntries(usage, thresholds, modelFamily).filter((metric) => metric.threshold > 0).map((metric) => metric.util / metric.threshold);
+  return scores.length > 0 ? Math.max(...scores) : 0;
 }
-function getExceededMetric(usage, state) {
+function getExceededMetric(usage, state, modelFamily) {
   if (!usage)
     return null;
   const thresholds = getThresholds(state.config);
-  if (usage.rejected.status?.toLowerCase() === "rejected") {
-    return "rejected rate limit";
+  if (usage.rejected.status?.toLowerCase() === "rejected" && isRejectionRelevant(usage.rejected.prefix, modelFamily)) {
+    return usage.rejected.prefix ? `rejected rate limit (${usage.rejected.prefix})` : "rejected rate limit";
   }
-  const metrics = [
-    { name: "session5h", util: usage.session5h.utilization, thresh: thresholds.session5h },
-    { name: "weekly7d", util: usage.weekly7d.utilization, thresh: thresholds.weekly7d },
-    { name: "weekly7dSonnet", util: usage.weekly7dSonnet.utilization, thresh: thresholds.weekly7dSonnet },
-    { name: "weekly7dFable", util: usage.weekly7dFable.utilization, thresh: thresholds.weekly7dFable }
-  ];
-  const exceeded = metrics.filter((m) => m.util > m.thresh).sort((a, b) => b.util / b.thresh - a.util / a.thresh);
+  const metrics = metricEntries(usage, thresholds, modelFamily).map(({ name, util, threshold }) => ({ name, util, thresh: threshold }));
+  const exceeded = metrics.filter((m) => m.thresh > 0 && m.util >= m.thresh).sort((a, b) => b.util / b.thresh - a.util / a.thresh);
   return exceeded.length > 0 ? exceeded[0].name : null;
 }
-function getEarliestReset(usage) {
+function getEarliestReset(usage, modelFamily) {
   if (!usage)
     return 0;
-  const resets = [
-    usage.session5h.reset,
-    usage.weekly7d.reset,
-    usage.weekly7dSonnet.reset,
-    usage.weekly7dFable.reset,
-    usage.rejected.reset
-  ].filter((r) => r > 0);
-  return resets.length > 0 ? Math.min(...resets) * 1000 : 0;
+  const resets = Object.keys(METRIC_MODEL_FAMILY).filter((key) => isMetricRelevant(key, modelFamily)).map((key) => usage[key].reset);
+  if (isRejectionRelevant(usage.rejected.prefix, modelFamily)) {
+    resets.push(usage.rejected.reset);
+  }
+  const activeResets = resets.filter((reset) => reset > 0);
+  return activeResets.length > 0 ? Math.min(...activeResets) * 1000 : 0;
+}
+function getModelFamily(model) {
+  if (!model)
+    return;
+  const normalized = model.toLowerCase();
+  return ["fable", "sonnet", "opus"].find((family) => normalized.includes(family));
+}
+function isMetricRelevant(metric, modelFamily) {
+  const metricFamily = METRIC_MODEL_FAMILY[metric];
+  return modelFamily === undefined || metricFamily === null || metricFamily === modelFamily;
+}
+function rejectionFamily(prefix) {
+  if (!prefix)
+    return;
+  const normalized = prefix.toLowerCase();
+  return ["fable", "sonnet", "opus"].find((family) => normalized === `7d_${family}` || normalized === `anthropic-ratelimit-unified-7d_${family}`);
+}
+function isRejectionRelevant(prefix, modelFamily) {
+  const rejectedFamily = rejectionFamily(prefix);
+  return modelFamily === undefined || rejectedFamily === undefined || rejectedFamily === modelFamily;
+}
+function metricEntries(usage, thresholds, modelFamily) {
+  return Object.keys(METRIC_MODEL_FAMILY).filter((key) => isMetricRelevant(key, modelFamily)).map((key) => ({
+    name: key,
+    util: usage[key].utilization,
+    threshold: thresholds[key]
+  }));
 }
 function purgeExpiredCooldowns(state) {
   const now = Date.now();
@@ -782,13 +814,13 @@ function purgeExpiredCooldowns(state) {
     }
   }
 }
-function findBestAvailable(candidates, state, exclude) {
+function findBestAvailable(candidates, state, exclude, modelFamily) {
   for (const acct of candidates) {
     if (exclude.has(acct.name))
       continue;
     if (isTemporarilyUnavailable(state, acct.name))
       continue;
-    if (!isOverThreshold(state.usage[acct.name], state)) {
+    if (!isOverThreshold(state.usage[acct.name], state, modelFamily)) {
       return acct;
     }
   }
@@ -799,24 +831,25 @@ function findBestAvailable(candidates, state, exclude) {
       continue;
     if (isTemporarilyUnavailable(state, acct.name))
       continue;
-    const score = getUtilizationScore(state.usage[acct.name], state);
-    if (score < bestScore) {
+    const score = getUtilizationScore(state.usage[acct.name], state, modelFamily);
+    if (!best || score < bestScore) {
       bestScore = score;
       best = acct;
     }
   }
   return best;
 }
-function selectAccount(accounts, state) {
+function selectAccount(accounts, state, model) {
   if (accounts.length === 0) {
     throw new Error("No accounts available");
   }
   purgeExpiredCooldowns(state);
+  const modelFamily = getModelFamily(model);
   if (state.selectionMode === "manual" && state.manualAccount) {
     const manual = accounts.find((account) => account.name === state.manualAccount);
     if (manual) {
       const unavailable = isTemporarilyUnavailable(state, manual.name);
-      const exhausted = isOverThreshold(state.usage[manual.name], state);
+      const exhausted = isOverThreshold(state.usage[manual.name], state, modelFamily);
       if (!unavailable && !exhausted) {
         return {
           account: manual,
@@ -854,9 +887,9 @@ function selectAccount(accounts, state) {
   const primaryUsage = state.usage[primary.name];
   const isPrimary = current.name === primary.name;
   if (isPrimary) {
-    if (isOverThreshold(primaryUsage, state)) {
-      const exceededMetric = getExceededMetric(primaryUsage, state);
-      const best = findBestAvailable(fallbacks, state, new Set);
+    if (isOverThreshold(primaryUsage, state, modelFamily)) {
+      const exceededMetric = getExceededMetric(primaryUsage, state, modelFamily);
+      const best = findBestAvailable(fallbacks, state, new Set, modelFamily);
       if (best) {
         return {
           account: best,
@@ -868,18 +901,18 @@ function selectAccount(accounts, state) {
     }
     return { account: primary, switched: false };
   }
-  const currentOverThreshold = isOverThreshold(currentUsage, state);
+  const currentOverThreshold = isOverThreshold(currentUsage, state, modelFamily);
   const currentInCooldown = isTemporarilyUnavailable(state, current.name);
   if (currentOverThreshold || currentInCooldown) {
     const reason = currentInCooldown ? `${current.name} in auth-failure cooldown` : `${current.name} exceeded threshold`;
-    if (!isOverThreshold(primaryUsage, state) && !isTemporarilyUnavailable(state, primary.name)) {
+    if (!isOverThreshold(primaryUsage, state, modelFamily) && !isTemporarilyUnavailable(state, primary.name)) {
       return {
         account: primary,
         switched: true,
         reason: `${reason} — switching back to primary`
       };
     }
-    const best = findBestAvailable(accounts, state, new Set([current.name]));
+    const best = findBestAvailable(accounts, state, new Set([current.name]), modelFamily);
     if (best && best.name !== current.name) {
       return {
         account: best,
@@ -891,12 +924,12 @@ function selectAccount(accounts, state) {
   }
   const now = Date.now();
   const checkInterval = state.config.checkInterval;
-  const earliestReset = getEarliestReset(primaryUsage);
+  const earliestReset = getEarliestReset(primaryUsage, modelFamily);
   const timeSinceLastCheck = now - state.lastRotationCheck;
   const shouldCheckPrimary = earliestReset > 0 && earliestReset <= now || timeSinceLastCheck >= checkInterval;
   if (shouldCheckPrimary) {
     state.lastRotationCheck = now;
-    if (!isOverThreshold(primaryUsage, state) && !isTemporarilyUnavailable(state, primary.name)) {
+    if (!isOverThreshold(primaryUsage, state, modelFamily) && !isTemporarilyUnavailable(state, primary.name)) {
       return {
         account: primary,
         switched: true,
@@ -937,6 +970,16 @@ function saveRequestState(state, initiallyLoaded) {
   }
   saveState(state);
 }
+function getRequestModel(body) {
+  if (typeof body !== "string")
+    return;
+  try {
+    const parsed = JSON.parse(body);
+    return typeof parsed.model === "string" ? parsed.model : undefined;
+  } catch {
+    return;
+  }
+}
 var AuthSwitcherPlugin = async ({ client }) => {
   return {
     auth: {
@@ -1005,7 +1048,8 @@ var AuthSwitcherPlugin = async ({ client }) => {
             }
             ensureAccountsInState(state, accounts.map((a) => a.name));
             resolveStaleMetrics(state);
-            const selection = selectAccount(accounts, state);
+            const model = getRequestModel(init?.body);
+            const selection = selectAccount(accounts, state, model);
             let account = selection.account;
             if (selection.switched) {
               await client.app.log({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oc-auth-switcher",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "OpenCode auth plugin for multi-account Anthropic Claude Max rotation with automatic failover.",
   "type": "module",
   "main": "dist/index.js",
@@ -10,6 +10,7 @@
   "scripts": {
     "build": "bun build src/index.ts --outdir dist --target node --format esm && bun build src/cli.ts --outdir dist --target bun --format esm",
     "dev": "bun run build --watch",
+    "test": "bun test",
     "prepublishOnly": "bun run build"
   },
   "peerDependencies": {