@magpie-community/opencode-qoder-auth 0.1.1 → 0.1.3

package/index.mjs

@@ -16,6 +16,7 @@
 // from magpie's internal/qoder, which ported it from CLIProxyAPI's qoder
 // support (https://github.com/ufec/CLIProxyAPI, MIT).
 import { createCipheriv, createHash, publicEncrypt, randomBytes, randomUUID, constants } from "node:crypto"
+import { STATUS_CODES } from "node:http"
 
 const ID = "qoder"
 const CLIENT_ID = "732aef47-9cf2-46a2-95fe-4cebb5d0d1fa"
@@ -213,14 +214,24 @@ async function deviceSignIn() {
   }
 }
 
-class SignInGone extends Error {}
+// SignInGone is a sign-in that can't sign a request: a 401. Only Qoder
+// refusing the refresh token marks the account lapsed (expired), as the
+// built-in's qoderRefreshFailed did; no refresh token, or no account,
+// answered 401 there without marking one.
+class SignInGone extends Error {
+  constructor(message, expired = false) {
+    super(message)
+    this.expired = expired
+  }
+}
 
 // refreshJob trades the job token's refresh token for a new pair; the old
 // one is spent.
-async function refreshJob(refresh) {
+async function refreshJob(refresh, user) {
   if (!String(refresh ?? "").trim()) throw new SignInGone("Qoder: the sign-in lapsed; sign in again")
   const r = await openapi("/api/v1/jobToken/refresh", { method: "POST", body: { refresh_token: refresh } })
-  if (r.status === 401 || r.status === 403) throw new SignInGone("Qoder: the sign-in has expired — sign in again")
+  if (r.status === 401 || r.status === 403)
+    throw new SignInGone(`${user}'s Qoder sign-in has expired — sign in again (qoder job token refresh: status ${r.status})`, true)
   if (r.status !== 200) throw new Error(`Qoder job token refresh: status ${r.status}`)
   if (!String(r.json?.token ?? "").trim() || !String(r.json?.refresh_token ?? "").trim())
     throw new Error("Qoder job token refresh: incomplete token pair")
@@ -252,6 +263,15 @@ const MODELS = [
   { id: "mmodel", name: "MiniMax-M3", context: 180_000 },
 ].map((m) => ({ images: true, ...m }))
 
+// freeOf reads whether the listing marks a model free, as Qoder's client
+// reads it (internal/qoder/models.go): is_free true, or a price_factor (the
+// credits a request costs, as a multiple) of 0, either in snake or camel case.
+function freeOf(raw) {
+  const is = raw.is_free ?? raw.isFree
+  const price = raw.price_factor ?? raw.priceFactor
+  return is === true || (typeof price === "number" && price === 0)
+}
+
 // modelInfo reads one entry of the listing's "chat" array: its efforts and
 // default from thinking_config (is_reasoning alone when it has none).
 function modelInfo(raw) {
@@ -265,6 +285,7 @@ function modelInfo(raw) {
     alwaysThinks: false,
     efforts: Array.isArray(raw.reasoning_efforts) ? [...raw.reasoning_efforts] : [],
     defaultEffort: "",
+    free: freeOf(raw),
     config: raw,
   }
   const tc = raw.thinking_config
@@ -331,6 +352,8 @@ function runtimeModel(m) {
     },
     release_date: "",
     variants: Object.fromEntries((m.efforts ?? []).map((e) => [e, { reasoningEffort: e }])),
+    // magpie's own: served at no cost to the plan's credits
+    free: !!m.free,
   }
 }
 
@@ -474,17 +497,26 @@ function failure(status, text) {
   try {
     const j = JSON.parse(text)
     if (j?.message) msg = j.message
-    const d = typeof j?.details === "string" ? JSON.parse(j.details) : null
+    // details is a JSON string, or the object itself (gjson reads either)
+    const d = typeof j?.details === "string" ? JSON.parse(j.details) : j?.details
     if (d?.error?.message) msg += ": " + d.error.message
   } catch {}
-  msg ||= `HTTP ${status}`
-  if (status === 401 || status === 403) return { status: 401, message: "Qoder: the sign-in lapsed — sign in again" }
+  msg ||= STATUS_CODES[status] ?? `HTTP ${status}`
+  // a refused chat is the built-in's 401, which never marked the account
+  // lapsed: only a refused refresh did (errorResponse says kept)
+  if (status === 401 || status === 403) return { status: 401, message: "the sign-in lapsed — sign in again" }
   if (status === 429 || msg.toLowerCase().includes("quota")) return { status: 429, message: "usage limit reached: " + msg }
-  return { status, message: "Qoder: " + msg }
+  return { status, message: msg }
 }
 
-const errorResponse = ({ status, message }) =>
-  new Response(JSON.stringify({ error: { message, type: "qoder_error", code: status } }), { status, headers: { "Content-Type": "application/json" } })
+// errorResponse is a failure as OpenAI's API gives it. signIn is what it
+// means for the account (magpie's X-Magpie-Sign-In): a 401 keeps it unless
+// told expired, since the built-in marked only a refused refresh.
+const errorResponse = ({ status, message, signIn = status === 401 ? "kept" : undefined }) =>
+  new Response(JSON.stringify({ error: { message, type: "qoder_error", code: status } }), {
+    status,
+    headers: { "Content-Type": "application/json", ...(signIn ? { "X-Magpie-Sign-In": signIn } : {}) },
+  })
 
 // ---- the reply ----------------------------------------------------------------
 
@@ -727,6 +759,17 @@ async function bodyText(input, init) {
   return typeof b === "string" ? b : new TextDecoder().decode(b)
 }
 
+// signed is res saying what it means for the sign-in, as the built-in's
+// answer did: a renewed job token cleared the mark whatever came of the
+// request; without one, a success left the mark as it was.
+function signed(res, renewed) {
+  const said = renewed ? "renewed" : res.ok ? "kept" : null
+  if (!said) return res
+  const headers = new Headers(res.headers)
+  headers.set("X-Magpie-Sign-In", said)
+  return new Response(res.body, { status: res.status, statusText: res.statusText, headers })
+}
+
 // ---- usage --------------------------------------------------------------------
 //
 // The account's allowance as magpie's built-in Qoder account shows it
@@ -848,6 +891,9 @@ export async function QoderAuthPlugin({ client }) {
   }
   // each account's listing, the model configs a request carries
   const listings = new Map()
+  // the accounts fresh renewed: the built-in took the lapse mark off on a
+  // renewed job token (qoderPersist), whatever the request then met
+  const renewals = new WeakSet()
 
   // fresh is the account with a live job token, refreshed and saved near
   // its end.
@@ -856,9 +902,10 @@ export async function QoderAuthPlugin({ client }) {
       const a = await getAuth()
       if (a?.type !== "oauth" || !a.access || !a.uid) throw new SignInGone("Qoder: not signed in")
       if (a.expires - Date.now() > REFRESH_LEAD) return a
-      const jt = await refreshJob(a.refresh)
+      const jt = await refreshJob(a.refresh, a.accountId || a.email || a.uid)
       const next = { ...a, access: jt.token, refresh: jt.refresh_token, expires: expiresAt(jt) }
       await client.auth.set({ path: { id: ID }, body: next })
+      renewals.add(next)
       return next
     })
 
