@magpie-community/opencode-qoder-auth 0.2.27 → 0.2.30

package/README.md

@@ -139,7 +139,7 @@ itself.
 |---|---|
 | A refused sign-in (no code, or code 105) | 401 |
 | A quota (codes 110, 112–119, 122) | 429 |
-| Busy or queued for the model (code 10605) | 503, with `Retry-After` from Qoder's `retryAfterSeconds` (30s when it gives none); the sign-in is untouched |
+| Busy or queued for the model (code 10605) | Since 0.2.28 the request waits in Qoder's queue as Qoder's client does (below), then is sent again; past the wait, 503 with `Retry-After` from Qoder's `retryAfterSeconds` (30s when it gives none). The sign-in is untouched |
 | A refusal of the request itself (codes 406, 416, 430, 80411, 80412, 100400–100403) | 400, with Qoder's words |
 | "Error in upstream response", the model's own vendor behind Qoder failing, which Qoder sends as a 400 (since 0.2.24) | 502, so magpie asks again or another account; the sign-in is untouched |
 | A failure before the answer starts | Qoder's status |
@@ -285,8 +285,28 @@ the account's credentials.
   international account gets no daily claim until Qoder is installed.
 - A helper that is there but can't be read, or gives an invalid identity,
   is `failed` and asked again later, rather than a false "no activity"
-  result. Qoder CN keeps its existing requests and does not need this
-  local helper.
+  result.
+
+Qoder CN (since 0.2.30) sends its own device identity the same way when
+Qoder CN is installed: its desktop 0.4.9 and CLI (`qoderclicn`) both ask
+Qoder CN's `runtime-info` for environment `0` (the international one is
+`3`) and send it on the campaigns pages (yetone/magpie#2911, #304).
+
+- The plugin finds Qoder CN desktop's `resources/umid` (`Qoder CN.app` on
+  macOS, `%LOCALAPPDATA%\Programs\Qoder CN` or `%ProgramFiles%\Qoder CN`
+  on Windows, `/opt/Qoder-CN` on Linux) or the runtime its CLI caches in
+  `~/.qoder-cn/.bin` (`QODERCN_CONFIG_DIR`, `QODERCN_CLI_HOME` and
+  `QODERCN_CONFIG_DIR_NAME` move it). `QODERCN_RUNTIME_INFO` names
+  another location; `QODER_RUNTIME_INFO` is only the international one's.
+- Without it the requests go out as before, as Qoder CN's desktop does
+  when it can't read the identity, and a claim the list still offers is
+  made. When the list then offers no daily claim, the check-in is
+  `ineligible` for the day with a message to install Qoder CN desktop (or
+  sign in to its CLI); a helper that is there but can't be read makes it
+  `failed`, asked again later.
+- Not tried with a real Qoder CN account: whether Qoder CN now hides the
+  daily claim from a request without the identity, as the international
+  site does, is inferred from its clients, not seen.
 
 - **List:** `GET <openapi>/sash/api/v1/me/campaigns`: `campaigns[]` with
   `campaignId`, `actionType`, `claimStatus` (`CLAIMABLE`, `CLAIMED`),
@@ -319,6 +339,20 @@ That parser fix does not remove the provider's limit or prove that every
 live 401 had the same cause. A timeout likewise does not establish an
 empty wallet or an expired login.
 
