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

package/README.md

@@ -54,12 +54,44 @@ Before each request, the plugin checks which plan the account is on, and
 asks again every 10 minutes:
 
 - If the key's account has a GLM Coding Plan
-  (`/api/biz/subscription/list`), requests go to that plan.
-- Otherwise they go to the Start Plan.
+  (`/api/biz/subscription/list`), its requests go to that plan. A model
+  the account's gift plans also serve is listed again as
+  `<model>-Trial`; asking that entry spends the gift (see below).
+- Otherwise they go to the gift plans.
 
 Every request carries the key as both `x-api-key` and
 `Authorization: Bearer`.
 
+**The gift's trial entries.** An account with a GLM Coding Plan can
+also hold gift plans from ZCode activities, ones that expire on a fixed
+date. Their allowance would lapse unused if every request went to the
+coding plan, so the plugin reads the gift's balance (per the sign-in's
+session, kept for 10 minutes) and lists every model a live bucket
+serves again as `<model>-Trial`, named in the catalog's spelling
+(GLM-5.3-Flash-Trial). Asking a trial entry sends the model to the
+gift, dressed as ZCode's own; asking the plain model spends the coding
+plan — the choice is the user's. A bucket is judged spent only by its
+`remaining_units` — a missing one is unknown, not spent. A trial entry
+whose bucket is spent or blocked answers 429 without touching the
+coding plan; when the gift answers a trial entry with a quota error
+(code 1113 "Insufficient balance or no resource package", code 1005
+"exceed quota limit", which it can answer inside an HTTP 200) that too
+becomes a 429 and keeps the entry off for a minute. Any other gift
+answer (its 405, its 401, its 5xx) goes on as it came: the user picked
+the gift, so the coding plan is not spent behind their back. Every 429
+counts as spent, Z.ai's 1302/1303 rate limits among them. A stream's
+body is never read or buffered on the way.
+
+## The usage card
+
+An account with both plans shows both allowances: the coding plan's
+windows first, then the gift's buckets, each with its own name, models
+and end. The card's plan and term stay the coding plan's. A gift read
+that fails leaves just the coding card — magpie hides a card's windows
+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.
+
 ## Models
 
 The models are the ones ZCode offers for the account's plan. They come
@@ -75,3 +107,8 @@ minutes. When the config can't be read, the plugin falls back to this list:
 | GLM-5-Turbo | 200K | 64K | none, high |
 
 The Start Plan has all of these except GLM-5.3.
+
+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).

package/index.mjs

@@ -130,48 +130,128 @@ const num = (v) => {
   return typeof n === "number" && Number.isFinite(n) ? n : undefined
 }
 