@@ -882,10 +929,15 @@ export async function QoderAuthPlugin({ client }) {
       return dt.token
     })
 
-  // usage is the account's allowance, magpie's own hook
+  // usage is the account's allowance, magpie's own hook. signIn is what the read means for the sign-in, as the built-in's did:
+  // a refused job refresh marks it, a renewed one clears it, and nothing
+  // else does — not a clean read, nor a refused device token, which serves
+  // only the account pages
   const usage = async (getAuth) => {
+    let signIn = "kept"
     try {
       const cred = await fresh(getAuth)
+      if (renewals.has(cred)) signIn = "renewed"
       let env
       try {
         env = await fetchUsage(cred.deviceToken)
@@ -893,14 +945,47 @@ export async function QoderAuthPlugin({ client }) {
         if (!(e instanceof UsageStatus) || (e.status !== 401 && e.status !== 403)) throw e
         env = await fetchUsage(await deviceToken(getAuth, cred.deviceToken))
       }
-      return parseUsage(env)
+      return { ...parseUsage(env), signIn }
     } catch (e) {
-      return { error: e?.message ?? String(e) }
+      return { error: e?.message ?? String(e), signIn: e?.expired ? "expired" : signIn }
     }
   }
 
   const signedInError = (e) =>
-    errorResponse(e instanceof SignInGone ? { status: 401, message: e.message } : { status: 502, message: "Qoder: " + (e?.message ?? e) })
+    errorResponse({
+      status: e instanceof SignInGone ? 401 : 502,
+      message: String(e?.message ?? e).replace(/^Qoder: /, ""),
+      signIn: e?.expired ? "expired" : undefined,
+    })
+
+  // ask is the answer to a chat completion on the live account cred.
+  const ask = async (chat, cred, init) => {
+    let m
+    try {
+      m = (await models(cred)).find((x) => x.key === chat.model) ?? (await models(cred, true)).find((x) => x.key === chat.model)
+    } catch (e) {
+      // the built-in answered any failure to read the list 400
+      // (QoderModelOf), a refused one included, marking nothing
+      return errorResponse({ status: 400, message: e.message })
+    }
+    if (!m) return errorResponse({ status: 400, message: `unknown or disabled model "${chat.model}"` })
+    const wire = encodeBody(JSON.stringify(qoderBody(chat, m)))
+    const headers = {
+      ...cosyHeaders(CHAT_URL, cred, wire),
+      Accept: "text/event-stream",
+      "Cache-Control": "no-cache",
+      "X-Model-Key": m.key,
+      "X-Model-Source": m.source,
+    }
+    let res
+    try {
+      res = await fetch(CHAT_URL, { method: "POST", headers, body: wire, signal: init.signal })
+    } catch (e) {
+      return errorResponse({ status: 502, message: e.message })
+    }
+    if (!res.ok) return errorResponse(failure(res.status, (await res.text()).slice(0, 1 << 20)))
+    return answer(res, chat)
+  }
 
   return {
     auth: {
@@ -915,12 +1000,12 @@ export async function QoderAuthPlugin({ client }) {
           async fetch(input, init = {}) {
             const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url
             if (!/\/chat\/completions$/.test(new URL(url).pathname))
-              return errorResponse({ status: 404, message: "Qoder: only chat completions are served" })
+              return errorResponse({ status: 404, message: "only chat completions are served" })
             let chat
             try {
               chat = JSON.parse(await bodyText(input, init))
             } catch {
-              return errorResponse({ status: 400, message: "Qoder: a request that isn't JSON" })
+              return errorResponse({ status: 400, message: "a request that isn't JSON" })
             }
             let cred
             try {
@@ -928,29 +1013,7 @@ export async function QoderAuthPlugin({ client }) {
             } catch (e) {
               return signedInError(e)
             }
-            let m
-            try {
-              m = (await models(cred)).find((x) => x.key === chat.model) ?? (await models(cred, true)).find((x) => x.key === chat.model)
-            } catch (e) {
-              return errorResponse({ status: 502, message: e.message })
-            }
-            if (!m) return errorResponse({ status: 400, message: `Qoder: unknown or disabled model "${chat.model}"` })
-            const wire = encodeBody(JSON.stringify(qoderBody(chat, m)))
-            const headers = {
-              ...cosyHeaders(CHAT_URL, cred, wire),
-              Accept: "text/event-stream",
-              "Cache-Control": "no-cache",
-              "X-Model-Key": m.key,
-              "X-Model-Source": m.source,
-            }
-            let res
-            try {
-              res = await fetch(CHAT_URL, { method: "POST", headers, body: wire, signal: init.signal })
-            } catch (e) {
-              return errorResponse({ status: 502, message: "Qoder: " + e.message })
-            }
-            if (!res.ok) return errorResponse(failure(res.status, (await res.text()).slice(0, 1 << 20)))
-            return answer(res, chat)
+            return signed(await ask(chat, cred, init), renewals.has(cred))
           },
         }
       },
@@ -978,7 +1041,7 @@ export async function QoderAuthPlugin({ client }) {
           const ms = await models(cred, true)
           if (!ms.length) return provider.models
           return Object.fromEntries(
-            ms.map((m) => [m.key, runtimeModel({ id: m.key, name: m.name, context: m.context, images: m.images, efforts: m.thinks ? m.efforts : [] })]),
+            ms.map((m) => [m.key, runtimeModel({ id: m.key, name: m.name, context: m.context, images: m.images, efforts: m.thinks ? m.efforts : [], free: m.free })]),
           )
         } catch {
           return provider.models
@@ -989,4 +1052,4 @@ export async function QoderAuthPlugin({ client }) {
 }
 
 // for tests
-export const _internal = { parseUsage, gfmt, when }
+export const _internal = { parseUsage, gfmt, when, failure, modelInfo }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magpie-community/opencode-qoder-auth",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Qoder subscription in OpenCode and magpie",
   "type": "module",
   "main": "./index.mjs",