+Since **0.2.28** a queued request waits its turn as Qoder's own client
+(Qoder.app 0.4.3's agent worker) waits it: it asks
+`/api/v2/service/ask/queue/status` with the request's `requestSetId`, the
+model and the plan's `queueType`, at once and then every
+`retryAfterSeconds` (held to 0.5–30s, 30s when unsaid), and once
+`isQueued` is false it waits that state's `retryAfterSeconds` and sends the
+same request again (up to 10 times). Qoder's client waits up to an hour;
+the plugin waits at most 4 minutes from the request's start, since nothing
+reaches the agent meanwhile (magpie keeps a stream alive with comments for
+5 minutes of silence). Three failed status asks in a row, a 404, or a
+cancelled request end the wait early. Qoder's client also reports the end
+of its turn to `/api/v2/service/ask/finish`; the plugin doesn't, and
+Qoder releases that lease on its own TTL. `queue.test.mjs` has the wait.
+
 For a bounded offline reproduction, run `packages/qoder/busy.test.mjs`
 from #185 in an isolated temporary HOME. It compares plain queue JSON,
 BOM-prefixed JSON and known message wrappers, keeping explicit login and

package/index.mjs

@@ -956,7 +956,7 @@ function failure(status, text) {
     const model = queue?.modelKey ? ` for ${queue.modelKey}` : ""
     const tier = queue?.queueType ? ` (this plan's queue: ${queue.queueType})` : ""
     const what = queue?.isQueued === true ? "queued the request" : "is busy"
-    return { status: 503, message: `Qoder ${what}${model}${tier}; try again in ${wait}s`, retryAfter: wait, signIn: "" }
+    return { status: 503, message: `Qoder ${what}${model}${tier}; try again in ${wait}s`, retryAfter: wait, signIn: "", queue: queue ?? {} }
   }
   if (QUOTA_CODES.has(code)) return { status: 429, message: "usage limit reached: " + msg, signIn: "" }
   if (REQUEST_CODES.has(code)) return { status: 400, message: `Qoder refused the request (${code}): ${msg}`, signIn: "" }
@@ -987,6 +987,148 @@ const errorResponse = ({ status, message, signIn = status === 401 ? "kept" : und
     },
   })
 
