@magpie-community/opencode-cursor-auth 0.1.4 → 0.1.7

package/README.md

@@ -43,8 +43,18 @@ plugin's `fetch` answers them on Cursor's agent API:
   system prompt; the model calls them through Cursor's `CallDynamicTool`,
   and the calls come back as chat completion tool calls. Cursor's own tools
   (shell, file reads, edits) are never run.
+- A conversation's Runs share one `conversation_id`, so Cursor sends them
+  to the machine that has the prompt cached (Grok on Cursor caches by
+  machine). It is made from what names the session — the request's
+  `prompt_cache_key` (Codex's thread id), else the session the
+  `chat.headers` hook is told — and the conversation's first user message,
+  so subagents under one session are conversations of their own. With
+  nothing naming the session, each Run has a new one.
 - Text, thinking (`reasoning_content`) and token usage come back streamed
-  or not. Failures keep their statuses: 401 to sign in again, 429 at the
+  or not. Cursor's `input_tokens` counts the cached prompt too: the cache
+  read and written is taken out of it, and given as `cached_tokens` and
+  `cache_write_tokens`, so it is counted once; its reasoning tokens are
+  `reasoning_tokens`. Failures keep their statuses: 401 to sign in again, 429 at the
   usage limit, 400 for a prompt too long, 403 for a region refusal.
 
 ## Models
@@ -60,6 +70,15 @@ The `config` hook declares `auto` (Cursor's pick). Once signed in, the
   is. `-fast` and `-thinking` models stay models of their own; a
   `service_tier` of `priority` picks the fast one.
 - The context window is 1M for a model whose name says 1M, else 200K.
+- Cursor's model picker (`AiService/AvailableModels`, as the CLI asks for
+  it) adds the models it offers that the usable list leaves out (GLM-5.3,
+  GLM-5.3 Flash), run with the picker variant's parameters; hidden and
+  Tab-only models stay out.
+- A model Cursor serves only in Max Mode (the usable list's `maxMode`, a
+  picker model with no other mode, or a Max Mode variant) is asked for in
+  Max Mode, as the CLI turns it on for one. A model neither says it of is
+  asked again in Max Mode when Cursor answers "Max Mode Required", and so
+  from then on.
 
 ## Not included
 

package/index.mjs

@@ -158,9 +158,10 @@ async function cliTokenNow() {
     await cliRefresh
     tok = await cliToken()
   }
-  if (!tok) throw new AuthError("Cursor isn't signed in: run `cursor-agent login`, or sign in again")
+  // the built-in's words (provider.CursorToken)
+  if (!tok) throw new AuthError("Cursor isn't signed in; sign in from magpie's Providers page or run `cursor-agent login`")
   const e = expiry(tok)
-  if (e && e <= Date.now()) throw new AuthError("Cursor's sign-in has run out: run `cursor-agent login`, or sign in again")
+  if (e && e <= Date.now()) throw new AuthError("Cursor's sign-in has run out; sign in again from magpie's Providers page or run `cursor-agent login`")
   return tok
 }
 
@@ -601,14 +602,19 @@ function modelID(raw, model, effort, fast) {
   return vs[fitEffort(effort, levels)]
 }
 