-// startPlan is the Start Plan the account has now ({name, until}), as
-// ZCode reads its balance: an "active" plan past its end is over.
+// the alias is the catalog spelling of the model plus -trial, so the picker
+// reads GLM-5.3-Trial while the loader strips it back to the raw name
+const giftID = (m) => (MODELS.find((x) => x.id.toLowerCase() === String(m).toLowerCase())?.id ?? m) + "-Trial"
+const uniqueModels = (names) => {
+  const byName = new Map()
+  for (const m of names) if (!byName.has(m.toLowerCase())) byName.set(m.toLowerCase(), m)
+  return [...byName.values()]
+}
+const giftNames = (g) => g?.allModels ?? g?.models ?? []
+const giftModel = (g, id) => giftNames(g).find((m) => giftID(m).toLowerCase() === id.toLowerCase())
+const bucketModels = (x) => (Array.isArray(x.capabilities) ? x.capabilities : [])
+  .map((c) => String(c ?? "").trim()).filter((c) => c.startsWith("model:") || !c.includes(":"))
+  .map((c) => c.replace(/^model:/, "").trim()).filter(Boolean)
+
+// Both the card and the request route use the same test for a spent bucket.
+// Older balances may omit remaining_units but still tell used and total.
+const giftSpent = (x) => {
+  const left = num(x.remaining_units)
+  if (left !== undefined) return left <= 0
+  const total = num(x.total_units), used = num(x.used_units)
+  return total !== undefined && used !== undefined && used >= total
+}
+
+// startPlan is the gift an account can spend now ({models}), as ZCode reads
+// its balance: several plans can be active at once, and a model routes to
+// the gift when any of them has a live bucket serving it — a bucket past
+// its plan's own end, or one whose remaining_units says none, is skipped
+// rather than asked and refused. models are those live buckets' names.
 async function startPlan(jwt, device) {
   if (!jwt) throw new Error("not signed in to ZCode")
   if (jwtExpired(jwt)) throw new Error(EXPIRED)
   const b = (await call("GET", `${ZCODE}/api/v1/zcode-plan/billing/balance?app_version=${APP_VERSION}`, { auth: "Bearer " + jwt, device })) ?? {}
   const now = num(b.server_time) > 0 ? num(b.server_time) : Date.now() / 1000
-  const isStart = (x) => x.includes("start-plan") || x.includes("start plan")
-  for (const p of b.plans ?? []) {
-    if (String(p.status ?? "").trim().toLowerCase() !== "active") continue
-    const end = num(p.ends_at)
-    if (end > 0 && end <= now) continue
-    const id = String(p.plan_id ?? "").trim().toLowerCase()
-    const n = String(p.name ?? "").trim().toLowerCase()
-    if ((id || n) && !isStart(id) && !isStart(n)) continue
-    return { name: first(p.name, "Start Plan"), until: end > 0 ? end * 1000 : 0 }
+  const same = (x, p) => (x.user_plan_id && p.user_plan_id ? x.user_plan_id === p.user_plan_id : String(x.plan_id ?? "") === String(p.plan_id ?? ""))
+  const plans = Array.isArray(b.plans) ? b.plans : []
+  const balances = Array.isArray(b.balances) ? b.balances : []
+  const ms = new Set(), all = new Map()
+  let ttl = 600_000
+  let any = false
+  let name = ""
+  for (const p of plans) {
+    const st = String(p?.status ?? "").trim().toLowerCase()
+    const end = num(p?.ends_at)
+    if (st !== "active" || (end > 0 && end <= now)) continue
+    any = true
+    if (end > 0) ttl = Math.min(ttl, (end - now) * 1000)
+    if (!name) name = String(p?.name ?? "").trim()
+    for (const x of balances) {
+      if (!same(x, p)) continue
+      const exp = num(x.expires_at)
+      if (exp > 0 && exp <= now) continue
+      if (exp > 0) ttl = Math.min(ttl, (exp - now) * 1000)
+      // Spent buckets still declare models; only live ones can spend now.
+      for (const m of bucketModels(x)) {
+        if (!all.has(m.toLowerCase())) all.set(m.toLowerCase(), m)
+        if (!giftSpent(x)) ms.add(m)
+      }
+    }
   }
-  return null
+  return any ? { name: name || "Start Plan", models: [...ms], allModels: [...all.values()], ttl } : null
 }
 
-// onStart says whether an account's requests go to the Start Plan: when it
-// has ZCode's token and no coding plan key, or a key whose account has no
-// coding plan. Asked again after 10 minutes (a minute when unsure).
+// plansOf says where an account's requests go and what more it can spend:
+// {start, gift}. start is what onStart said: an account with no coding plan
+// sends every request to the gift and reads no balance to do it; a team's
+// seat, a sign-in with no ZCode token and a key whose plan-list read found
+// no gift stay on the coding plan. gift is what a coding account also holds:
+// the gift plans ({models}), and its requests spend the gift for a model it
+// serves, until it says it is spent (see blocked). Asked again after 10
+// minutes (a minute when unsure — a plan-list read that failed is retried
+// sooner; a gift read that failed simply leaves gift null until the next
+// ask).
 const routes = new Map()
-async function onStart(s) {
-  if (!s.jwt || isTeam(s)) return false // a team's seat is on the team's plan
-  if (!s.key) return true
+async function plansOf(s) {
+  if (isTeam(s) || !s.jwt) return { start: false, gift: null }
+  if (!s.key) return { start: true, gift: null }
   const id = s.key + "\0" + s.jwt
   const r = routes.get(id)
-  if (r && Date.now() - r.at < r.ttl) return r.start
+  if (r && Date.now() - r.at < r.ttl) return r
   let start = false
+  let gift = null
   let sure = false
   try {
-    start = !(await plan(s))
+    if (!(await plan(s))) start = true
+    else gift = await startPlan(s.jwt, s.device).catch(() => null)
     sure = true
   } catch {
+    // the plan list could not be read: a key account takes the dual route
+    // (start stays false, the gift is kept, a minute's ttl), so a gift
+    // refusal still replays to the coding plan rather than blacking out
     try {
-      if (await startPlan(s.jwt, s.device)) start = sure = true
+      gift = await startPlan(s.jwt, s.device)
+      sure = false
     } catch {}
   }
-  routes.set(id, { start, at: Date.now(), ttl: sure ? 600_000 : 60_000 })
-  return start
+  const out = { start, gift, at: Date.now(), ttl: Math.min(sure ? 600_000 : 60_000, gift?.ttl ?? 600_000) }
+  routes.set(id, out)
+  return out
+}
+
+// blocked remembers the models a gift said it has none left for: a key+jwt+
+// model for a minute, so one turn that is refused does not ask again.
+const blocked = new Map()
+
+// giftServes: the gift's buckets name their models lowercased ("glm-5.3-
+// flash"); what is asked for arrives as the plan lists it ("GLM-5.3-Flash").
+const giftServes = (gift, m) => (gift.models ?? []).some((x) => x.toLowerCase() === m.toLowerCase())
+const giftUsable = (s, gift, m) => !jwtExpired(s.jwt) && giftServes(gift, m) &&
+  Date.now() >= (blocked.get(s.key + "\0" + s.jwt + "\0" + m.toLowerCase()) ?? 0)
+
+// spentUp is the gift saying it has nothing left to spend: its own no-
+// resource-package code 1113, its "exceed quota limit" 1005 — a spent gift
+// can answer a 200 with a JSON body carrying one of those codes. Every 429
+// counts as spent, Z.ai's 1302/1303 rate limits among them.
+function spentUp(text, status) {
+  if (status === 429) return true
+  let b
+  try { b = JSON.parse(text) } catch { return false }
+  if (!b || typeof b !== "object") return false
+  const code = (v) => String(v ?? "")
+  const c1 = code(b.code), c2 = code(b.error?.code)
+  return c1 === "1113" || c1 === "1005" || c2 === "1113" || c2 === "1005"
 }
 
 // ---- keys ------------------------------------------------------------------------
@@ -366,10 +446,12 @@ function startNum(v) {
   return undefined
 }
 
-// startUsage is the Start Plan's allowance: a window for each of its
-// buckets, a model's tokens for the day or for the plan's time. A plan
-// still "active" past its end is over, and its buckets are left out.
-async function startUsage(s) {
+// giftOf reads the balance and returns the gift's card fields: its plans and
+// windows. Several plans can be active at once, so every live plan's buckets
+// show, each keeping its own models and end; the plan and end put on the
+// card (for a gift-only account) are the soonest-ending live plan's. null
+// when there is no live plan to show.
+async function giftOf(s) {
   if (!s.jwt) throw new Error("not signed in to ZCode")
   if (jwtExpired(s.jwt)) throw new Error(EXPIRED)
   const b = (await call("GET", `${ZCODE}/api/v1/zcode-plan/billing/balance?app_version=${APP_VERSION}`, { auth: "Bearer " + s.jwt, device: s.device })) ?? {}
@@ -382,7 +464,7 @@ async function startUsage(s) {
     if (end > 0 && end <= now && p.status.trim().toLowerCase() === "active") p.status = "expired"
     if (p.status.trim().toLowerCase() === "expired") over.add(p.user_plan_id + "\0" + p.plan_id)
   }
-  const same = (x, p) => (x.user_plan_id && p.user_plan_id ? x.user_plan_id === p.user_plan_id : x.plan_id === p.plan_id)
+  const same = (x, p) => (x.user_plan_id && p.user_plan_id ? x.user_plan_id === p.user_plan_id : String(x.plan_id ?? "") === String(p.plan_id ?? ""))
   const balances = (Array.isArray(b.balances) ? b.balances : [])
     .map((x) => ({ ...x, user_plan_id: str(x?.user_plan_id), plan_id: str(x?.plan_id) }))
     .filter((x) => {
@@ -395,32 +477,41 @@ async function startUsage(s) {
       return keep
     })
 
+  // every live plan counts as the gift: no plan-name filter decides it,
+  // the balance says what the session can spend
   let active = null
   for (const p of plans) {
     if (p.status.trim().toLowerCase() !== "active") continue
-    const id = p.plan_id.trim().toLowerCase(), n = str(p.name).trim().toLowerCase()
-    const isStart = (x) => x.includes("start-plan") || x.includes("start plan")
-    if ((id || n) && !isStart(id) && !isStart(n)) continue
     const end = startNum(p.ends_at)
-    active = { name: first(str(p.name), "Start Plan"), until: end > 0 ? new Date(Math.trunc(end) * 1000).toISOString() : "" }
-    break
+    if (end > 0 && end <= now) continue
+    if (active && !(end > 0 && (!startNum(active.end) || end < startNum(active.end)))) continue
+    active = { name: first(str(p.name), "Start Plan"), end, until: end > 0 ? new Date(Math.trunc(end) * 1000).toISOString() : "" }
   }
-  if (!active) return { error: "this account has no GLM Coding Plan, and ZCode's Start Plan has ended or was never started" }
+  if (!active) return null
   const out = { plan: active.name, windows: [] }
   if (active.until) Object.assign(out, { until: active.until, renew: "off" })
+  const live = plans.filter((p) => {
+    if (p.status.trim().toLowerCase() !== "active") return false
+    const end = startNum(p.ends_at)
+    return !(end > 0 && end <= now)
+  })
   for (const x of balances) {
+    const owner = live.find((p) => same(x, p))
+    if (!owner) continue
+    const exp = startNum(x.expires_at)
+    if (exp > 0 && exp <= now) continue // a bucket past its own end is over
     const total = startNum(x.total_units), left = startNum(x.remaining_units)
     let used = startNum(x.used_units)
     if (total === undefined && used === undefined && left === undefined) continue
-    const models = (Array.isArray(x.capabilities) ? x.capabilities : [])
-      .map((c) => String(c ?? "").trim().replace(/^model:/, "").trim()).filter(Boolean)
-    const w = { name: first(str(x.show_name), models.join(", "), "Credits"), used: 0 }
+    const models = bucketModels(x)
+    const base = first(str(x.show_name), models.join(", "), "Credits")
+    const w = { name: base, used: 0, _plan: str(owner.name), _spent: giftSpent(x) }
     if (used === undefined) used = total !== undefined && left !== undefined ? total - left : 0
     if (total > 0) {
       w.used = (100 * used) / total
       w.display = `${compact(used)} / ${compact(total)}`
     }
-    const exp = startNum(x.expires_at)
+    if (w._spent) w.used = Math.max(100, w.used)
     if (exp > 0) w.resetsAt = new Date(Math.trunc(exp) * 1000).toISOString()
     let span = 0
     for (const p of plans) {
@@ -440,6 +531,77 @@ async function startUsage(s) {
   return out
 }
 
+// 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.
+const NO_START = "this account has no GLM Coding Plan, and ZCode's Start Plan has ended or was never started"
+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
+  }
+  return g
+}
+
+// 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.
+// Fresh usage also updates the request cache, so a replenished or spent
+// gift takes effect before its ten-minute route cache expires. A failed
+// gift read leaves the working Coding Plan's card and route alone.
+async function dualUsage(s) {
+  const out = await codingUsage(s)
+  const cached = routes.get(s.key + "\0" + s.jwt)
+  try {
+    const g = await giftOf(s)
+    const gift = g ? { name: g.plan, models: [...new Set(g.windows.filter((w) => !w._spent)
+      .flatMap((w) => w.models ?? []).map((m) => m.toLowerCase()))],
+      allModels: uniqueModels(g.windows.flatMap((w) => w.models ?? [])) } : null
+    if (cached) {
+      cached.gift = gift
+      const ends = g ? [g.until, ...g.windows.map((w) => w.resetsAt)].map((t) => Date.parse(t)).filter(Number.isFinite) : []
+      if (ends.length) cached.ttl = Math.min(cached.ttl, Math.max(0, Math.min(...ends) - cached.at))
+    }
+    if (g) {
+      // the gift's models are its trial entries alone: a plain model stays
+      // on the coding plan, and the user picks the gift by its entry
+      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)
+        }
+      })
+      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)
+        const scoped = models.length ? { ...w, models } : { ...w, aside: true }
+        // the card names a bucket's model as the picker does (GLM-5.3-Flash-Trial);
+        // no plan prefix — the card's section header already says the account
+        let name = w.name
+        for (const m of selected) {
+          const at = name.toLowerCase().indexOf(m.toLowerCase())
+          if (at >= 0) name = name.slice(0, at) + giftID(m) + name.slice(at + m.length)
+        }
+        return { ...scoped, name }
+      }))
+    }
+  } catch {
+    if (cached) {
+      cached.gift = null
+      cached.at = Date.now()
+      cached.ttl = 60_000 // an uncertain gift is read again sooner
+    }
+  }
+  return out
+}
+
 // periodOf reads an entitlement's period: "daily", "weekly", "monthly".
 function periodOf(p) {
   p = p.toLowerCase()
@@ -989,6 +1151,26 @@ const entry = (m) => ({
 })
 
 // model is a model as OpenCode's provider hands it to provider.models.
+// modelOf reads the model a Messages body asks for.
+function modelOf(text) {
+  try {
+    const m = JSON.parse(text)?.model
+    return typeof m === "string" ? m : ""
+  } catch {
+    return ""
+  }
+}
+
+// kept passes a response on as it came, the account kept: the built-in
+// never marked a ZCode account lapsed nor cleared one.
+function kept(res, text) {
+  const h = new Headers(res.headers)
+  h.delete("content-length")
+  h.delete("content-encoding")
+  h.set("X-Magpie-Sign-In", "kept")
+  return new Response(text !== undefined ? text : res.body, { status: res.status, statusText: res.statusText, headers: h })
+}
+
 function model(m, url) {
   const e = entry(m)
   return {
@@ -1168,15 +1350,24 @@ export async function ZCodeAuthPlugin({ client }) {
       async models(provider, { auth } = {}) {
         const s = stateOf(auth)
         if (!s) return provider.models
-        const start = await onStart(s).catch(() => false)
+        const { start, gift: known } = await plansOf(s).catch(() => ({ start: false, gift: null }))
+        const gift = start ? await startPlan(s.jwt, s.device).catch(() => null) : known
         const base = start ? START_BASE : s.base
-        let ms = modelsOf(await zcodeConfig().catch(() => null), planID(base))
+        const cfg = await zcodeConfig().catch(() => null)
+        let ms = modelsOf(cfg, planID(base))
         // ZCode's config can't be had: its table stands in, and magpie keeps
         // the list it was told last, as the built-in keeps the one it fetched last
         const fell = !ms.length
         if (fell) ms = start ? START_MODELS : MODELS
         const url = s.base + "/v1"
         const out = Object.fromEntries(ms.map((m) => [m.id, model(m, url)]))
+        const details = [...ms, ...modelsOf(cfg, planID(START_BASE)), ...START_MODELS]
+        for (const raw of giftNames(gift)) {
+          const id = giftID(raw)
+          if (out[id]) continue
+          const m = details.find((m) => m.id.toLowerCase() === raw.toLowerCase()) ?? { efforts: [] }
+          out[id] = model({ ...m, id }, url)
+        }
         if (fell) out[Symbol.for("magpie.fellBack")] = true
         return out
       },
@@ -1196,14 +1387,8 @@ export async function ZCodeAuthPlugin({ client }) {
             if (!s) throw new Error("not signed in to ZCode")
             let url = input instanceof Request ? input.url : String(input)
             const opts = input instanceof Request ? { method: input.method, headers: input.headers, body: input.body, signal: input.signal, duplex: "half", ...init } : { ...init }
-            const start = await onStart(s)
-            // the request goes to the plan the account is on, wherever it was made for
-            for (const b of [START_BASE, ZAI_BASE, BIGMODEL_BASE]) {
-              if (url.startsWith(b)) {
-                url = (start ? START_BASE : s.base) + url.slice(b.length)
-                break
-              }
-            }
+            const { start: alone, gift: known } = await plansOf(s)
+            let gift = known
             let key = s.key
             if (isTeam(s) && !key) {
               key = await teamKey(s)
@@ -1212,32 +1397,79 @@ export async function ZCodeAuthPlugin({ client }) {
                 await client?.auth?.set?.({ path: { id }, body: next }).catch?.(() => {})
               }
             }
-            const h = new Headers(opts.headers)
+            // a dual account's body is read ahead of sending, so a gift that
+            // says it is spent can spend nothing and replay what was asked for
+            let start = alone
+            let orig, forcedGift = false
+            if (opts.body != null) {
+              orig = opts.body = typeof opts.body === "string" ? opts.body : await new Response(opts.body).text()
+              delete opts.duplex
+              let m = modelOf(orig)
+              if (m.toLowerCase().endsWith("-trial")) {
+                gift ??= await startPlan(s.jwt, s.device).catch(() => null)
+                const raw = giftModel(gift, m)
+                const available = raw && giftUsable(s, gift, raw)
+                if (!available) {
+                  const error = { type: raw ? "rate_limit_error" : "invalid_request_error", message: raw ? `ZCode's limited quota for ${raw} is exhausted or temporarily unavailable` : `ZCode has no active limited quota for ${m}` }
+                  return kept(new Response(JSON.stringify({ type: "error", error }), { status: raw ? 429 : 400, headers: { "content-type": "application/json" } }))
+                }
+                orig = opts.body = JSON.stringify({ ...JSON.parse(orig), model: raw })
+                m = raw
+                forcedGift = true
+              }
+              start = alone || forcedGift
+            }
+            const swap = (base) => {
+              for (const b of [START_BASE, ZAI_BASE, BIGMODEL_BASE]) {
+                if (url.startsWith(b)) {
+                  url = base + url.slice(b.length)
+                  break
+                }
+              }
+            }
+            let h = new Headers(opts.headers)
             if (start) {
               if (jwtExpired(s.jwt)) throw new Error(EXPIRED)
               if (!s.jwt) throw new Error("ZCode's sign-in has no key; sign in again")
+              swap(START_BASE)
               // the Start Plan is served only to what looks like ZCode's own request
               startHeaders(h, s.jwt)
               if (opts.body != null) {
-                const text = typeof opts.body === "string" ? opts.body : await new Response(opts.body).text()
+                const text = orig ?? (typeof opts.body === "string" ? opts.body : await new Response(opts.body).text())
                 opts.body = dress(text, s.site, s.device)
                 delete opts.duplex
                 h.delete("content-length")
               }
             } else {
               if (!key) throw new Error("ZCode's sign-in has no key; sign in again")
+              swap(s.base)
               h.delete("authorization")
               h.set("x-api-key", key)
               h.set("Authorization", "Bearer " + key)
             }
-            const res = await fetch(url, { ...opts, headers: h })
+            let res = await fetch(url, { ...opts, headers: h })
+            // a trial entry's gift answer that can't serve the request is
+            // the agent's answer, not the coding plan's: the user picked the
+            // gift, so a spent bucket says 429 (its quota error inside a 200
+            // among them) and anything else goes on as it came. A quota
+            // answer keeps that model off the gift for a minute, so a rate
+            // limit is not knocked twice. A stream's body is never read here.
+            if (start && forcedGift) {
+              const json = (res.headers.get("content-type") ?? "").includes("application/json")
+              if (res.status >= 400 || json) {
+                const text = await res.text()
+                const spent = spentUp(text, res.status)
+                if (!spent && res.status < 400) return kept(res, text)
+                if (spent) {
+                  for (const [k, until] of blocked) if (Date.now() >= until) blocked.delete(k)
+                  blocked.set(s.key + "\0" + s.jwt + "\0" + modelOf(orig).toLowerCase(), Date.now() + 60_000)
+                }
+                return spent && res.status < 400 ? kept(new Response(text, { status: 429, headers: res.headers })) : kept(res, text)
+              }
+            }
             // the plan's answer goes on as it came, the account kept: the
             // built-in never marked a ZCode account lapsed nor cleared one
-            const kept = new Headers(res.headers)
-            kept.delete("content-length")
-            kept.delete("content-encoding")
-            kept.set("X-Magpie-Sign-In", "kept")
-            return new Response(res.body, { status: res.status, statusText: res.statusText, headers: kept })
+            return kept(res)
           },
         }
       },
@@ -1254,6 +1486,9 @@ export async function ZCodeAuthPlugin({ client }) {
         const saved = (out) => {
           const plan = s.plan || auth?.plan
           if (plan && !out.plan) out.plan = plan
+          // MCP reads as a footnote: its window goes last on the card
+          if (Array.isArray(out.windows) && out.windows.some((w) => w.name === "MCP · Month"))
+            out.windows = [...out.windows.filter((w) => w.name !== "MCP · Month"), ...out.windows.filter((w) => w.name === "MCP · Month")]
           out.signIn = "kept"
           return out
         }
@@ -1269,7 +1504,9 @@ export async function ZCodeAuthPlugin({ client }) {
             }
             return saved(await teamUsage(s, key))
           }
-          if (await onStart(s)) return saved(await startUsage(s))
+          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))
         } catch (e) {
           return saved({ error: e?.message ?? String(e) })
@@ -1300,4 +1537,4 @@ export async function ZCodeAuthPlugin({ client }) {
 }
 
 // for tests
-export const _internal = { entry, limitWindows, termOf, startUsage, routes, teamKeys, ownSignIn, stateOf, dress, PROMPT }
+export const _internal = { entry, limitWindows, termOf, startUsage, routes, blocked, plansOf, giftOf, dualUsage, spentUp, giftServes, modelOf, teamKeys, ownSignIn, stateOf, dress, PROMPT }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magpie-community/opencode-zcode-auth",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "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",