+// ---- Qoder's queue -------------------------------------------------------------
+
+// A chat Qoder answers with its queue code (10605) is waited out as Qoder's
+// own client waits it (qoder-agent-sdk's worker in Qoder.app 0.4.3, its
+// "[ModelQueue]" path): it asks GET /api/v2/service/ask/queue/status with
+// the request's requestSetId, the model and the plan's queueType, at once
+// and then every retryAfterSeconds (held to 0.5s..30s, 30s when unsaid),
+// while the state says isQueued or serviceAvailable false. Once isQueued is
+// false it waits that state's retryAfterSeconds, if any, and sends the same
+// request again, request_set_id and all, up to 10 times. Three failed asks
+// in a row, a 404 (no queue there) or a state with neither field end the
+// wait. Qoder's client waits up to an hour; here the whole of it is held
+// under QUEUE.budget from the request's start, since nothing reaches the
+// agent meanwhile: magpie keeps a stream's agent alive with comments for 5
+// minutes of a vendor's silence, and then leaves it to the agent's own
+// timeout. Past the budget it is the 503 with Retry-After it was before, so
+// magpie may ask another account. Qoder's client also tells
+// /api/v2/service/ask/finish when its turn ends; that is left out, and its
+// own log says Qoder's TTL releases the lease when finish is not heard.
+const QUEUE_STATUS_PATH = "/algo/api/v2/service/ask/queue/status"
+const QUEUE = {
+  budget: 4 * 60 * 1000, // the longest a request is held, its first answer's wait included
+  shortest: 500,
+  longest: 30_000,
+  unsaid: 30_000, // a pause when the queue gives no retryAfterSeconds
+  recoveries: 10, // the queue waited out this many times, at most, for one request
+  failures: 3, // status asks failing in a row that end the wait
+  ask: 30_000, // the longest one status ask may take
+  now: () => Date.now(),
+  pause: (ms, signal) =>
+    new Promise((ok, no) => {
+      if (signal?.aborted) return no(signal.reason ?? new DOMException("aborted", "AbortError"))
+      const t = setTimeout(() => {
+        signal?.removeEventListener("abort", stop)
+        ok()
+      }, ms)
+      const stop = () => {
+        clearTimeout(t)
+        no(signal.reason ?? new DOMException("aborted", "AbortError"))
+      }
+      signal?.addEventListener("abort", stop, { once: true })
+    }),
+}
+
+// queuePause is how long to wait before asking the queue again: the
+// queue's retryAfterSeconds held to 0.5s..30s, or 30s when it said none.
+function queuePause(seconds) {
+  const n = Number(seconds)
+  const ms = Number.isFinite(n) ? n * 1000 : QUEUE.unsaid
+  return Math.min(QUEUE.longest, Math.max(QUEUE.shortest, ms))
+}
+
+class QueueEnd extends Error {}
+
+// queueState is the queue's state in a status reply, found as Qoder's
+// client finds it: the object, or one under data/result/message/body, as
+// an object or a JSON string, that says isQueued or serviceAvailable.
+function queueState(text) {
+  let root
+  try {
+    root = JSON.parse(text)
+  } catch {
+    return undefined
+  }
+  const todo = [root]
+  const seen = new Set()
+  while (todo.length) {
+    const o = todo.shift()
+    if (!o || typeof o !== "object" || Array.isArray(o) || seen.has(o)) continue
+    seen.add(o)
+    const flag = (v) => (typeof v === "boolean" ? v : v === "true" ? true : v === "false" ? false : undefined)
+    const isQueued = flag(o.isQueued)
+    const serviceAvailable = flag(o.serviceAvailable)
+    if (isQueued !== undefined || serviceAvailable !== undefined) {
+      const num = (v) => (v == null || v === "" || !Number.isFinite(Number(v)) ? undefined : Number(v))
+      const str = (v) => (typeof v === "string" && v ? v : undefined)
+      return { isQueued, serviceAvailable, modelKey: str(o.modelKey), queueType: str(o.queueType), retryAfterSeconds: num(o.retryAfterSeconds) }
+    }
+    for (const k of ["data", "result", "message", "body"]) {
+      const v = o[k]
+      if (v && typeof v === "object") todo.push(v)
+      else if (typeof v === "string")
+        try {
+          todo.push(JSON.parse(v))
+        } catch {}
+    }
+  }
+  return undefined
+}
+
+// queueStatus asks Qoder's queue where the request stands.
+async function queueStatus(api, cred, { requestSetId, modelKey, queueType, requestId, sessionId }, signal, deadline) {
+  const q = new URLSearchParams({ requestSetId, modelKey })
+  if (queueType) q.set("queueType", queueType)
+  const url = `${api}${QUEUE_STATUS_PATH}?${q}`
+  const headers = { ...cosyHeaders(url, cred, ""), "X-Request-ID": requestId, "X-Session-ID": sessionId }
+  delete headers["Content-Type"]
+  const left = Math.min(QUEUE.ask, deadline - QUEUE.now())
+  if (left <= 0) throw new QueueEnd("the queue's wait ran out")
+  const res = await fetch(url, { headers, signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(left)]) : AbortSignal.timeout(left) })
+  const text = await res.text()
+  if (res.status === 404) throw new QueueEnd("Qoder has no queue status here")
+  if (!res.ok) throw new Error(`queue status: HTTP ${res.status}`)
+  const st = queueState(text)
+  if (!st) throw new QueueEnd("the queue status said nothing of the queue")
+  return st
+}
+
+// queueWait waits in Qoder's queue for the request, from the state its
+// refusal gave, until the queue lets it through (true) or the wait ends
+// (false). A cancelled request throws.
+async function queueWait(api, cred, ask, first, signal, deadline) {
+  let q = first ?? {}
+  let asked = false
+  let failed = 0
+  for (;;) {
+    if (signal?.aborted) throw signal.reason ?? new DOMException("aborted", "AbortError")
+    if (QUEUE.now() >= deadline) return false
+    if (asked) await QUEUE.pause(Math.min(queuePause(q.retryAfterSeconds), Math.max(0, deadline - QUEUE.now())), signal)
+    asked = true
+    if (QUEUE.now() >= deadline) return false
+    let st
+    try {
+      st = await queueStatus(api, cred, { ...ask, modelKey: q.modelKey ?? ask.modelKey, queueType: q.queueType ?? ask.queueType }, signal, deadline)
+    } catch (e) {
+      if (signal?.aborted) throw signal.reason ?? e
+      if (e instanceof QueueEnd) return false
+      if (++failed >= QUEUE.failures) return false
+      q = { ...q, retryAfterSeconds: undefined }
+      continue
+    }
+    failed = 0
+    q = { ...st, modelKey: st.modelKey ?? q.modelKey, queueType: st.queueType ?? q.queueType }
+    if (st.isQueued === false) {
+      if (st.retryAfterSeconds > 0) await QUEUE.pause(Math.min(queuePause(st.retryAfterSeconds), Math.max(0, deadline - QUEUE.now())), signal)
+      return QUEUE.now() < deadline
+    }
+    if (st.serviceAvailable === false || st.isQueued === true) continue
+    return false
+  }
+}
+
 // ---- the reply ----------------------------------------------------------------
 
 const CALL_OPEN = "\x3ctool_call\x3e"
