oc-auth-switcher 0.4.0 → 0.5.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) {
@@ -735,53 +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" || thresholds.session5h > 0 && usage.session5h.utilization >= thresholds.session5h || thresholds.weekly7d > 0 && usage.weekly7d.utilization >= thresholds.weekly7d || thresholds.weekly7dSonnet > 0 && usage.weekly7dSonnet.utilization >= thresholds.weekly7dSonnet || thresholds.weekly7dFable > 0 && 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;
-  const scores = [
-    { util: usage.session5h.utilization, threshold: thresholds.session5h },
-    { util: usage.weekly7d.utilization, threshold: thresholds.weekly7d },
-    { util: usage.weekly7dSonnet.utilization, threshold: thresholds.weekly7dSonnet },
-    { util: usage.weekly7dFable.utilization, threshold: thresholds.weekly7dFable }
-  ].filter((metric) => metric.threshold > 0).map((metric) => metric.util / metric.threshold);
+  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") {
+  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 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();
@@ -791,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;
     }
   }
@@ -808,7 +831,7 @@ function findBestAvailable(candidates, state, exclude) {
       continue;
     if (isTemporarilyUnavailable(state, acct.name))
       continue;
-    const score = getUtilizationScore(state.usage[acct.name], state);
+    const score = getUtilizationScore(state.usage[acct.name], state, modelFamily);
     if (!best || score < bestScore) {
       bestScore = score;
       best = acct;
@@ -816,16 +839,17 @@ function findBestAvailable(candidates, state, exclude) {
   }
   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,
@@ -863,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,
@@ -877,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,
@@ -900,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,
@@ -946,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: {
@@ -1014,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.4.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",