oc-auth-switcher 0.4.0 → 0.6.0

package/README.md

@@ -25,19 +25,17 @@ This is the **only** auth plugin you need for Anthropic. Do not also list `@ex-m
 ### 2. Add accounts
 
 ```bash
-# Add your primary account (first account = always preferred)
-oc-auth-switcher add primary
-
-# Add fallback accounts
-oc-auth-switcher add fallback-1
-oc-auth-switcher add fallback-2
+# Add accounts in any order
+oc-auth-switcher add work
+oc-auth-switcher add personal
+oc-auth-switcher add team
 ```
 
 Each `add` command runs an OAuth flow — you'll be given a URL to open in your browser and prompted to paste the callback.
 
 ### 3. Use OpenCode normally
 
-Metrics update automatically on every API request. When the primary account exceeds the utilization threshold, the plugin switches to the next available fallback. When the primary recovers, it switches back.
+Metrics update automatically on every API request. The active account remains selected until it reaches a relevant utilization threshold or becomes unavailable, then the plugin switches to the available account with the most headroom.
 
 ## CLI Commands
 
@@ -50,8 +48,8 @@ oc-auth-switcher <command> [options]
 | `add [name]` | Add a new account via OAuth |
 | `reauth <name>` | Re-authenticate an existing account |
 | `usage [--watch]` | Show utilization dashboard with progress bars |
-| `config [options]` | View/modify thresholds and check interval |
-| `switch <name>` | Manually switch to a specific account |
+| `config [options]` | View/modify thresholds |
+| `switch <name>` | Set the active account |
 | `status` | Show current active account and rotation state |
 | `remove <name>` | Remove an account from the pool |
 
@@ -61,11 +59,8 @@ oc-auth-switcher <command> [options]
 # Set uniform threshold (default: 95%)
 oc-auth-switcher config --threshold 0.95
 
-# Set per-metric thresholds (5h, 7d, 7d-sonnet)
-oc-auth-switcher config --thresholds 90,80,70
-
-# Set primary recovery check interval (default: 60 min)
-oc-auth-switcher config --interval 30
+# Set per-metric thresholds (5h, 7d, 7d-sonnet, 7d-fable)
+oc-auth-switcher config --thresholds 90,80,70,70
 
 # Reset to defaults
 oc-auth-switcher config --reset
@@ -82,12 +77,13 @@ Both files use atomic writes with `.bak` fallback for crash safety.
 
 ## Rotation Algorithm
 
-- The first account in the pool is always "primary" (preferred)
-- When the primary exceeds any utilization threshold, switch to the first fallback under threshold
-- If all fallbacks are also over threshold, pick the one with the lowest utilization score
-- When on a fallback, periodically check if the primary has recovered (configurable interval)
-- Auth failures trigger a 1-hour cooldown per account
-- Token refresh is handled automatically with retry and fallback to other accounts
+- Keep the active account while its model-relevant utilization remains below threshold
+- When rotation is required, select the available account with the lowest maximum threshold-normalized utilization
+- Break exact utilization ties by account array order
+- If every account is exhausted, select the least-loaded account rather than failing
+- Recovered accounts do not preempt a healthy active account
+- Auth failures trigger a 10-minute cooldown per account
+- Token refresh is handled automatically with retry and failover to other accounts
 
 ## Running the CLI
 

package/dist/cli.js

@@ -12,8 +12,8 @@ var configDir = path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(),
 var ACCOUNTS_FILE = path.join(configDir, "auth-switcher-accounts.json");
 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 REJECTION_FALLBACK_SECONDS = 60 * 60;
 
 // node_modules/@ex-machina/opencode-anthropic-auth/dist/constants.js
 var CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
@@ -159,13 +159,9 @@ var EMPTY_USAGE = {
 function defaultState() {
   return {
     currentAccount: null,
-    selectionMode: "auto",
-    manualAccount: null,
-    lastRotationCheck: 0,
     requestCount: 0,
     config: {
-      threshold: DEFAULT_THRESHOLD,
-      checkInterval: DEFAULT_CHECK_INTERVAL
+      threshold: DEFAULT_THRESHOLD
     },
     usage: {},
     authFailures: {}
@@ -193,13 +189,9 @@ function normalizeState(raw) {
   ]));
   return {
     currentAccount: raw.currentAccount ?? defaults.currentAccount,
-    selectionMode: raw.selectionMode === "manual" && raw.manualAccount ? "manual" : "auto",
-    manualAccount: raw.manualAccount ?? defaults.manualAccount,
-    lastRotationCheck: raw.lastRotationCheck ?? defaults.lastRotationCheck,
     requestCount: raw.requestCount ?? defaults.requestCount,
     config: {
-      threshold: migratedThreshold,
-      checkInterval: raw.config?.checkInterval ?? defaults.config.checkInterval
+      threshold: migratedThreshold
     },
     usage,
     authFailures: raw.authFailures ?? defaults.authFailures
@@ -641,7 +633,6 @@ ${BOLD}${CYAN}=== Auth Switcher Configuration ===${RESET}
     console.log(`  Threshold (7d):        ${(thresholds.weekly7d * 100).toFixed(0)}%`);
     console.log(`  Threshold (7d sonnet): ${(thresholds.weekly7dSonnet * 100).toFixed(0)}%`);
     console.log(`  Threshold (7d fable):  ${(thresholds.weekly7dFable * 100).toFixed(0)}%`);
-    console.log(`  Check interval:        ${state.config.checkInterval / 60000} min`);
     console.log();
     console.log(`${DIM}  Config file: ${STATE_FILE}${RESET}`);
     console.log();
@@ -676,18 +667,9 @@ ${BOLD}${CYAN}=== Auth Switcher Configuration ===${RESET}
         weekly7dFable: normalized[3] ?? currentFableThreshold
       };
       console.log(`${GREEN}Set per-metric thresholds: 5h=${(normalized[0] * 100).toFixed(0)}% 7d=${(normalized[1] * 100).toFixed(0)}% 7d-sonnet=${(normalized[2] * 100).toFixed(0)}% 7d-fable=${((normalized[3] ?? currentFableThreshold) * 100).toFixed(0)}%${RESET}`);
-    } else if (arg === "--interval" && args[i + 1]) {
-      const minutes = parseInt(args[++i], 10);
-      if (isNaN(minutes) || minutes < 1) {
-        console.error(`${RED}Interval must be a positive number of minutes${RESET}`);
-        process.exit(1);
-      }
-      state.config.checkInterval = minutes * 60 * 1000;
-      console.log(`${GREEN}Set check interval to ${minutes} minutes${RESET}`);
     } else if (arg === "--reset") {
       state.config.threshold = DEFAULT_THRESHOLD;
-      state.config.checkInterval = DEFAULT_CHECK_INTERVAL;
-      console.log(`${GREEN}Reset to defaults: threshold=${(DEFAULT_THRESHOLD * 100).toFixed(0)}% interval=${DEFAULT_CHECK_INTERVAL / 60000}min${RESET}`);
+      console.log(`${GREEN}Reset to default threshold: ${(DEFAULT_THRESHOLD * 100).toFixed(0)}%${RESET}`);
     }
   }
   saveState(state);
@@ -707,20 +689,10 @@ ${BOLD}Available accounts:${RESET}`);
       const tag = a.name === state2.currentAccount ? ` ${GREEN}[ACTIVE]${RESET}` : "";
       console.log(`  - ${a.name}${tag}`);
     }
