@magpie-community/opencode-cursor-auth 0.2.9 → 0.2.11

package/README.md

@@ -76,9 +76,13 @@ plugin's `fetch` answers them on Cursor's agent API:
   usage events, by the Run's conversation id: it shows in about 2.5 s,
   and is looked for up to 6 s. Far from Cursor it shows later than that
   (yetone/magpie#1053), so the step says 0 used and the conversation owes
-  it: its next steps collect the event in the background and count it
-  with their own, and a step that ends the turn waits for what is still
-  owed, so the conversation adds up to what Cursor counted. An account
+  it: its next steps collect the event in the background, and a step
+  that ends the turn waits for what is still owed, so the conversation
+  adds up to what Cursor counted. What a step collected of earlier steps
+  is not added to its own count, which a client reads as how full its
+  context is: it is `usage.magpie_deferred` (`prompt_tokens`,
+  `completion_tokens`, `cached_tokens`, `cache_write_tokens`), which
+  magpie bills with the step and clients ignore. An account
   whose events miss the wait 3 steps in a row stops waiting for them.
   With nothing naming the session (so no later step to collect it), or
   an account that can't read its usage events, the step is estimated as
@@ -140,7 +144,10 @@ team or personal spend limit, as `cursor-agent`'s usage view shows it) also
 shows On-demand: its spend, and its limit when it has one. Cursor keeps
 serving such an account past the included usage, so magpie doesn't count
 it used up when Cursor Models or Other Models reach 100%; it does when the
-on-demand spend reaches its limit.
+on-demand spend reaches its limit. A team member with no limit of their
+own spends the team's pool: On-demand shows the pool's spend and limit,
+with the member's own spend beside it, and the account is used up when
+the pool is.
 
 Sign in to the Cursor account linked in Grok Bot. A linked SuperGrok
 subscription grants Bot access without a paid Cursor plan; see

package/index.mjs

@@ -385,7 +385,10 @@ function firstParty(model) {
 // period's spendLimitUsage (cents) and, where that sets no limit of the
 // user's, GetHardLimit's reply (dollars; undefined when it couldn't be
 // read). kind is "fixed" (up to limitDollars), "unlimited", "disabled" or
-// "unavailable" (not known).
+// "unavailable" (not known). A team member with no limit of their own
+// spends the team's pool, which cursor-agent's view calls unlimited but
+// which runs out at pooledLimit for the whole team (magpie #1868): that is
+// a fixed limit on the pool's spend, with the member's own in mineDollars.
 function onDemandOf(data, hard) {
   const s = data?.spendLimitUsage
   const usedDollars = Number(s?.individualUsed ?? 0) / 100
@@ -397,8 +400,11 @@ function onDemandOf(data, hard) {
         : { kind: "disabled", usedDollars }
   if (s?.limitType === "team") {
     if (own) return own
-    if (hard) return hard.noUsageBasedAllowed || !(Number(hard.hardLimit) > 0) ? { kind: "disabled", usedDollars } : { kind: "unlimited", usedDollars }
-    return Number(s.pooledLimit ?? 0) > 0 ? { kind: "unlimited", usedDollars } : { kind: "unavailable", usedDollars }
+    if (hard && (hard.noUsageBasedAllowed || !(Number(hard.hardLimit) > 0))) return { kind: "disabled", usedDollars }
+    // pooledLimit and pooledRemaining come as int64 strings, pooledUsed as a number
+    const pool = Number(s.pooledLimit ?? 0)
+    if (pool > 0) return { kind: "fixed", usedDollars: Number(s.pooledUsed ?? 0) / 100, limitDollars: pool / 100, mineDollars: usedDollars }
+    return hard ? { kind: "unlimited", usedDollars } : { kind: "unavailable", usedDollars }
   }
   if (!hard) return own ?? { kind: "unavailable", usedDollars }
   if (hard.noUsageBasedAllowed) return { kind: "disabled", usedDollars }
@@ -422,7 +428,8 @@ async function hardLimit(tok) {
   }
 }
 
-const dollars = (n) => "$" + n.toFixed(2)
+// 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 })
 
 // usage is the account's windows this billing period; an enterprise plan
 // reports spend instead, and gets none. ids are the models it can be
@@ -430,7 +437,8 @@ const dollars = (n) => "$" + n.toFixed(2)
 // may spend on-demand once its included usage is gone (fottencity on
 // 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, or never when it has none.
+// out: at its limit (a team member with none of their own: the team's
+// pool), or never when it has none.
 async function usage(tok, ids) {
   const [res, hard] = await Promise.all([
     fetch(API + "/aiserver.v1.DashboardService/GetCurrentPeriodUsage", {
@@ -467,7 +475,7 @@ async function usage(tok, ids) {
   const pooled = 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)}`, ...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 }]
       : od.kind === "unlimited"
         ? [{ name: "On-demand", used: 0, display: dollars(od.usedDollars), ...resets, aside: true }]
         : []
@@ -1400,7 +1408,8 @@ function owe(conv, { since = Date.now(), n = 0, ready = Date.now(), carry = null
 
 // usageEvents are the dashboard's events of conversation conv from since
 // on, the `want` oldest not counted yet, summed: usage (null when none),
-// how many were found (got), and refused when the account can't read them.
+// each with its time (events), how many were found (got), and refused
+// when the account can't read them.
 // Polling, they are looked for as STEP_WAIT says, from `first` on, until
 // all show; else asked for once.
 async function usageEvents(tok, conv, since, want, { poll = false, first = STEP_WAIT.first, signal } = {}) {
@@ -1413,6 +1422,7 @@ async function usageEvents(tok, conv, since, want, { poll = false, first = STEP_
   const num = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0)
   let usage = null
   let got = 0
+  const events = []
   if (poll) await wait(first)
   while (!signal?.aborted) {
     try {
@@ -1425,7 +1435,7 @@ async function usageEvents(tok, conv, since, want, { poll = false, first = STEP_
       if (res.status >= 400 && res.status < 500 && res.status !== 429) {
         // not this account's to read
         unreadable.set(tokKey(tok), Date.now())
-        return { usage, got, refused: true }
+        return { usage, events, got, refused: true }
       }
       const evs = res.ok ? ((await res.json())?.usageEventsDisplay ?? []) : []
       const found = evs
@@ -1435,7 +1445,9 @@ async function usageEvents(tok, conv, since, want, { poll = false, first = STEP_
       for (const ev of found) {
         claimed.set(conv + "\0" + ev.timestamp, Date.now())
         const t = ev.tokenUsage
-        usage = addUsage(usage ?? ZERO(), { input: num(t.inputTokens), output: num(t.outputTokens), cacheRead: num(t.cacheReadTokens), cacheWrite: num(t.cacheWriteTokens) })
+        const u = { input: num(t.inputTokens), output: num(t.outputTokens), cacheRead: num(t.cacheReadTokens), cacheWrite: num(t.cacheWriteTokens), reasoning: 0 }
+        usage = addUsage(usage ?? ZERO(), u)
+        events.push({ at: num(ev.timestamp), usage: u })
         got++
       }
       if (got >= want) break
@@ -1443,7 +1455,7 @@ async function usageEvents(tok, conv, since, want, { poll = false, first = STEP_
     if (!poll || Date.now() + STEP_WAIT.every > end) break
     await wait(STEP_WAIT.every)
   }
-  return { usage, got, refused: false }
+  return { usage, events, got, refused: false }
 }
 
 // stepUsage is the usage of the Run of conversation conv started at since,
@@ -1453,22 +1465,24 @@ async function stepUsage(tok, conv, since, signal) {
 }
 
 // collect takes conversation conv's debt and asks for its events (polling
-// when poll): what was carried and what was found (usage), and whether
-// any is still owed (short), which is owed on. What comes back once the
-// Run that asked is over (over() true) is carried to the next instead.
+// when poll): what was carried and what was found (usage), what was
+// carried alone (carry) and the events found (events), and whether any is
+// still owed (short), which is owed on. What comes back once the Run that
+// asked is over (over() true) is carried to the next instead.
 function collect(tok, conv, { poll = false, first, signal, over = () => false } = {}) {
   const d = owed.get(conv)
-  if (!d) return Promise.resolve({ usage: null, short: false })
+  if (!d) return Promise.resolve({ usage: null, carry: null, events: [], short: false })
   owed.delete(conv)
   const p = (async () => {
-    let r = { usage: null, got: 0 }
+    let r = { usage: null, events: [], got: 0 }
     if (d.n > 0 && canRead(tok)) r = await usageEvents(tok, conv, d.since, d.n, { poll, first, signal }).catch(() => r)
     const short = d.n > r.got && canRead(tok)
     if (short) owe(conv, { since: d.since, n: d.n - r.got, ready: d.ready })
+    const carry = d.carry && { ...d.carry }
     const usage = addUsage(d.carry, r.usage)
-    if (!over()) return { usage, short }
+    if (!over()) return { usage, carry, events: r.events ?? [], short }
     owe(conv, { carry: usage })
-    return { usage: null, short }
+    return { usage: null, carry: null, events: [], short }
   })()
   const set = flights.get(conv) ?? new Set()
   flights.set(conv, set.add(p))
@@ -1490,22 +1504,41 @@ function collect(tok, conv, { poll = false, first, signal, over = () => false }
 // read its events). owed(final) is what the Run collected otherwise,
 // all that can be had when final. done() ends the Run: what was collected
 // and not given out goes back.
+//
+// What a Run collects is told apart by its event's time: Cursor stamps a
+// Run's event as the Run begins (1.4–3.4 s after since), so one from since
+// on (less the second usageEvents allows) is this Run's own (mine), and one
+// before it, or a count carried, an earlier Run's (theirs). own() gives out only mine, as the step's usage,
+// which a client reads as how full its context is; theirs goes out by
+// owed(), apart. A Run of its conversation begins only once the one
+// before has ended, so the two never meet; were the time off, the step's
+// count would be told in the wrong field, never twice nor lost.
 function ledger(tok, conv, since, signal, kept) {
   const key = tokKey(tok)
-  let pending = null // collected, not given out yet
+  let mine = null // this Run's own, collected, not given out yet
+  let theirs = null // earlier Runs', collected, not given out yet
   let over = false
   const gather = (opts) =>
     collect(tok, conv, { ...opts, over: () => over }).then((r) => {
-      pending = addUsage(pending, r.usage)
+      theirs = addUsage(theirs, r.carry)
+      for (const e of r.events ?? []) {
+        if (e.at >= since - 1000) mine = addUsage(mine, e.usage)
+        else theirs = addUsage(theirs, e.usage)
+      }
       return r
     })
   let collecting = null
   const debt = kept ? owed.get(conv) : undefined
   const timer = debt ? setTimeout(() => (collecting = gather()), Math.max(0, debt.ready - Date.now())) : null
   timer?.unref?.()
+  const takeMine = () => {
+    const u = mine
+    mine = null
+    return u
+  }
   const take = () => {
-    const u = pending
-    pending = null
+    const u = addUsage(theirs, mine)
+    mine = theirs = null
     return u
   }
   return {
@@ -1526,7 +1559,7 @@ function ledger(tok, conv, since, signal, kept) {
         if (r.short) misses.set(key, m + 1)
         else misses.delete(key)
       } else misses.set(key, m + 1)
-      return take() ?? false
+      return takeMine() ?? false
     },
     async owed(final) {
       if (!kept) return null
@@ -1540,7 +1573,8 @@ function ledger(tok, conv, since, signal, kept) {
     done() {
       over = true
       clearTimeout(timer)
-      if (pending) owe(conv, { carry: take() })
+      const u = take()
+      if (u) owe(conv, { carry: u })
     },
   }
 }
@@ -1910,16 +1944,19 @@ async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage,
   // with it or by a later step (ledger), never guessed
   let counted = false
   // finish is the step's end, with what earlier steps owed (more), which
-  // is no reason not to guess the step's own
+  // is no reason not to guess the step's own. The step's usage is its own
+  // Run's alone: a client reads its prompt_tokens as how full the context
+  // is (pi, OpenCode), and an earlier step's prompt added to it read twice
+  // the context. What earlier steps owed goes apart, as magpie_deferred,
+  // which magpie counts with the step and no client reads.
   const finish = (more) => {
     if (!counted && !usage.output) usage.output = Math.floor((said + 3) / 4)
     // a guess only when Cursor counted nothing: a prompt read whole from
     // the cache leaves no uncached rest, and is no reason to guess; nor is
     // a prompt counted from the events
     if (!counted && !usage.input && !usage.cacheRead && !usage.cacheWrite) usage.input = estimate
-    // the events' output is their steps', counted here as their prompt is
-    if (more) for (const k of ["input", "output", "cacheRead", "cacheWrite"]) usage[k] += more[k]
     const prompt = usage.input + usage.cacheRead + usage.cacheWrite
+    const deferred = more && more.input + more.output + more.cacheRead + more.cacheWrite > 0
     return {
       stop: calls > 0 ? "tool_calls" : "stop",
       usage: {
@@ -1928,6 +1965,16 @@ async function* decode(stream, { send, blobs, tools, estimate, close, stepUsage,
         total_tokens: prompt + usage.output,
         prompt_tokens_details: { cached_tokens: usage.cacheRead, cache_write_tokens: usage.cacheWrite },
         ...(usage.reasoning ? { completion_tokens_details: { reasoning_tokens: usage.reasoning } } : {}),
+        ...(deferred
+          ? {
+              magpie_deferred: {
+                prompt_tokens: more.input + more.cacheRead + more.cacheWrite,
+                completion_tokens: more.output,
+                cached_tokens: more.cacheRead,
+                cache_write_tokens: more.cacheWrite,
+              },
+            }
+          : {}),
       },
     }
   }

package/package.json

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