@magpie-community/opencode-cursor-auth 0.2.30 → 0.2.32

package/README.md

@@ -240,6 +240,11 @@ go without the list for 5 minutes instead of each waiting for it again.
 ## Usage
 
 magpie shows Cursor Models, Other Models and Total for the billing period.
+A plan of Cursor's merged billing (`GetPlanInfo`'s `isMerged`, the newer
+plans) has no Other Models pool: its included usage is one allowance every
+model draws on, as the dashboard's "Weekly usage limit" shows it. magpie
+shows that as one window, Weekly (Monthly on a monthly plan), for every
+model.
 Accounts with a Grok Bot allowance also show its usage and reset time;
 active trials are labelled separately. A spent Bot allowance doesn't stop
 Cursor requests.
@@ -265,6 +270,21 @@ reaching its included allowance doesn't count the account as used up.
 On-demand also shows the team's spend when known, with its limit when it
 has one. A reached on-demand limit counts the account as used up.
 
+### Included usage only (optional)
+
+In magpie, open the Cursor provider, turn on **Included usage only** under
+**Plugin options**, and save (or set `"pluginOptions": {"cursor":
+{"included_only": true}}` in magpie's settings.json). It is off by default,
+applies to every Cursor account, and takes effect at each account's next
+usage reading.
+
+When on, Cursor Models and Other Models (a merged plan's Weekly, an
+Enterprise account's allowance) are what keep an account in routing: once one is used up, magpie moves its
+models to the next account until the period resets, even when on-demand
+could still pay for them. On-demand and Total are still shown but never
+keep an account in routing. Use it when on-demand is a shared or paid pool
+you don't want spent. When off, on-demand works as described above.
+
 Sign in to the Cursor account linked in Grok Bot. A linked SuperGrok
 subscription grants Bot access without a paid Cursor plan; see
 [Grok Bot plans and billing](https://cursor.com/help/grok-bot/plans).

package/index.mjs

@@ -316,18 +316,27 @@ async function whoIs(tok) {
 
 // plans are the plan each token's account is on, as `cursor-agent about`
 // names it (GetPlanInfo's planName, magpie's card title), asked again after
-// an hour.
+// an hour. merged is GetPlanInfo's isMerged: a plan of Cursor's merged
+// (xAI) billing, whose included usage is one allowance for every model,
+// most of them a week long (includedUsagePeriod), and has no Other Models
+// pool (majiang_ai on X). The dashboard's usage page shows such a plan one
+// meter, the period's totalPercentUsed. period is "weekly", "monthly" or
+// "" (not said). A reply that couldn't be read keeps the last one, else
+// says nothing: undefined merged, which the pools are kept for.
 const plans = new Map()
 const PLAN_TTL = 3600_000
+const PERIODS = { INCLUDED_USAGE_PERIOD_WEEKLY: "weekly", INCLUDED_USAGE_PERIOD_MONTHLY: "monthly", 1: "monthly", 2: "weekly" }
 async function planOf(tok) {
   const had = plans.get(tok)
-  if (had && Date.now() - had.at < PLAN_TTL) return had.plan
+  if (had && Date.now() - had.at < PLAN_TTL) return had
   try {
-    const plan = String((await unary(API, "aiserver.v1.DashboardService/GetPlanInfo", tok))?.planInfo?.planName ?? "").trim()
-    if (plan) plans.set(tok, { plan, at: Date.now() })
-    return plan || had?.plan || ""
+    const info = await unary(API, "aiserver.v1.DashboardService/GetPlanInfo", tok)
+    const plan = String(info?.planInfo?.planName ?? "").trim()
+    const got = { plan: plan || had?.plan || "", merged: info?.isMerged === true, period: PERIODS[info?.planInfo?.includedUsagePeriod] ?? "", at: Date.now() }
+    if (plan || got.merged) plans.set(tok, got)
+    return got
   } catch {
-    return had?.plan ?? ""
+    return had ?? { plan: "" }
   }
 }
 
@@ -532,13 +541,21 @@ async function hardLimit(tok) {
 // dollars, thousands grouped: a team's pool runs to six figures ($451,200.00)
 const dollars = (n) => "$" + n.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })
 
+// INCLUDED_ONLY is the switch (magpie's plugin options, off by default)
+// that keeps an account in routing only while its included usage lasts
+// (magpie-community/plugins#485): on, the included pools (Cursor Models and
+// Other Models; an Enterprise account's allowance) are what stops it, and
+// On-demand and Total are shown only, a budget with room or none at all
+// keeping nothing in routing. Off, on-demand that can still pay keeps it.
+const INCLUDED_ONLY = "included_only"
+
 // enterpriseUsage is the allowance GetCurrentPeriodUsage leaves out on an
 // Enterprise account. That call answers with only the billing cycle there;
 // the website's usage-summary has individualUsage.overall, in cents, and
 // the account's membership. The CLI JWT is also the website's dashboard
 // session, as botUsage builds it. undefined when the summary says nothing
 // this can show, so a failed read stays an empty card, as before.
-async function enterpriseUsage(tok) {
+async function enterpriseUsage(tok, includedOnly = false) {
   try {
     const subject = JSON.parse(Buffer.from(tok.split(".")[1], "base64url").toString()).sub
     if (typeof subject !== "string") return undefined
@@ -569,8 +586,9 @@ async function enterpriseUsage(tok) {
     const unlimited = od?.enabled === true && od.limit === null
     const fixed = od?.enabled === true && typeof od.limit === "number" && Number.isFinite(od.limit) && od.limit > 0 && spent
     // Only an explicitly unlimited budget or a measured budget with room
-    // lets a spent included allowance stay available to magpie's routing.
-    const aside = unlimited || (fixed && od.used < od.limit)
+    // lets a spent included allowance stay available to magpie's routing,
+    // and neither does with INCLUDED_ONLY on.
+    const aside = !includedOnly && (unlimited || (fixed && od.used < od.limit))
     const windows = [{
       name: "Enterprise",
       used: Math.max(0, Math.min(100, (100 * used) / limit)),
@@ -589,6 +607,7 @@ async function enterpriseUsage(tok) {
       limit: od.limit / 100,
       unit: "USD",
       ...resets,
+      ...(includedOnly ? { aside: true } : {}),
     })
     else if (unlimited && spent) windows.push({ name: "On-demand", used: 0, display: dollars(od.used / 100), ...resets, aside: true })
     return windows
@@ -603,9 +622,13 @@ async function enterpriseUsage(tok) {
 // Discord: a team that pays for more) is still served when the pools are
 // spent, so they are shown aside, and its On-demand spend is what can run
 // out: at its limit (a team member with none of their own: the team's
-// pool), or never when it has none. An Enterprise account's period has no
-// planUsage; its allowance comes from usage-summary instead.
-async function usage(tok, ids) {
+// pool), or never when it has none. With includedOnly (INCLUDED_ONLY on)
+// the pools are the allowance whatever on-demand allows, and On-demand is
+// shown only. An Enterprise account's period has no planUsage; its
+// allowance comes from usage-summary instead.
+// plan is planOf's answer, asked alongside (a promise): a merged plan's
+// included usage is one window, Weekly on a weekly plan, for every model.
+async function usage(tok, ids, includedOnly = false, plan = undefined) {
   const [res, hard] = await Promise.all([
     fetch(API + "/aiserver.v1.DashboardService/GetCurrentPeriodUsage", {
       method: "POST",
@@ -620,7 +643,7 @@ async function usage(tok, ids) {
   const u = data?.planUsage
   if (!u) {
     // Prefer measured Enterprise usage before any reset-date-only fallback.
-    const windows = await enterpriseUsage(tok)
+    const windows = await enterpriseUsage(tok, includedOnly)
     return windows ? { windows } : { windows: [] }
   }
   const ms = /^[+-]?\d+$/.test(data.billingCycleEnd ?? "") ? Number(data.billingCycleEnd) : 0
@@ -642,13 +665,26 @@ async function usage(tok, ids) {
   const pool = [...new Set(["auto", ...asked, ...(data.autoBucketModels ?? [])])].filter(inPool)
   const num = (v) => (typeof v === "number" ? v : 0)
   const od = onDemandOf(data, hard)
-  const pooled = od.kind === "fixed" || od.kind === "unlimited" ? { aside: true } : {}
+  const pooled = !includedOnly && (od.kind === "fixed" || od.kind === "unlimited") ? { aside: true } : {}
   const onDemand =
     od.kind === "fixed"
-      ? [{ name: "On-demand", used: Math.max(0, Math.min(100, (100 * od.usedDollars) / od.limitDollars)), display: `${dollars(od.usedDollars)} / ${dollars(od.limitDollars)}` + (od.mineDollars === undefined ? "" : ` (you: ${dollars(od.mineDollars)})`), ...resets }]
+      ? [{ name: "On-demand", used: Math.max(0, Math.min(100, (100 * od.usedDollars) / od.limitDollars)), display: `${dollars(od.usedDollars)} / ${dollars(od.limitDollars)}` + (od.mineDollars === undefined ? "" : ` (you: ${dollars(od.mineDollars)})`), ...resets, ...(includedOnly ? { aside: true } : {}) }]
       : od.kind === "unlimited"
         ? [{ name: "On-demand", used: 0, display: dollars(od.usedDollars), ...resets, aside: true }]
         : []
+  // A merged plan has no pools: its included usage is one allowance every
+  // model draws on, which the dashboard shows as the period's
+  // totalPercentUsed, autoPercentUsed the same and apiPercentUsed 0 always.
+  const info = await plan
+  if (info?.merged === true) {
+    const weekly = info.period === "weekly"
+    return {
+      windows: [
+        { name: weekly ? "Weekly" : info.period === "monthly" ? "Monthly" : "Included", used: num(u.totalPercentUsed), ...resets, ...(weekly ? { span: 604800 } : {}), ...pooled },
+        ...onDemand,
+      ],
+    }
+  }
   // the two pools fit the line; the total goes in its tooltip
   return {
     windows: [
@@ -3172,7 +3208,16 @@ async function answerOf(auth, chat, signal, session = "") {
 
 // ---- the plugin ---------------------------------------------------------------------------
 
-export async function CursorAuthPlugin() {
+export async function CursorAuthPlugin(input) {
+  // includedOnly is the user's INCLUDED_ONLY as magpie has it now, read at
+  // each usage reading so a change needs no restart; false outside magpie
+  const includedOnly = () => {
+    try {
+      return input?.magpie?.option?.(ID, INCLUDED_ONLY) === true
+    } catch {
+      return false
+    }
+  }
   return {
     auth: {
       provider: ID,
@@ -3205,6 +3250,16 @@ export async function CursorAuthPlugin() {
         { type: "oauth", label: "cursor-agent's sign-in", authorize: cliSignIn },
         { type: "api", label: "Cursor API key (cursor.com/dashboard → Integrations)" },
       ],
+      // magpie's own switches (input.magpie.option), read at each usage
+      // reading
+      options: [
+        {
+          key: INCLUDED_ONLY,
+          label: "Included usage only",
+          description:
+            "Keeps an account in routing only while its included usage lasts: once an included pool (Cursor Models, Other Models, a newer plan's Weekly) is used up, magpie moves its models to the next account until it resets, even if on-demand could pay. On-demand and Total never keep an account in routing.",
+        },
+      ],
       // magpie's: how much of the plan's included usage is gone (the plan
       // is the one the sign-in read). The built-in's read, clean or not,
       // neither marked the account nor cleared it.
@@ -3215,7 +3270,8 @@ export async function CursorAuthPlugin() {
         } catch (e) {
           return { error: e.message, windows: [], signIn: "kept" }
         }
-        const [u, plan, bot] = await Promise.all([usage(tok, Object.keys(provider?.models ?? {})), planOf(tok), botUsage(tok)])
+        const info = planOf(tok)
+        const [u, { plan }, bot] = await Promise.all([usage(tok, Object.keys(provider?.models ?? {}), includedOnly(), info), info, botUsage(tok)])
         // Bot goes among magpie's three menu-bar rings: before Total, and
         // before an On-demand with no limit, which is only a dollar figure on
         // a ring that never fills (magpie #2213, Morganwan90). An On-demand

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magpie-community/opencode-cursor-auth",
-  "version": "0.2.30",
+  "version": "0.2.32",
   "description": "Cursor subscriptions (Pro, Pro+, Ultra, Teams) in OpenCode and magpie, through the API cursor-agent talks to",
   "type": "module",
   "main": "./index.mjs",