-    console.log(`  - auto ${DIM}(resume automatic selection)${RESET}`);
     console.error(`
-${RED}Usage: oc-auth-switcher switch <account-name|auto>${RESET}`);
+${RED}Usage: oc-auth-switcher switch <account-name>${RESET}`);
     process.exit(1);
   }
-  if (name === "auto") {
-    const state2 = loadState();
-    state2.selectionMode = "auto";
-    state2.manualAccount = null;
-    state2.lastRotationCheck = Date.now();
-    saveState(state2);
-    console.log(`${GREEN}Automatic account selection resumed.${RESET}`);
-    return;
-  }
   const account = data.accounts.find((a) => a.name === name);
   if (!account) {
     console.error(`${RED}Account "${name}" not found${RESET}`);
@@ -729,9 +701,6 @@ ${RED}Usage: oc-auth-switcher switch <account-name|auto>${RESET}`);
   console.log(`${CYAN}Switching to account: ${name}...${RESET}`);
   const state = loadState();
   state.currentAccount = name;
-  state.selectionMode = "manual";
-  state.manualAccount = name;
-  state.lastRotationCheck = Date.now();
   saveState(state);
   console.log(`${GREEN}Switched to "${name}". Will take effect on the next API request.${RESET}`);
 }
@@ -743,10 +712,8 @@ function cmdStatus() {
 ${BOLD}${CYAN}=== Auth Switcher Status ===${RESET}
 `);
   console.log(`  Active account:    ${BOLD}${state.currentAccount || "(none)"}${RESET}`);
-  console.log(`  Selection mode:    ${state.selectionMode}${state.manualAccount ? ` (${state.manualAccount})` : ""}`);
   console.log(`  Total accounts:    ${data.accounts.length}`);
   console.log(`  Request count:     ${state.requestCount}`);
-  console.log(`  Last rotation:     ${state.lastRotationCheck ? new Date(state.lastRotationCheck).toLocaleString() : "never"}`);
   console.log();
   const failures = Object.entries(state.authFailures).filter(([_, until]) => until > Date.now());
   if (failures.length > 0) {
@@ -778,10 +745,6 @@ function cmdRemove(args) {
   const state = loadState();
   if (state.currentAccount === name) {
     state.currentAccount = null;
-    if (state.manualAccount === name) {
-      state.selectionMode = "auto";
-      state.manualAccount = null;
-    }
     saveState(state);
     console.log(`${YELLOW}This was the active account. Rotation will pick a new one automatically.${RESET}`);
   }
@@ -797,24 +760,22 @@ ${BOLD}COMMANDS:${RESET}
   ${CYAN}add${RESET} [name]          Add a new Anthropic account via OAuth
   ${CYAN}reauth${RESET} <name>       Re-authenticate an existing account
   ${CYAN}usage${RESET} [--watch]     Show usage dashboard with utilization metrics
-  ${CYAN}config${RESET} [options]    View or modify threshold/interval configuration
-  ${CYAN}switch${RESET} <name|auto>  Pin a specific account or resume automatic selection
+  ${CYAN}config${RESET} [options]    View or modify threshold configuration
+  ${CYAN}switch${RESET} <name>       Set the active account
   ${CYAN}status${RESET}              Show current active account and rotation state
   ${CYAN}remove${RESET} <name>       Remove an account from the pool
 
 ${BOLD}CONFIG OPTIONS:${RESET}
   --threshold <0-1>          Set uniform threshold (e.g., 0.90)
   --thresholds <a,b,c[,d]>   Set per-metric thresholds (5h,7d,7d-sonnet,7d-fable)
-  --interval <minutes>       Set primary recovery check interval
   --reset                    Reset to defaults
 
 ${BOLD}EXAMPLES:${RESET}
-  oc-auth-switcher add primary
-  oc-auth-switcher add fallback-1
+  oc-auth-switcher add work
+  oc-auth-switcher add personal
   oc-auth-switcher usage --watch
   oc-auth-switcher config --threshold 0.90
-  oc-auth-switcher switch fallback-1
-  oc-auth-switcher switch auto
+  oc-auth-switcher switch personal
 `);
 }
 async function main() {

package/dist/index.js

@@ -414,8 +414,14 @@ var configDir = path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(),
 var ACCOUNTS_FILE = path.join(configDir, "auth-switcher-accounts.json");
 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 REJECTION_FALLBACK_SECONDS = 60 * 60;
+var METRIC_MODEL_FAMILY = {
+  session5h: null,
+  weekly7d: null,
+  weekly7dSonnet: "sonnet",
+  weekly7dFable: "fable"
+};
 
 // src/accounts.ts
 function normalizeAccount(raw) {
@@ -527,13 +533,9 @@ var EMPTY_USAGE = {
 function defaultState() {
   return {
     currentAccount: null,
-    selectionMode: "auto",
-    manualAccount: null,
-    lastRotationCheck: 0,
     requestCount: 0,
     config: {
-      threshold: DEFAULT_THRESHOLD,
-      checkInterval: DEFAULT_CHECK_INTERVAL
+      threshold: DEFAULT_THRESHOLD
     },
     usage: {},
     authFailures: {}
@@ -561,13 +563,9 @@ function normalizeState(raw) {
   ]));
   return {
     currentAccount: raw.currentAccount ?? defaults.currentAccount,
-    selectionMode: raw.selectionMode === "manual" && raw.manualAccount ? "manual" : "auto",
-    manualAccount: raw.manualAccount ?? defaults.manualAccount,
-    lastRotationCheck: raw.lastRotationCheck ?? defaults.lastRotationCheck,
     requestCount: raw.requestCount ?? defaults.requestCount,
     config: {
-      threshold: migratedThreshold,
-      checkInterval: raw.config?.checkInterval ?? defaults.config.checkInterval
+      threshold: migratedThreshold
     },
     usage,
     authFailures: raw.authFailures ?? defaults.authFailures
@@ -708,7 +706,7 @@ function updateUsageFromHeaders(state, accountName, headers) {
     if (!Number.isFinite(reset) || reset <= 0) {
       const retryAfterHeader = headers.get("retry-after");
       const retryAfter = retryAfterHeader === null ? NaN : Number(retryAfterHeader);
-      reset = Date.now() / 1000 + (Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter : state.config.checkInterval / 1000);
+      reset = Date.now() / 1000 + (Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter : REJECTION_FALLBACK_SECONDS);
     }
     usage.rejected = {
       utilization: 1,
@@ -735,53 +733,49 @@ 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) {
-  if (!usage)
-    return null;
-  const thresholds = getThresholds(state.config);
-  if (usage.rejected.status?.toLowerCase() === "rejected") {
-    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.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 getModelFamily(model) {
+  if (!model)
+    return;
+  const normalized = model.toLowerCase();
+  return ["fable", "sonnet", "opus"].find((family) => normalized.includes(family));
 }
-function getEarliestReset(usage) {
-  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;
+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,24 +785,32 @@ function purgeExpiredCooldowns(state) {
     }
   }
 }
-function findBestAvailable(candidates, state, exclude) {
+function findBestAvailable(candidates, state, exclude, modelFamily) {
+  let best = null;
+  let bestScore = Infinity;
   for (const acct of candidates) {
     if (exclude.has(acct.name))
       continue;
     if (isTemporarilyUnavailable(state, acct.name))
       continue;
-    if (!isOverThreshold(state.usage[acct.name], state)) {
-      return acct;
+    if (!isOverThreshold(state.usage[acct.name], state, modelFamily)) {
+      const score = getUtilizationScore(state.usage[acct.name], state, modelFamily);
+      if (!best || score < bestScore) {
+        bestScore = score;
+        best = acct;
+      }
     }
   }
-  let best = null;
-  let bestScore = Infinity;
+  if (best)
+    return best;
+  best = null;
+  bestScore = Infinity;
   for (const acct of candidates) {
     if (exclude.has(acct.name))
       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,79 +818,29 @@ 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);
-  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);
-      if (!unavailable && !exhausted) {
-        return {
-          account: manual,
-          switched: state.currentAccount !== manual.name,
-          reason: state.currentAccount !== manual.name ? `Manual selection — switching to ${manual.name}` : undefined
-        };
-      }
-      state.currentAccount = manual.name;
-    }
-    state.selectionMode = "auto";
-    state.manualAccount = null;
-  }
-  if (accounts.length === 1) {
-    return { account: accounts[0], switched: false };
-  }
-  const primary = accounts[0];
-  const fallbacks = accounts.slice(1);
-  if (!state.currentAccount) {
-    return {
-      account: primary,
-      switched: true,
-      reason: "Initial selection — using primary account"
-    };
-  }
+  const modelFamily = getModelFamily(model);
   const currentIdx = accounts.findIndex((a) => a.name === state.currentAccount);
   if (currentIdx < 0) {
+    const best = findBestAvailable(accounts, state, new Set, modelFamily);
+    const selected = best ?? accounts[0];
     return {
-      account: primary,
+      account: selected,
       switched: true,
-      reason: "Current account no longer in pool — switching to primary"
+      reason: `Selecting account ${selected.name}`
     };
   }
   const current = accounts[currentIdx];
   const currentUsage = state.usage[current.name];
-  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 (best) {
-        return {
-          account: best,
-          switched: true,
-          reason: `Primary exceeded ${exceededMetric} threshold — switching to ${best.name}`
-        };
-      }
-      return { account: primary, switched: false };
-    }
-    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)) {
-      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,
@@ -898,29 +850,10 @@ function selectAccount(accounts, state) {
     }
     return { account: current, switched: false };
   }
-  const now = Date.now();
-  const checkInterval = state.config.checkInterval;
-  const earliestReset = getEarliestReset(primaryUsage);
-  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)) {
-      return {
-        account: primary,
-        switched: true,
-        reason: "Primary has recovered — switching back"
-      };
-    }
-  }
   return { account: current, switched: false };
 }
 function markAuthFailure(state, accountName) {
   state.authFailures[accountName] = Date.now() + AUTH_FAILURE_COOLDOWN;
-  if (state.selectionMode === "manual" && state.manualAccount === accountName) {
-    state.selectionMode = "auto";
-    state.manualAccount = null;
-  }
 }
 function clearAuthFailure(state, accountName) {
   delete state.authFailures[accountName];
@@ -929,23 +862,27 @@ function clearAuthFailure(state, accountName) {
 // src/index.ts
 function selectionSnapshot(state) {
   return {
-    selectionMode: state.selectionMode,
-    manualAccount: state.manualAccount,
-    currentAccount: state.currentAccount,
-    lastRotationCheck: state.lastRotationCheck
+    currentAccount: state.currentAccount
   };
 }
 function saveRequestState(state, initiallyLoaded) {
   const onDisk = loadState();
-  const selectionChangedSinceLoad = onDisk.selectionMode !== initiallyLoaded.selectionMode || onDisk.manualAccount !== initiallyLoaded.manualAccount || onDisk.currentAccount !== initiallyLoaded.currentAccount || onDisk.lastRotationCheck !== initiallyLoaded.lastRotationCheck;
+  const selectionChangedSinceLoad = onDisk.currentAccount !== initiallyLoaded.currentAccount;
   if (selectionChangedSinceLoad) {
-    state.selectionMode = onDisk.selectionMode;
-    state.manualAccount = onDisk.manualAccount;
     state.currentAccount = onDisk.currentAccount;
-    state.lastRotationCheck = onDisk.lastRotationCheck;
   }
   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 +951,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({
@@ -1038,7 +976,8 @@ var AuthSwitcherPlugin = async ({ client }) => {
                   updateAccountTokens(account.name, result.access, result.refresh, result.expires);
                 } else {
                   markAuthFailure(state, account.name);
-                  const next = accounts.find((a) => !attemptedAccounts.has(a.name) && !state.authFailures[a.name]);
+                  const available = accounts.filter((candidate) => !attemptedAccounts.has(candidate.name) && (!state.authFailures[candidate.name] || state.authFailures[candidate.name] <= Date.now()));
+                  const next = available.length > 0 ? selectAccount(available, state, model).account : undefined;
                   if (!next) {
                     saveRequestState(state, initiallyLoadedSelection);
                     throw new Error(`[oc-auth-switcher] All accounts failed token refresh`);
@@ -1070,7 +1009,8 @@ var AuthSwitcherPlugin = async ({ client }) => {
               const isScopeError = errorBody.includes("scope") || errorBody.includes("unauthorized") || errorBody.includes("invalid");
               if (isScopeError) {
                 markAuthFailure(state, account.name);
-                const next = accounts.find((a) => !attemptedAccounts.has(a.name) && (!state.authFailures[a.name] || state.authFailures[a.name] <= Date.now()));
+                const available = accounts.filter((candidate) => !attemptedAccounts.has(candidate.name) && (!state.authFailures[candidate.name] || state.authFailures[candidate.name] <= Date.now()));
+                const next = available.length > 0 ? selectAccount(available, state, model).account : undefined;
                 if (next) {
                   attemptedAccounts.add("__retried__");
                   account = next;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oc-auth-switcher",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "OpenCode auth plugin for multi-account Anthropic Claude Max rotation with automatic failover.",
   "type": "module",
   "main": "dist/index.js",