@magpie-community/opencode-zcode-auth 0.1.9 → 0.1.11

package/README.md

@@ -92,6 +92,18 @@ behind an error, so a gift hiccup must not black out a working Coding
 Plan. A gift that goes out of date while requests use it simply stops
 showing.
 
+**Gift plans ZCode holds but has not granted.** ZCode hands out one-off
+trust-build / gift plans (a day's ZCode Trust Build, say) that are not
+on the account until the ZCode app claims them. The plugin reads the
+app's own list of them (`GET /api/v1/zcode-plan/billing/preview`) with
+the card and names them there — "1 to claim · claim it in the ZCode app"
+— set aside, so the line stops nothing and routing, usage caps and the
+menu bar pass it over. The plugin never claims one: the claim needs the
+Aliyun captcha attestation only the app's renderer can make. A preview
+that fails, or lists nothing, adds no line at all, and a card that is an
+error keeps its error. Claim the plan in the ZCode app (open it once);
+the next read shows it as an ordinary gift bucket.
+
 ## Models
 
 The models are the ones ZCode offers for the account's plan. They come
@@ -112,3 +124,9 @@ A gift plan's models appear again as `<model>-Trial` entries, so a
 request can spend the gift's quota on purpose. A trial entry is listed
 while any live bucket serves its model, spent buckets included (a spent
 entry answers 429 rather than vanishing mid-session).
+
+Two plans can give one model (ZCode Trust Build and the Start Plan both
+give GLM-5.3-Flash). The server picks the bucket, so the usage card
+counts the model on its live bucket, the least used, and sets a spent
+sibling aside. A spent sibling never makes the model, or the account,
+look used up while another bucket still has quota.

package/index.mjs

@@ -531,6 +531,30 @@ async function giftOf(s) {
   return out
 }
 
+// claimHint is the card's line for gift plans ZCode is holding for the
+// account but has not put on it: GET /billing/preview lists them, and
+// only the ZCode app claims one — its claim takes the Aliyun captcha
+// attestation the app's own renderer makes, so the plugin reads the list
+// and asks the user to claim it there. A window, set aside (it is no
+// allowance: using it up stops nothing), so the card shows it and
+// routing, caps and the menu bar pass it over. null when there is
+// nothing to claim, the preview failing or listing none among it: a
+// failed read is no line at all, never a card or a refusal of its own.
+async function claimHint(s) {
+  if (!s.jwt || jwtExpired(s.jwt)) return null
+  let d
+  try {
+    d = await call("GET", `${ZCODE}/api/v1/zcode-plan/billing/preview?app_version=${APP_VERSION}&platform=${platform()}`, { auth: "Bearer " + s.jwt, device: s.device })
+  } catch {
+    return null
+  }
+  const plans = (Array.isArray(d?.plans) ? d.plans : []).filter((p) => typeof p?.plan_id === "string" && p.plan_id.trim())
+  if (!plans.length) return null
+  const n = plans.length
+  const name = first(...plans.map((p) => (typeof p?.name === "string" ? p.name : "")), "ZCode gift plan")
+  return { name, used: 0, aside: true, display: `${n} to claim · claim ${n === 1 ? "it" : "them"} in the ZCode app` }
+}
+
 // startUsage is a gift-only account's card: its buckets, or the words
 // for having none to show. The card's header already names the plan, so
 // the windows keep their own names.
@@ -538,14 +562,38 @@ const NO_START = "this account has no GLM Coding Plan, and ZCode's Start Plan ha
 async function startUsage(s) {
   const g = await giftOf(s)
   if (!g) return { error: NO_START }
-  for (const w of g.windows) {
-    if (w.models?.length) w.models = [...w.models, ...w.models.map(giftID)]
-    delete w._plan
-    delete w._spent
-  }
+  const best = bestBuckets(g.windows)
+  g.windows = g.windows.map(({ _plan, _spent, ...w }, i) => {
+    if (!w.models?.length) return w
+    // a model two plans give (Trust Build's and the Start Plan's Flash)
+    // counts on the bucket ZCode spends now; the other stays on the card
+    // without holding the model up (ganlerk, Discord)
+    const models = w.models.filter((m) => best.get(m.toLowerCase()) === i)
+    if (!models.length) {
+      delete w.models
+      return { ...w, aside: true }
+    }
+    return { ...w, models: [...models, ...models.map(giftID)] }
+  })
   return g
 }
 
+// bestBuckets is, for each model the gift's buckets serve, the index of
+// the one a request spends: a live one before a spent one, the least
+// used of those. The server picks among an account's buckets itself
+// (ZCode sends no plan with a request), so one spent bucket doesn't stop
+// a model another still has.
+function bestBuckets(windows) {
+  const best = new Map()
+  windows.forEach((w, i) => {
+    for (const m of w.models ?? []) {
+      const key = m.toLowerCase(), old = best.get(key), prev = windows[old]
+      if (old === undefined || (prev._spent && !w._spent) || (prev._spent === w._spent && w.used < prev.used)) best.set(key, i)
+    }
+  })
+  return best
+}
+
 // dualUsage shows both pools but only the pool a request can use counts
 // for its model. Live gift models don't spend the Coding windows; spent
 // or blocked gift buckets stay visible without holding up the Coding Plan.
@@ -571,13 +619,7 @@ async function dualUsage(s) {
       const notModels = gift.allModels.map((m) => giftID(m).toLowerCase())
       if (notModels.length) out.windows = out.windows.map((w) => w.aside ? w : { ...w, notModels })
       // Several buckets may serve one model: one spent sibling cannot block it.
-      const best = new Map()
-      g.windows.forEach((w, i) => {
-        for (const m of w.models ?? []) {
-          const key = m.toLowerCase(), old = best.get(key), prev = g.windows[old]
-          if (old === undefined || (prev._spent && !w._spent) || (prev._spent === w._spent && w.used < prev.used)) best.set(key, i)
-        }
-      })
+      const best = bestBuckets(g.windows)
       out.windows.push(...g.windows.map(({ _plan: p, _spent, ...w }, i) => {
         const selected = gift.allModels.filter((m) => best.get(m.toLowerCase()) === i)
         const models = selected.map(giftID)
@@ -1505,9 +1547,16 @@ export async function ZCodeAuthPlugin({ client }) {
             return saved(await teamUsage(s, key))
           }
           const { start, gift } = await plansOf(s)
-          if (start) return saved(await startUsage(s))
-          if (gift) return saved(await dualUsage(s))
-          return saved(await codingUsage(s))
+          const card = saved(start ? await startUsage(s) : gift ? await dualUsage(s) : await codingUsage(s))
+          // a gift plan ZCode holds for the account but has not put on it:
+          // named on the card, claimed in the ZCode app (its claim needs
+          // the app's captcha attestation, see claimHint). A card that is
+          // an error keeps its error and asks nothing
+          if (!card.error) {
+            const hint = await claimHint(s)
+            if (hint) card.windows = [...(card.windows ?? []), hint]
+          }
+          return card
         } catch (e) {
           return saved({ error: e?.message ?? String(e) })
         }
@@ -1537,4 +1586,4 @@ export async function ZCodeAuthPlugin({ client }) {
 }
 
 // for tests
-export const _internal = { entry, limitWindows, termOf, startUsage, routes, blocked, plansOf, giftOf, dualUsage, spentUp, giftServes, modelOf, teamKeys, ownSignIn, stateOf, dress, PROMPT }
+export const _internal = { entry, limitWindows, termOf, startUsage, routes, blocked, plansOf, giftOf, dualUsage, claimHint, spentUp, giftServes, modelOf, teamKeys, ownSignIn, stateOf, dress, PROMPT }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magpie-community/opencode-zcode-auth",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "OpenCode provider plugin: signs in to Z.ai's or BigModel's (智谱) GLM Coding Plan as ZCode does, including team seats and ZCode's Start Plan",
   "type": "module",
   "main": "./index.mjs",