@s-berdia/opencode-router 1.1.1 → 1.2.0

package/dist/index.js

@@ -1069,6 +1069,7 @@ function loadCatalog(file = catalogCacheFile()) {
 
 // src/scoring.ts
 var FIVE_HOUR_SHARE = 0.2;
+var WEEK_SHARE = 0.5;
 var FREE_ROLE_BONUS = 6;
 var DEFAULT_UNVETTED_PENALTY = 8;
 function modelClass(model) {
@@ -1581,6 +1582,13 @@ function rankRole(catalog, roleName, table, cfg, feeds) {
       chosen.push(entry);
     }
   }
+  if (cfg.plan !== "free" && !chosen.some((entry) => entry.model.free)) {
+    const free = scored.find((entry) => entry.model.free);
+    if (free) {
+      if (chosen.length >= depth && chosen.length > 1) chosen.pop();
+      chosen.push(free);
+    }
+  }
   return chosen.map((entry, index) => ({
     rank: index + 1,
     providerID: entry.model.providerID,
@@ -1642,13 +1650,22 @@ async function buildRoutingTable(opts = {}) {
   };
   return { table, cfg, scoreTable, catalog };
 }
-function pickForRole(table, role, isHealthy) {
+function pickForRole(table, role, isUsable) {
   const chain = table.active[role];
   if (!chain || chain.length === 0) return void 0;
-  return chain.find((entry) => isHealthy(entry.id)) ?? chain[0];
+  return chain.find(isUsable) ?? chain[0];
 }
 function healthCheck(result, ledger) {
-  return (modelId) => ledger.isHealthy(modelId, monthlyCapFor(modelId, result.scoreTable, result.cfg.plan), result.cfg.softThreshold);
+  const allowanceOk = ledger.allowanceAvailable(result.cfg.softThreshold);
+  return (entry) => !ledger.inCooldown(entry.id) && (allowanceOk || entry.class !== "subscription");
+}
+function usesAllowance(result, modelId) {
+  const cap = monthlyCapFor(modelId, result.scoreTable, result.cfg.plan);
+  return cap !== null && cap > 0;
+}
+function allowanceShare(result, modelId, costUSD) {
+  const cap = monthlyCapFor(modelId, result.scoreTable, result.cfg.plan);
+  return cap !== null && cap > 0 ? costUSD / cap : 0;
 }
 
 // src/ledger.ts
@@ -1658,7 +1675,6 @@ var DAY = 24 * HOUR;
 var WINDOW_5H = 5 * HOUR;
 var WINDOW_WEEK = 7 * DAY;
 var WINDOW_MONTH = 30 * DAY;
-var MONTHLY_LIMIT = 0.95;
 function emptyState(now) {
   return {
     cost5h: 0,
@@ -1741,7 +1757,8 @@ var LedgerStore = class {
     }
     return this.roll(entry, now);
   }
-  record(modelId, costUSD, tokens) {
+  /** `allowanceShare`: the cost divided by the model's monthly limit; 0 for a model outside the Go allowance. */
+  record(modelId, costUSD, tokens, allowanceShare2 = 0) {
     const state = this.state(modelId);
     state.cost5h += costUSD;
     state.costWeek += costUSD;
@@ -1750,8 +1767,23 @@ var LedgerStore = class {
     state.tokensWeek += tokens;
     state.tokensMonth += tokens;
     state.lastUsedAt = this.now();
+    if (allowanceShare2 > 0) this.addShare(allowanceShare2);
     this.save();
   }
+  /** Call after sync() or state(), never before: a reload would drop changes to the old data. */
+  sharedAllowance() {
+    if (!this.data.allowance || !Array.isArray(this.data.allowance.buckets)) this.data.allowance = { buckets: [] };
+    return this.data.allowance;
+  }
+  addShare(share) {
+    const allowance = this.sharedAllowance();
+    const now = this.now();
+    const hour = Math.floor(now / HOUR) * HOUR;
+    allowance.buckets = allowance.buckets.filter(([start]) => start + HOUR > now - WINDOW_MONTH);
+    const bucket = allowance.buckets.find(([start]) => start === hour);
+    if (bucket) bucket[1] += share;
+    else allowance.buckets.push([hour, share]);
+  }
   cooldown(modelId, durationMs, reason) {
     const state = this.state(modelId);
     state.cooldownUntil = this.now() + durationMs;
@@ -1763,15 +1795,46 @@ var LedgerStore = class {
     state.cooldownUntil = void 0;
     this.save();
   }
-  usage(modelId, monthlyCapUSD) {
-    return usageOf(this.state(modelId), monthlyCapUSD);
+  inCooldown(modelId) {
+    const until = this.state(modelId).cooldownUntil;
+    return until !== void 0 && this.now() < until;
   }
-  /** Healthy = not cooling down, under the soft threshold for 5 hours, and under the monthly limit. */
-  isHealthy(modelId, monthlyCapUSD, softThreshold) {
+  /** After a usage-limit error: every model that uses the shared allowance is limited. */
+  cooldownAllowance(durationMs, reason) {
+    this.sync();
+    const allowance = this.sharedAllowance();
+    allowance.cooldownUntil = this.now() + durationMs;
+    if (reason) allowance.lastError = reason;
+    this.save();
+  }
+  usage(modelId) {
     const state = this.state(modelId);
-    if (state.cooldownUntil && this.now() < state.cooldownUntil) return false;
-    const u = usageOf(state, monthlyCapUSD);
-    return u.pct5h < softThreshold && u.pctMonth < MONTHLY_LIMIT;
+    return {
+      cost5h: state.cost5h,
+      costMonth: state.costMonth,
+      tokens5h: state.tokens5h,
+      tokensMonth: state.tokensMonth,
+      cooldownUntil: state.cooldownUntil ?? null
+    };
+  }
+  /** Rolling use of the shared allowance in the last 5 hours, 7 days, and 30 days. */
+  allowance() {
+    this.sync();
+    const allowance = this.sharedAllowance();
+    const now = this.now();
+    const cooldownUntil = allowance.cooldownUntil !== void 0 && now < allowance.cooldownUntil ? allowance.cooldownUntil : null;
+    return {
+      pct5h: windowShare(allowance.buckets, now, WINDOW_5H) / FIVE_HOUR_SHARE,
+      pctWeek: windowShare(allowance.buckets, now, WINDOW_WEEK) / WEEK_SHARE,
+      pctMonth: windowShare(allowance.buckets, now, WINDOW_MONTH),
+      cooldownUntil,
+      cooldownReason: cooldownUntil === null ? null : allowance.lastError ?? null
+    };
+  }
+  /** True when no window has reached `softThreshold` and no usage-limit cooldown is active. */
+  allowanceAvailable(softThreshold) {
+    const u = this.allowance();
+    return u.cooldownUntil === null && u.pct5h < softThreshold && u.pctWeek < softThreshold && u.pctMonth < softThreshold;
   }
   snapshot() {
     return structuredClone(this.data);
@@ -1782,17 +1845,16 @@ var LedgerStore = class {
     this.loadedMtime = mtimeOf(this.file);
   }
 };
-function usageOf(state, monthlyCapUSD) {
-  const cap5h = monthlyCapUSD === null ? null : monthlyCapUSD * FIVE_HOUR_SHARE;
-  return {
-    cost5h: state.cost5h,
-    costMonth: state.costMonth,
-    tokens5h: state.tokens5h,
-    tokensMonth: state.tokensMonth,
-    pct5h: cap5h === null || cap5h <= 0 ? 0 : state.cost5h / cap5h,
-    pctMonth: monthlyCapUSD === null || monthlyCapUSD <= 0 ? 0 : state.costMonth / monthlyCapUSD,
-    cooldownUntil: state.cooldownUntil ?? null
-  };
+function windowShare(buckets, now, windowMs) {
+  const from = now - windowMs;
+  let sum = 0;
+  for (const [start, share] of buckets) {
+    const end = Math.min(start + HOUR, now);
+    if (end <= from || start > now) continue;
+    const span = end - start;
+    sum += span <= 0 ? share : share * (end - Math.max(start, from)) / span;
+  }
+  return sum;
 }
 
 // src/apply.ts
@@ -1942,14 +2004,21 @@ var TTL_MS = 15e3;
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
+function errorData(error) {
+  if (!error || typeof error !== "object") return { status: 0, message: "" };
+  const data = error.data ?? {};
+  return {
+    status: Number(data.statusCode ?? data.status ?? 0),
+    message: String(data.message ?? data.responseBody ?? "").toLowerCase()
+  };
+}
+function isUsageLimitError(error) {
+  const { status, message } = errorData(error);
+  return status === 402 || /usage limit|limit (?:has been |was )?reached|quota|insufficient|exceeded your/.test(message);
+}
 function isRateLimitError(error) {
-  if (!error || typeof error !== "object") return false;
-  const rec = error;
-  const data = rec.data ?? {};
-  const status = Number(data.statusCode ?? data.status ?? 0);
-  const message = String(data.message ?? data.responseBody ?? "").toLowerCase();
-  if (status === 429 || status === 402) return true;
-  return /rate.?limit|quota|too many requests|insufficient|capacity|overloaded/.test(message);
+  const { status, message } = errorData(error);
+  return status === 429 || isUsageLimitError(error) || /rate.?limit|too many requests|capacity|overloaded/.test(message);
 }
 function isAuthError(error) {
   return typeof error === "object" && error !== null && String(error.name ?? "").includes("ProviderAuthError");
@@ -1985,6 +2054,13 @@ var OpencodeRouter = async (input) => {
       writeApplyMarker({ ok: false, detail: `hot-apply failed: ${errorMessage(error)}` });
     }
   }
+  async function coolDown(modelId, error, reason) {
+    if (isUsageLimitError(error) && usesAllowance(await ensure(), modelId)) {
+      ledger.cooldownAllowance(RATE_LIMIT_COOLDOWN_MS, "Go usage limit");
+    } else if (isRateLimitError(error)) {
+      ledger.cooldown(modelId, RATE_LIMIT_COOLDOWN_MS, reason);
+    }
+  }
   function rememberMessage(id) {
     recordedMessages.add(id);
     if (recordedMessages.size > MAX_TRACKED_MESSAGES) {
@@ -2057,15 +2133,15 @@ var OpencodeRouter = async (input) => {
           const id = `${info.providerID}/${info.modelID}`;
           sessionModels.set(info.sessionID, id);
           const tokens = (info.tokens?.input ?? 0) + (info.tokens?.output ?? 0) + (info.tokens?.cache?.read ?? 0) + (info.tokens?.cache?.write ?? 0);
+          const result = await ensure();
           let cost = info.cost ?? 0;
           if (cost === 0 && tokens > 0) {
-            await ensure();
             const blended = blendedById.get(id) ?? 0;
             if (blended > 0) cost = tokens / 1e6 * blended;
           }
-          ledger.record(id, cost, tokens);
-          if (isRateLimitError(info.error)) ledger.cooldown(id, RATE_LIMIT_COOLDOWN_MS, "rate limit / quota");
-          else if (isAuthError(info.error)) ledger.cooldown(id, AUTH_COOLDOWN_MS, "auth error");
+          ledger.record(id, cost, tokens, allowanceShare(result, id, cost));
+          if (isAuthError(info.error)) ledger.cooldown(id, AUTH_COOLDOWN_MS, "auth error");
+          else await coolDown(id, info.error, "rate limit / quota");
         } else if (event.type === "session.created" && !updateToastShown) {
           updateToastShown = true;
           void pendingUpdate.then((update) => {
@@ -2078,7 +2154,7 @@ var OpencodeRouter = async (input) => {
         } else if (event.type === "session.error") {
           const { sessionID, error } = event.properties;
           const id = sessionID ? sessionModels.get(sessionID) : void 0;
-          if (id && isRateLimitError(error)) ledger.cooldown(id, RATE_LIMIT_COOLDOWN_MS, "session rate limit");
+          if (id) await coolDown(id, error, "session rate limit");
         }
       } catch {
       }