@@ -1232,11 +1374,17 @@ async function* events(body) {
 // answer turns Qoder's reply into the chat completion OpenAI's API gives.
 // A failure before the answer keeps its status; one after it ends the
 // stream with an error.
-async function answer(res, chat) {
+// opened is a chat reply's events and the first of them, read before
+// anything is answered: a refusal in the stream (Qoder's queue among them)
+// comes first.
+async function opened(res) {
+  const it = events(res.body)
+  return { it, first: await it.next() }
+}
+
+async function answer({ it, first }, chat) {
   const id = "chatcmpl-" + hexID()
   const created = Math.floor(Date.now() / 1000)
-  const it = events(res.body)
-  const first = await it.next()
   if (first.value?.error) return errorResponse(first.value.error)
   if (first.done) return errorResponse({ status: 502, message: "Qoder ended without an answer" })
 
@@ -1378,23 +1526,45 @@ const CAMPAIGN_MACHINE_TTL = 60 * 60 * 1000 // Qoder's desktop client renews its
 //     (or .qoder): a file runtime-info-<platform>-<arch>-<hash> on macOS and
 //     Linux, a folder umid-win32-<arch>-<hash> holding runtime-info.exe on
 //     Windows.
-async function campaignRuntime({ home = homedir(), platform = process.platform, arch = process.arch, env = process.env, opt = "/opt" } = {}) {
-  if (env.QODER_RUNTIME_INFO) return resolve(env.QODER_RUNTIME_INFO)
+//
+// Qoder CN keeps its own (Qoder CN desktop 0.4.9's packages, qoderclicn
+// 1.1.77): Qoder CN.app on macOS (its installer's expectedBundleName),
+// /opt/Qoder-CN on Linux (the .deb), Qoder CN on Windows (the user
+// installer's "Uninstall Qoder CN.exe", electron-builder's
+// Programs\<productName>); its CLI's config is QODERCN_CONFIG_DIR, else
+// QODERCN_CLI_HOME (or home) joined with QODERCN_CONFIG_DIR_NAME (or
+// .qoder-cn). Both ask the helper for environment 0, the international
+// ones for 3 (the desktop's `regionCode === "global" ? 3 : 0`, the CLI's
+// UMID environment ONLINE = 0, US_ONLINE = 3).
+//
+// required: international Qoder lists the daily credits only on a request
+// carrying the identity. Qoder CN's desktop sends it when it can read it
+// and goes on without it when it can't, and a Qoder CN account was offered
+// and claimed the credits without one (0.2.21), so there it is sent when
+// Qoder CN is installed and left out when it isn't.
+const RUNTIMES = {
+  qoder: { name: "Qoder", environment: "3", override: "QODER_RUNTIME_INFO", app: "Qoder", linux: "Qoder", cli: "QODER_", dir: ".qoder", required: true },
+  "qoder-cn": { name: "Qoder CN", environment: "0", override: "QODERCN_RUNTIME_INFO", app: "Qoder CN", linux: "Qoder-CN", cli: "QODERCN_", dir: ".qoder-cn", required: false },
+}
+
+async function campaignRuntime({ home = homedir(), platform = process.platform, arch = process.arch, env = process.env, opt = "/opt", runtime = RUNTIMES.qoder } = {}) {
+  if (env[runtime.override]) return resolve(env[runtime.override])
   const name = platform === "win32" ? "runtime-info.exe" : "runtime-info"
   const isFile = async (path) => (await stat(path).catch(() => null))?.isFile() ?? false
   const paths = []
   if (platform === "win32") {
     const local = env.LOCALAPPDATA || join(home, "AppData", "Local")
-    paths.push(join(local, "Programs", "Qoder", "resources", "umid", name))
+    paths.push(join(local, "Programs", runtime.app, "resources", "umid", name))
     // the machine-wide installer, as VS Code's system setup places it
-    for (const dir of [env.ProgramFiles || env.PROGRAMFILES, env.ProgramW6432]) if (dir) paths.push(join(dir, "Qoder", "resources", "umid", name))
+    for (const dir of [env.ProgramFiles || env.PROGRAMFILES, env.ProgramW6432]) if (dir) paths.push(join(dir, runtime.app, "resources", "umid", name))
   } else if (platform === "darwin") {
-    for (const dir of ["/Applications", join(home, "Applications")]) paths.push(join(dir, "Qoder.app", "Contents", "Resources", "umid", name))
+    for (const dir of ["/Applications", join(home, "Applications")]) paths.push(join(dir, runtime.app + ".app", "Contents", "Resources", "umid", name))
   } else if (platform === "linux") {
-    paths.push(join(opt, "Qoder", "resources", "umid", name))
+    paths.push(join(opt, runtime.linux, "resources", "umid", name))
   }
   for (const path of paths) if (await isFile(path)) return path
-  const config = env.QODER_CONFIG_DIR || join(env.QODER_CLI_HOME || env.GEMINI_CLI_HOME || home, env.QODER_CONFIG_DIR_NAME || ".qoder")
+  const cli = (key) => env[runtime.cli + key]
+  const config = cli("CONFIG_DIR") || join(cli("CLI_HOME") || env.GEMINI_CLI_HOME || home, cli("CONFIG_DIR_NAME") || runtime.dir)
   const cache = join(config, ".bin")
   const entries = await readdir(cache, { withFileTypes: true }).catch(() => [])
   const found = []
@@ -1408,7 +1578,7 @@ async function campaignRuntime({ home = homedir(), platform = process.platform,
     if (path && (await isFile(path))) found.push({ path, time: (await stat(path)).mtimeMs })
   }
   if (found.length) return found.sort((a, b) => b.time - a.time)[0].path
-  throw new RuntimeMissing()
+  throw new RuntimeMissing(runtime)
 }
 
 // RuntimeMissing: no Qoder desktop or CLI on this machine to read the
@@ -1418,19 +1588,21 @@ async function campaignRuntime({ home = homedir(), platform = process.platform,
 // never makes up. Asking again won't change that until the user installs
 // Qoder, so the check-in says what to do once instead of "tries again later".
 class RuntimeMissing extends Error {
-  constructor() {
+  constructor(runtime = RUNTIMES.qoder) {
+    const { name, override } = runtime
     super(
-      "Qoder check-in: device identity runtime not found. Qoder gives the daily credits only to a device its own app identifies, and this machine has neither Qoder desktop nor Qoder CLI to read that identity from. Install Qoder desktop (or install Qoder CLI and sign in to it once), or set QODER_RUNTIME_INFO to its runtime-info executable; magpie checks in again the next day",
+      `${name} check-in: device identity runtime not found. ${name} gives the daily credits only to a device its own app identifies, and this machine has neither ${name} desktop nor ${name} CLI to read that identity from. Install ${name} desktop (or install ${name} CLI and sign in to it once), or set ${override} to its runtime-info executable; magpie checks in again the next day`,
     )
   }
 }
 
-// Read the SDK identity as Qoder does: environment 3 is international; on
-// Windows and macOS the uid goes over stdin, never into the command line.
-async function campaignMachine(uid) {
+// Read the SDK identity as Qoder does: environment 3 is international, 0
+// Qoder CN; on Windows and macOS the uid goes over stdin, never into the
+// command line.
+async function campaignMachine(uid, runtime = RUNTIMES.qoder) {
   if (!uid) throw new Error("Qoder check-in: device identity needs the account uid; sign in again")
-  const file = await campaignRuntime()
-  const args = process.platform === "linux" ? ["3"] : ["3", "--account-stdin"]
+  const file = await campaignRuntime({ runtime })
+  const args = process.platform === "linux" ? [runtime.environment] : [runtime.environment, "--account-stdin"]
   const text = await new Promise((resolve, reject) => {
     const child = execFile(file, args, { timeout: 20_000, windowsHide: true, maxBuffer: 1 << 20 }, (err, out) => {
       if (err) reject(err)
@@ -1439,7 +1611,7 @@ async function campaignMachine(uid) {
     child.stdin?.on("error", () => {})
     child.stdin?.end(process.platform === "linux" ? undefined : JSON.stringify({ account: uid }) + "\n")
   }).catch(() => {
-    throw new Error("Qoder check-in: could not read device identity; restart or update Qoder, or check QODER_RUNTIME_INFO")
+    throw new Error(`${runtime.name} check-in: could not read device identity; restart or update ${runtime.name}, or check ${runtime.override}`)
   })
   try {
     const identity = JSON.parse(text.trim().split(/\r?\n/, 1)[0])
@@ -1451,7 +1623,7 @@ async function campaignMachine(uid) {
     }
     return headers
   } catch {
-    throw new Error("Qoder check-in: invalid device identity from Qoder; restart or update Qoder")
+    throw new Error(`${runtime.name} check-in: invalid device identity from ${runtime.name}; restart or update ${runtime.name}`)
   }
 }
 
@@ -1606,12 +1778,13 @@ const makePlugin = (site) => async ({ client }) => {
   const ID = site.id
   // The SDK identity is account-specific. Share an in-flight read, refresh
   // after an hour, and leave a failed read available for the next attempt.
+  const runtime = RUNTIMES[ID]
   const campaignMachines = new Map()
   const machineForCampaign = async (uid) => {
     const now = Date.now()
     let entry = campaignMachines.get(uid)
     if (!entry || now - entry.at >= CAMPAIGN_MACHINE_TTL) {
-      entry = { at: now, promise: campaignMachine(uid) }
+      entry = { at: now, promise: campaignMachine(uid, runtime) }
       campaignMachines.set(uid, entry)
     }
     try {
@@ -1621,6 +1794,16 @@ const makePlugin = (site) => async ({ client }) => {
       throw e
     }
   }
+  // campaignIdentity: the headers a campaigns request carries, and why
+  // there are none where the site goes on without them (Qoder CN).
+  const campaignIdentity = async (uid) => {
+    if (runtime.required) return { machine: await machineForCampaign(uid) }
+    try {
+      return { machine: await machineForCampaign(uid) }
+    } catch (e) {
+      return { machine: {}, unread: e }
+    }
+  }
   // serializes checking, rotating and saving tokens: a refresh token is
   // spent once, so two refreshes would spend it twice
   let lock = Promise.resolve()
@@ -1779,7 +1962,7 @@ const makePlugin = (site) => async ({ client }) => {
     if (!url) return errorResponse({ status: 404, message: "only chat completions are served" })
     const method = String(init.method ?? input?.method ?? "GET").toUpperCase()
     try {
-      const machine = site.id === "qoder" ? await machineForCampaign(cred.uid) : {}
+      const { machine } = await campaignIdentity(cred.uid)
       // A PAT account has no device token: its job token signs the campaigns
       // pages too, as it does the usage read. Nothing is rotated on that
       // path — the refusal is the answer.
@@ -1808,7 +1991,7 @@ const makePlugin = (site) => async ({ client }) => {
     const base = campaignTarget(site, siteOf(site, cred), site.openapi + CAMPAIGNS)
     if (!base) return { outcome: "inactive", message: "no campaigns page for this account" }
     try {
-      const machine = site.id === "qoder" ? await machineForCampaign(cred.uid) : {}
+      const { machine, unread } = await campaignIdentity(cred.uid)
       // A PAT account has no device token: the campaigns pages take the job
       // token the exchange gave, as the usage endpoint does. A live Qoder CN
       // PAT account answered 200 to the list and CLAIMED to a claim, so the
@@ -1846,7 +2029,13 @@ const makePlugin = (site) => async ({ client }) => {
           const amount = Number(done.benefit?.amount)
           return { outcome: "done", ...(Number.isFinite(amount) && amount > 0 ? { credit: amount } : {}) }
         }
-        return campaigns.length ? { outcome: "failed", message: "campaigns: today's credits aren't offered yet" } : { outcome: "inactive" }
+        if (campaigns.length) return { outcome: "failed", message: "campaigns: today's credits aren't offered yet" }
+        // Asked without Qoder CN's identity and offered nothing: what an
+        // international list says to a request without one, so say why
+        // (no Qoder CN on this machine) or ask again (it didn't answer).
+        if (unread instanceof RuntimeMissing) return { outcome: "ineligible", message: unread.message }
+        if (unread) return { outcome: "failed", message: unread.message }
+        return { outcome: "inactive" }
       }
       const claimRes = await call(base.replace(/\/$/, "") + "/" + encodeURIComponent(campaign.campaignId) + "/claim", "POST", "{}")
       let claim = {}
@@ -1889,23 +2078,37 @@ const makePlugin = (site) => async ({ client }) => {
       return errorResponse({ status: 502, message: e?.message ?? String(e) })
     }
     if (!m) return errorResponse({ status: 400, message: `unknown or disabled model "${chat.model}"` })
-    const CHAT_URL = siteOf(site, cred).api + CHAT_PATH
-    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 })
+    const api = siteOf(site, cred).api
+    const CHAT_URL = api + CHAT_PATH
+    const body = qoderBody(chat, m)
+    const wire = encodeBody(JSON.stringify(body))
+    // Qoder's queue is waited out (queueWait) and the same request, its
+    // request_set_id the one the queue knows, sent again
+    const deadline = QUEUE.now() + QUEUE.budget
+    const ask = { requestSetId: body.request_set_id, requestId: body.request_id, sessionId: body.session_id, modelKey: m.key }
+    for (let waited = 0; ; waited++) {
+      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, open
+      try {
+        res = await fetch(CHAT_URL, { method: "POST", headers, body: wire, signal: init.signal })
+        if (res.ok) open = await opened(res)
+      } catch (e) {
+        return errorResponse({ status: 502, message: e.message })
+      }
+      const f = !res.ok ? failure(res.status, (await res.text()).slice(0, 1 << 20)) : open.first.value?.error
+      if (!f?.queue || waited >= QUEUE.recoveries) return f && !res.ok ? errorResponse(f) : answer(open, chat)
+      try {
+        if (!(await queueWait(api, cred, ask, f.queue, init.signal, deadline))) return errorResponse(f)
+      } catch (e) {
+        return errorResponse({ status: 502, message: e?.message ?? String(e) })
+      }
     }
-    if (!res.ok) return errorResponse(failure(res.status, (await res.text()).slice(0, 1 << 20)))
-    return answer(res, chat)
   }
 
   return {
@@ -2071,4 +2274,4 @@ export const QoderAuthPlugin = makePlugin(SITES.qoder)
 export const QoderCNAuthPlugin = makePlugin(SITES["qoder-cn"])
 
 // for tests
-export const _internal = { campaignRuntime, campaignPage, campaignTarget, vpcInstance, vpcSite, parseUsage, gfmt, when, failure, modelInfo, qoderBody, qoderMessages, cacheMarked, sessionOf, SITES, decodeBody, events }
+export const _internal = { campaignRuntime, RUNTIMES, campaignPage, campaignTarget, vpcInstance, vpcSite, parseUsage, gfmt, when, failure, modelInfo, qoderBody, qoderMessages, cacheMarked, sessionOf, SITES, decodeBody, events, QUEUE, queueState }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magpie-community/opencode-qoder-auth",
-  "version": "0.2.27",
+  "version": "0.2.30",
   "description": "Qoder subscriptions in OpenCode and magpie: Qoder (qoder.com) and Qoder CN (qoder.cn)",
   "type": "module",
   "main": "./index.mjs",