-// usable is the account's list, as `cursor-agent models` has it: its ids,
-// names and the id each is run by; kept a while, by token.
+// usable is the account's list: what `cursor-agent models` has
+// (GetUsableModels: its ids, names and the id each is run by, and whether
+// Cursor serves it in Max Mode), and the models Cursor's model picker
+// offers that it leaves out (parameterized). Kept a while, by token.
 const lists = new Map()
 async function usable(tok) {
   const h = createHash("sha256").update(tok).digest("hex")
   const had = lists.get(h)
   if (had && Date.now() - had.at < MODELS_KEEP) return had.raw
-  const j = await unary(API, "agent.v1.AgentService/GetUsableModels", tok, {}, 30_000)
+  const [j, picker] = await Promise.all([
+    unary(API, "agent.v1.AgentService/GetUsableModels", tok, {}, 30_000),
+    parameterized(tok),
+  ])
   const raw = []
   for (const m of j?.models ?? []) {
     const id = m.displayModelId || m.modelId
@@ -616,13 +622,88 @@ async function usable(tok) {
     // some names come with zero-width spaces and doubled ones
     let name = String(m.displayName || id).replaceAll("​", "").split(/\s+/).filter(Boolean).join(" ")
     name = name.replace(/\(default\)$/, "").trim().replace(/\(current\)$/, "").trim()
-    raw.push({ id, name, context: contextOf(name), run: m.modelId || id })
+    const run = m.modelId || id
+    // Max Mode as the CLI sends it: the list's own say, else the picker's
+    // (a model with no other mode, or a variant that is Max Mode's)
+    const maxMode = m.maxMode === true || !!(picker.slugs.get(id)?.maxMode || picker.slugs.get(run)?.maxMode)
+    raw.push({ id, name, context: contextOf(name), run, ...(maxMode ? { maxMode } : {}) })
   }
   if (!raw.length) throw new Error("Cursor listed no models")
+  for (const m of picker.extra(raw)) raw.push(m)
   lists.set(h, { at: Date.now(), raw })
   return raw
 }
 
+// left out of the CLI's picker as it leaves them out (model-service.ts)
+const PICKER_SKIP = new Set(["claude-4.5-haiku", "claude-4.5-haiku-thinking", "gemini-2.5-pro", "gemini-2.5-flash"])
+
+// needsMax is whether a variant of a picker's model is run in Max Mode
+// only, as the CLI reads it: a model with no other mode, or a Max Mode
+// variant.
+const needsMax = (m, v) => m?.supportsNonMaxMode === false || v?.isMaxMode === true
+
+// parameterized is Cursor's model picker (AiService/AvailableModels, as
+// the CLI asks for it): each id a model goes by (its name, legacy slugs,
+// each variant's slug) with the model and variant it is, and extra(raw),
+// the picker's models the usable list doesn't have, as entries of it (a
+// model added since, such as GLM-5.3, or one the account hasn't turned
+// on). A picker Cursor can't give is none.
+async function parameterized(tok) {
+  let models = []
+  try {
+    const j = await unary(API, "aiserver.v1.AiService/AvailableModels", tok, { useModelParameters: true, doNotUseMarkdown: true }, 8_000)
+    models = Array.isArray(j?.models) ? j.models : []
+  } catch {}
+  const slugs = new Map()
+  const namesOf = (m) => {
+    const vs = m.variants ?? []
+    return [m.name, m.serverModelName, ...(m.legacySlugs ?? []), ...(m.idAliases ?? []), ...vs.flatMap((v) => [v.legacySlug, v.variantStringRepresentation])].filter(Boolean)
+  }
+  for (const m of models) {
+    const vs = m.variants ?? []
+    for (const v of vs) for (const s of [v.legacySlug, v.variantStringRepresentation]) if (s && !slugs.has(s)) slugs.set(s, { maxMode: needsMax(m, v) })
+    for (const s of [m.name, m.serverModelName, ...(m.legacySlugs ?? [])]) if (s && !slugs.has(s)) slugs.set(s, { maxMode: needsMax(m, defaultVariant(m)) })
+  }
+  const extra = (raw) => {
+    const have = new Set(raw.flatMap((r) => [r.id, r.run]))
+    const out = []
+    for (const m of models) {
+      if (!m?.name || m.isHidden || m.isChatOnly || m.onlySupportsCmdK || m.supportsAgent === false || PICKER_SKIP.has(m.name)) continue
+      if (namesOf(m).some((s) => have.has(s))) continue
+      const title = clean(m.clientDisplayName || m.name)
+      const params = (v) => (v?.parameterValues ?? []).map((p) => ({ id: String(p.id ?? ""), value: String(p.value ?? "") })).filter((p) => p.id)
+      const entry = (id, name, v) => {
+        const maxMode = needsMax(m, v)
+        const limit = (maxMode && m.contextTokenLimitForMaxMode) || m.contextTokenLimit
+        return { id, name, context: limit > 0 ? limit : contextOf(name), run: m.name, params: params(v), ...(maxMode ? { maxMode } : {}) }
+      }
+      const named = (m.variants ?? []).filter((v) => v.legacySlug)
+      if (named.length) {
+        for (const v of named) {
+          if (have.has(v.legacySlug)) continue
+          have.add(v.legacySlug)
+          const label = clean(v.displayNameOutsidePicker || [title, v.displayName].filter(Boolean).join(" "))
+          out.push(entry(v.legacySlug, label, v))
+        }
+      } else if (!have.has(m.name)) {
+        have.add(m.name)
+        out.push(entry(m.name, title, defaultVariant(m)))
+      }
+    }
+    return out
+  }
+  return { slugs, extra }
+}
+
+// defaultVariant is the variant the CLI picks for a model asked for by
+// name: its default without Max Mode, else with it, else the first.
+const defaultVariant = (m) => {
+  const vs = m?.variants ?? []
+  return vs.find((v) => v.isDefaultNonMaxConfig) ?? vs.find((v) => v.isDefaultMaxConfig) ?? vs[0]
+}
+
+const clean = (s) => String(s ?? "").replaceAll("​", "").split(/\s+/).filter(Boolean).join(" ")
+
 function runtimeModel(m) {
   return {
     id: m.id,
@@ -847,21 +928,17 @@ function failure(status, text) {
   return statusOf(status, f.code ?? "", msg)
 }
 
-// signInExpired is a message of a token or session run out; a trial, a
-// plan or a link run out is no lapsed sign-in, and magpie marks the
-// account lapsed on a 401.
-const signInExpired = (low) => low.includes("expired") && /token|session|sign[- ]?in|log[- ]?in|auth|credential/.test(low)
-
 // statusOf is the status and words for Cursor's error of this code and
 // message. A region the team isn't served in says so, not to sign in.
 function statusOf(status, code, msg) {
-  msg ||= statusText(status) || `HTTP ${status}`
+  msg ||= statusText(status)
   const low = msg.toLowerCase()
   // magpie names the provider before the message itself
   const out = (status, message) => ({ status, message })
   if (regional(msg)) return out(403, msg + " — Cursor serves your team only in some regions and turned this request away; signing in again won't change that")
   if (code === "permission_denied") return out(403, msg)
-  if (code === "unauthenticated" || status === 401 || signInExpired(low)) return out(401, msg + " — sign in to Cursor again")
+  if (code === "unauthenticated" || status === 401 || low.includes("expired"))
+    return out(401, msg + " — sign in to Cursor again in magpie")
   if (code === "resource_exhausted" || low.includes("quota") || low.includes("rate limit") || low.includes("usage limit"))
     return out(429, "usage limit reached: " + msg)
   if (low.includes("too long") || low.includes("context length") || low.includes("too many tokens"))
@@ -1023,10 +1100,75 @@ function toolDef(t) {
 
 const env = () => pb().str(1, GOOS).str(2, tmpdir()).str(10, "UTC")
 
+// SESSION carries the session magpie (or OpenCode) names a request's
+// conversation by, from the chat.headers hook to the loader's fetch. It
+// goes no further: nothing of the request's headers is sent to Cursor.
+const SESSION = "x-magpie-cursor-session"
+
+// sessionOf is the session a chat.headers hook is told, "" when it names
+// none. magpie, with no session header from the agent, makes one of the
+// conversation's first user message ("magpie-" and 24 hex digits): that
+// names no session, and is taken as none, as the built-in's
+// nativeSessionOf takes no such header as none.
+function sessionOf(input) {
+  const s = String(input?.sessionID ?? "").trim()
+  if (!s || /^magpie-[0-9a-f]{24}$/.test(s)) return ""
+  return s.slice(0, 128)
+}
+
+// uuidOf is a version 4 UUID made of a hash's first 16 bytes.
+function uuidOf(b) {
+  b = Buffer.from(b.subarray(0, 16))
+  b[6] = (b[6] & 0x0f) | 0x40
+  b[8] = (b[8] & 0x3f) | 0x80
+  const h = b.toString("hex")
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`
+}
+
+// conversationID is the AgentRunRequest's conversation_id for a
+// conversation, as the built-in's cursorConversation makes it (magpie
+// #498): the same on every request of it, so that Cursor's backend keeps
+// sending it to the machine that has its prompt cached — Grok on Cursor
+// caches by machine. Cursor's own client keeps one conversationId per
+// agent session, so it is made from what names the session — the
+// client's prompt_cache_key (Codex's thread id), else the session magpie
+// or OpenCode names — together with the conversation's first user
+// message, which every later request repeats: subagents running at once
+// under one session (Claude Code's Task agents share its session id) are
+// separate conversations to Cursor, as they are to its own client. With
+// nothing naming the session it is "", and each Run gets a new id as
+// before: a first message alone ("hi") would put strangers' conversations
+// under one id.
+function conversationID(chat, session) {
+  const key = (typeof chat?.prompt_cache_key === "string" ? chat.prompt_cache_key.trim() : "") || session || ""
+  if (!key) return ""
+  const msgs = Array.isArray(chat?.messages) ? chat.messages : []
+  const first = msgs.find((m) => m?.role === "user") ?? msgs[0]
+  const sum = createHash("sha256")
+    .update("cursor conversation\0" + key + "\0" + (first === undefined ? "" : JSON.stringify(first)))
+    .digest()
+  return uuidOf(sum)
+}
+
+// usageOf is a TurnEndedUpdate as magpie counts usage, as the built-in's
+// cursorUsage has it (magpie #498). Its input_tokens is the whole prompt,
+// what was read from the cache and written to it included, as Cursor's
+// own client has it (it takes both out to get the prompt's uncached
+// rest); input is that rest, the cache added back for prompt_tokens. Its
+// reasoning_tokens is kept as reasoning.
+function usageOf(uf) {
+  const [inp, cr, cw] = [pbNum(uf, 1), pbNum(uf, 3), pbNum(uf, 4)]
+  return { input: Math.max(inp - cr - cw, 0), output: pbNum(uf, 2), cacheRead: cr, cacheWrite: cw, reasoning: pbNum(uf, 5) }
+}
+
 // buildRun is the Run's first message, an AgentClientMessage with its
 // run_request, and the blobs it names. The conversation state is the
 // messages and one turn, which the server wants there to sample at all.
-function buildRun(msgs, lastUser, tools, model) {
+// conv is the conversation_id (conversationID), a new one when "". The
+// model goes as the CLI sends it: in Max Mode when maxMode is set (Cursor
+// refuses a model it serves only that way otherwise: "Max Mode
+// Required"), with the picker variant's parameters when it has them.
+function buildRun(msgs, lastUser, tools, model, conv = "", { maxMode = false, params = [] } = {}) {
   const blobs = new Map()
   const put = (b) => {
     const id = createHash("sha256").update(b).digest()
@@ -1047,13 +1189,22 @@ function buildRun(msgs, lastUser, tools, model) {
     mcp.bytes(1, d)
   }
   const action = pb().bytes(2, pb().bytes(2, rc)) // resume_action
+  // ModelDetails: model_id, display_model_id, display_name, max_mode (7);
+  // RequestedModel: model_id, max_mode (2), parameters (3)
+  const details = pb().str(1, model).str(3, model).str(4, model)
+  const requested = pb().str(1, model)
+  if (maxMode) {
+    details.varint(7, 1)
+    requested.varint(2, 1)
+  }
+  for (const p of params) requested.bytes(3, pb().str(1, p.id).str(2, p.value))
   const rr = pb()
     .bytes(1, state)
     .bytes(2, action)
-    .bytes(3, pb().str(1, model).str(3, model).str(4, model))
+    .bytes(3, details)
     .bytes(4, mcp)
-    .str(5, randomUUID())
-    .bytes(9, pb().str(1, model))
+    .str(5, conv || randomUUID())
+    .bytes(9, requested)
     .varint(19, 1) // inline images
   return { first: pb().bytes(1, rr).done(), blobs }
 }
@@ -1120,8 +1271,8 @@ function open(base, headers, signal) {
 
 // runOnce is one Run of the chat on the agent API at base: an async
 // iterator of the answer's pieces, or the error it failed with before any.
-async function runOnce({ tok, base, id, tools, conv, signal }) {
-  const { first, blobs } = buildRun(conv.msgs, conv.last, tools, id)
+async function runOnce({ tok, base, id, tools, conv, convID, signal, maxMode, params }) {
+  const { first, blobs } = buildRun(conv.msgs, conv.last, tools, id, convID, { maxMode, params })
   const o = await open(
     base,
     {
@@ -1194,10 +1345,12 @@ async function* decode(stream, { send, blobs, tools, estimate }) {
   let calls = 0
   let listed = 0
   let said = 0
-  let usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }
+  let usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0 }
   const finish = () => {
     if (!usage.output) usage.output = Math.floor((said + 3) / 4)
-    if (!usage.input) usage.input = estimate
+    // a guess only when Cursor counted nothing: a prompt read whole from
+    // the cache leaves no uncached rest, and is no reason to guess
+    if (!usage.input && !usage.cacheRead && !usage.cacheWrite) usage.input = estimate
     const prompt = usage.input + usage.cacheRead + usage.cacheWrite
     return {
       stop: calls > 0 ? "tool_calls" : "stop",
@@ -1206,6 +1359,7 @@ async function* decode(stream, { send, blobs, tools, estimate }) {
         completion_tokens: usage.output,
         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 } } : {}),
       },
     }
   }
@@ -1244,7 +1398,7 @@ async function* decode(stream, { send, blobs, tools, estimate }) {
                   break
                 }
                 case 14: // turn ended, with what it used
-                  usage = { input: pbNum(uf, 1), output: pbNum(uf, 2), cacheRead: pbNum(uf, 3), cacheWrite: pbNum(uf, 4) }
+                  usage = usageOf(uf)
                   if (calls === 0) {
                     yield finish()
                     return
@@ -1357,15 +1511,36 @@ function exec(msg, tools, send, closeExec) {
 
 // ---- chat completions ------------------------------------------------------------------
 
+// Every answer says X-Magpie-Sign-In: kept. The built-in marked no Cursor
+// account lapsed, not for a 401 nor for any "expired" (a token, a session,
+// a trial), and cleared none on a success or a renewed token.
 const errorResponse = ({ status, message }) =>
   new Response(JSON.stringify({ error: { message, type: "cursor_error", code: status } }), {
     status,
-    headers: { "Content-Type": "application/json" },
+    headers: { "Content-Type": "application/json", "X-Magpie-Sign-In": "kept" },
   })
 
-// answer runs a chat completion on Cursor and answers it as one, streamed
+function kept(res) {
+  if (res.headers.has("X-Magpie-Sign-In")) return res
+  const headers = new Headers(res.headers)
+  headers.set("X-Magpie-Sign-In", "kept")
+  return new Response(res.body, { status: res.status, statusText: res.statusText, headers })
+}
+
+// answer runs a chat completion on Cursor, the account kept (errorResponse).
+const answer = async (auth, chat, signal, session) => kept(await answerOf(auth, chat, signal, session))
+
+// maxOnly are the ids Cursor said it serves in Max Mode only.
+const maxOnly = new Set()
+
+// maxRequired is Cursor's refusal of a model asked for without Max Mode
+// (the CLI's MAX_MODE_REQUIRED): "Max Mode Required: The model "x"
+// requires Max Mode to be enabled. …"
+const maxRequired = (msg) => /max[ _]mode[ _]required|requires max mode/i.test(String(msg ?? ""))
+
+// answerOf runs a chat completion on Cursor and answers it as one, streamed
 // or not.
-async function answer(auth, chat, signal) {
+async function answerOf(auth, chat, signal, session = "") {
   let tok
   try {
     tok = await tokenOf(auth)
@@ -1379,17 +1554,34 @@ async function answer(auth, chat, signal) {
   } catch {}
   const fast = chat.service_tier === "priority" || chat.service_tier === "fast"
   let id = modelID(raw, model, chat.reasoning_effort ?? "", fast)
-  id = raw.find((m) => m.id === id)?.run ?? id
+  const entry = raw.find((m) => m.id === id)
+  id = entry?.run ?? id
   if (id === "auto") id = "default" // Cursor's pick, which its API calls default
+  const params = entry?.params ?? []
+  let maxMode = !!entry?.maxMode || maxOnly.has(id)
   const tools = toolsOf(chat)
   const conv = conversation(chat, tools)
-  const base = await agentURL(tok, false)
-  let r = await runOnce({ tok, base, id, tools, conv, signal })
+  const convID = conversationID(chat, session)
+  let base = await agentURL(tok, false)
+  const once = () => runOnce({ tok, base, id, tools, conv, convID, signal, maxMode, params })
+  let r = await once()
   if (r.error && regional(r.error.message)) {
     // the team moved, or the config was kept from before: once more with
     // what the config says now
     const fresh = await agentURL(tok, true)
-    if (fresh !== base) r = await runOnce({ tok, base: fresh, id, tools, conv, signal })
+    if (fresh !== base) {
+      base = fresh
+      r = await once()
+    }
+  }
+  if (r.error && !maxMode && maxRequired(r.error.message)) {
+    // a model Cursor serves only in Max Mode that neither list said so of:
+    // in Max Mode, as the CLI turns it on for such a model, and so from
+    // now on. An account Max Mode isn't open to is answered as Cursor
+    // answers that.
+    maxMode = true
+    maxOnly.add(id)
+    r = await once()
   }
   if (r.error) return errorResponse(r.error)
   const it = r.events
@@ -1470,7 +1662,8 @@ export async function CursorAuthPlugin() {
             } catch {
               return errorResponse({ status: 400, message: "a request that isn't JSON" })
             }
-            return answer((await getAuth()) ?? auth, chat, init.signal ?? (input instanceof Request ? input.signal : undefined))
+            const session = new Headers(init.headers ?? (input instanceof Request ? input.headers : undefined)).get(SESSION) ?? ""
+            return answer((await getAuth()) ?? auth, chat, init.signal ?? (input instanceof Request ? input.signal : undefined), session)
           },
         }
       },
@@ -1480,18 +1673,28 @@ export async function CursorAuthPlugin() {
         { type: "api", label: "Cursor API key (cursor.com/dashboard → Integrations)" },
       ],
       // magpie's: how much of the plan's included usage is gone (the plan
-      // is the one the sign-in read)
+      // is the one the sign-in read). The built-in's read, clean or not,
+      // neither marked the account nor cleared it.
       async usage(getAuth, provider) {
         let tok
         try {
           tok = await tokenOf(await getAuth())
         } catch (e) {
-          return { error: e.message, windows: [] }
+          return { error: e.message, windows: [], signIn: "kept" }
         }
         const [u, plan] = await Promise.all([usage(tok, Object.keys(provider?.models ?? {})), planOf(tok)])
-        return plan ? { ...u, plan } : u
+        return { ...u, ...(plan ? { plan } : {}), signIn: "kept" }
       },
     },
+    // the session the request is part of, for the conversation_id
+    // (conversationID): magpie and OpenCode name it here, and the loader's
+    // fetch reads it back. Every plugin's hook sees every provider's
+    // requests, so it is put on Cursor's alone.
+    async "chat.headers"(input, output) {
+      if (input?.model?.providerID !== ID && input?.provider?.info?.id !== ID) return
+      const s = sessionOf(input)
+      if (s) output.headers[SESSION] = s
+    },
     async config(config) {
       config.provider ??= {}
       const was = config.provider[ID] ?? {}
@@ -1522,4 +1725,4 @@ export async function CursorAuthPlugin() {
 }
 
 // for tests
-export const _internal = { poolBase, splitID, families, byEffort, offered, modelID, conversation, buildRun, decode, exec, fields, pb, pbValue, pbAny, frame, frames, failure, toolsOf, expiry }
+export const _internal = { usable, maxRequired, conversationID, usageOf, sessionOf, SESSION, errorResponse, kept, poolBase, splitID, families, byEffort, offered, modelID, conversation, buildRun, decode, exec, fields, pb, pbValue, pbAny, frame, frames, failure, toolsOf, expiry }

package/package.json

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