magicrew-auth 0.3.25 → 0.3.28

package/src/hooks/methods.mjs

@@ -1,16 +1,26 @@
 // ② auth.methods[] —— 登录
 //
-// 两条路，按可靠性排：
+// 四条路，按可靠性排：
 //
-//   ① 浏览器登录（默认，零输入）：插件自己拉起一个能被 CDP 看进去的浏览器，
+//   ① 手机号验证码（零浏览器）：识图模型过旋转验证 → 发短信 → 用户填码。
+//   ② 邮箱验证码：同一条链，只有标识字段和两个端点不同（见下面 makeCodeMethod）。
+//   ③ 浏览器登录（默认零输入）：插件自己拉起一个能被 CDP 看进去的浏览器，
 //      用户在官方页里用任何方式登，登录成功那一刻插件把 localStorage 读走。
 //      拉不起来就降级成「magpie 开系统浏览器 + 用户粘一行 Console」。
-//   ② 登录态（JWT + 组织码）：手填两个字段，兜底用。
+//   ④ 登录态（JWT + 组织码）：手填两个字段，兜底用。
 //
-// ⚠ 两条铁律：
+// ⚠ 三条铁律：
 //   · authorize() 必须立刻返回 —— 真正等用户的是 callback()，死等会和 magpie 互锁
 //   · opened: true 的语义是「我自己已经开过页面了，你别再开」；
 //     只返回 url 让它去开的，**不许**传 opened
+//   · authorize() 里失败只能抛异常，**不能** return { type: "failed" } ——
+//     magpie 把它的返回值当「登录流程对象」，会去调 `.callback()`，于是崩在一句
+//     `callback is not a function` 上（实测触发路径：callback 失败 → 用户点「重试」
+//     → 重新调 authorize → 又走到失败分支 → 崩）
+//
+// ⚠ 数组顺序 = magpie 登录方式列表里的顺序，所以**按站点分**：
+//   国际站（magicrew-intl）邮箱在前 —— 那边用户大多是邮箱注册的；
+//   国内站手机号在前。
 
 import {
   issueGatewayKey,
@@ -22,7 +32,7 @@ import { inviteToUse, readSession, writeSession, noteLoginFailure, noteOrg, read
 import { readLocalCreds } from "../local-browser.mjs"
 import { CLIP_HINT, clipboardText, parseCreds, pollClipboard } from "../clipboard.mjs"
 import { readVisionModel } from "../vision.mjs"
-import { finishSmsLogin, startSmsLogin } from "../headless.mjs"
+import { finishCodeLogin, startCodeLogin } from "../headless.mjs"
 
 /**
  * 账号刚加进来（登录成功）→ 一次性把「首次 AI 工作 / 首个对话」补掉。
@@ -46,6 +56,16 @@ function kickoffFirstTask(c, jwt, org) {
  * `orgs` 是候选组织列表（无头那条路拿不到「用户当前选中的组织」，只能猜）。
  * 按顺序用 `fetchPoints` 真验一遍，第一个验得过才算。
  *
+ * 后两个参数只影响**卡片上显示的名字**，但选错会让同一个号在两条登录路上
+ * 算出不同的 accountId，magpie 就把同一个号加成两条（真机踩过）。三档优先级：
+ *
+ *   preferredAccountId → who.name（服务端给的手机号/邮箱/昵称）→ fallbackAccountId → 组织码
+ *
+ *   · 手机号验证码那条传 preferred —— 服务端只回打码号（`189****051`），
+ *     得由我们自己把它固定成同一个字符串，两条路才一致
+ *   · 邮箱验证码那条传 fallback —— 邮箱不需要打码；who 成功时优先用 who，
+ *     这样和浏览器登录那条路算出来的是同一个
+ *
  * ⚠ 别说这解决了「多组织选哪个」—— **它没解决，只是容错**：
  *   账号所属的任何一个组织都能通过 `fetchPoints`（只要 JWT 有效），
  *   所以「第一个验得过的」实际就是「列表第一个」。
@@ -54,7 +74,7 @@ function kickoffFirstTask(c, jwt, org) {
  *   头都一样），不能拿来判断。⇒ 多组织账号在无头这条路上会落到列表第一个组织，
  *   这是已知限制，不是 bug。
  */
-async function completeSignIn(c, jwt, org, orgs = [], preferredAccountId = null) {
+async function completeSignIn(c, jwt, org, orgs = [], preferredAccountId = null, fallbackAccountId = null) {
   const candidates = [org, ...orgs.filter((o) => o && o !== org)]
   let lastErr = null
   let picked = null
@@ -85,10 +105,7 @@ async function completeSignIn(c, jwt, org, orgs = [], preferredAccountId = null)
   //   真机踩过：浏览器登录拿到的是打码手机号 `189****051`（fetchWho 成功，
   //   服务端只给打码号）；无头那条路 fetchWho 挂了（438 字符的 access_token
   //   配 Bearer 头不通），于是兜底用了组织码 `h97gkbu8bruj` ⇒ 两条并存。
-  //
-  //   所以优先用**调用方明确给的** accountId（无头路径里就是它自己算出来的打码手机号），
-  //   `who.name` 只作为补充，组织码是最后一档 —— 它绝不该当账号名。
-  const accountId = preferredAccountId || who?.name || picked
+  const accountId = preferredAccountId || who?.name || fallbackAccountId || picked
   return {
     type: "success",
     access: key.apiKey,
@@ -101,161 +118,235 @@ async function completeSignIn(c, jwt, org, orgs = [], preferredAccountId = null)
   }
 }
 
-export function makeMethods(c) {
-  return [
-    {
-      // 手机号 + 短信验证码，**不开浏览器**。
-      //
-      // 卡点从来不是协议，是那张「拖动滑块使图片角度为正」的图。现在的做法：
-      // 用 magpie 设置里用户自己选的识图模型（settings.json 的 vision）
-      // 判断「主体上方向指向钟面几点」，再换算成拖动角度 —— 实测 120° 的图判出 122°，
-      // 而服务端容差 ±10°，够用。
-      //
-      // 没配识图模型时不在这里瞎猜（猜中概率只有 ~5.6%，会先撞「验证提交过于频繁」），
-      // 而是让这条方法直接报错并指路 —— 详见下面那段说明。
-      type: "oauth",
-      label: `${c.SHORT} 手机号验证码`,
-      prompts: [
-        {
-          type: "text",
-          key: "phone",
-          message: "手机号",
-          placeholder: "13800138000",
-          validate: (v) =>
-            /^1\d{10}$/.test(String(v || "").replace(/[\s-]/g, "")) ? undefined : "11 位手机号，只要数字",
-        },
-      ],
-      async authorize(inputs) {
-        const phone = String(inputs?.phone || "").replace(/[\s-]/g, "")
-        // ⚠ authorize() 里**不能**返回 { type: "failed" }：magpie 把这里的返回值当作
-        //   「登录流程对象」，会去调它的 `.callback()` —— 少了这个函数就是一句
-        //   `callback is not a function`，用户只看到莫名其妙的报错。
-        //   实测触发路径：callback 里失败 → magpie 显示「重试」 → 点重试会**重新调
-        //   authorize** → 这次走到这条失败分支 → 返回没有 callback 的对象 → 崩。
-        //   ⇒ authorize 里失败一律抛异常。
-        if (!/^1\d{10}$/.test(phone)) throw new Error("手机号不完整")
-
-        const vision = readVisionModel()
-        const masked = phone.replace(/^(\d{3})\d{4}(\d{4})$/, "$1****$2")
-
-        if (!vision) {
-          // 没有识图模型 → 回退到浏览器：打不开就不硬撑。
-          //
-          // 为什么不在这里瞎猜角度：容差 ±10° 意味着瞎猜命中率只有 ~5.6%（20/360），
-          // 平均要试十几次，而服务端有「验证提交过于频繁」和「验证次数已超限」两道风控 ——
-          // 等不到猜中，先被限流。所以老老实实让用户转那一下。
-          let browser = null
-          let why = ""
-          try {
-            browser = await import("../browser-login.mjs")
-          } catch (e) {
-            why = `浏览器登录模块加载失败：${String(e?.message ?? e).slice(0, 200)}`
-            noteLoginFailure(c.id, why)
-          }
+/** 邮箱的粗校验。别搬 RFC 那个怪物正则 —— 服务端还会再验一次 */
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/
+
+/**
+ * 「验证码登录」——手机号与邮箱共用一份实现。
+ *
+ * 两条链的协议**完全一样**：取图 → 识图判角度 → 过旋转验证 → 发码 → 用户填码 →
+ * 换登录态。差异只有三处，而且都已收敛进 captcha.mjs / headless.mjs 按 ident 分派：
+ *
+ *   · 问用户要什么：11 位手机号 / 邮箱
+ *   · 发码端点：`/v4/user/send-sms` / `/v4/user/send-email`
+ *   · 换登录态：`/v4/user/login`（验证码字段叫 `code`）/
+ *              `/v4/user/login-email`（字段叫 `captcha`）
+ *
+ * 所以这里只写一份、传 kind。哪天被复制成两份，下次改超时或改文案必然只改一份。
+ *
+ * 卡点从来不是协议，是那张「拖动滑块使图片角度为正」的图：用 magpie 设置里用户
+ * 自己选的识图模型（settings.json 的 vision）判「主体上方向指向钟面几点」，再换算
+ * 成拖动角度 —— 实测 120° 的图判出 122°，而服务端容差 ±10°，够用。
+ *
+ * 没配识图模型时**不在这里瞎猜**（猜中概率只有 ~5.6%，会先撞「验证提交过于频繁」），
+ * 而是回退到浏览器登录，让用户自己转那一下。
+ *
+ * @param {object} c     站点闭包（id / SHORT / web / host）
+ * @param {"mobile"|"email"} kind
+ */
+function makeCodeMethod(c, kind) {
+  const isEmail = kind === "email"
+  const what = isEmail ? "邮箱" : "手机号"
+  /** 官方登录页上那个 tab 的名字 —— 回退到浏览器时要说清楚点哪个 */
+  const tab = isEmail ? "邮箱登录（Email）" : "手机登录（Phone）"
 
-          const inviteCode = inviteToUse(c.id)
-          const url = inviteCode
-            ? `${c.web}/login?invitation=${encodeURIComponent(inviteCode)}`
-            : `${c.web}/login`
-          const hostFragment = new URL(c.web).hostname
+  /** 用户填的那一项 → 之后每个请求都要带的标识字段 */
+  const identOf = (inputs) =>
+    isEmail
+      ? { email: String(inputs?.email || "").trim() }
+      : { mobile: String(inputs?.phone || "").replace(/[\s-]/g, ""), stateCode: "+86" }
 
-          const session = browser
-            ? await browser.launchLoginBrowser(url).catch((e) => {
-                why = String(e?.message ?? e).slice(0, 300)
-                noteLoginFailure(c.id, `launch: ${why}`)
-                return null
-              })
-            : null
+  /**
+   * 给用户看的那个标识。
+   * 手机号打码（服务端自己也是这么回的），邮箱原样 —— 邮箱没有打码这回事，
+   * 而且它正好是浏览器登录那条路上 `who.name` 会给出的字符串。
+   */
+  const displayOf = (ident) =>
+    isEmail ? ident.email : String(ident.mobile).replace(/^(\d{3})\d{4}(\d{4})$/, "$1****$2")
 
-          return {
-            url,
-            ...(session ? { opened: true } : {}),
-            instructions: session
-              ? `没有配置识图模型，那个「拖动滑块使图片角度为正」得你自己转一下 —— 已经用 ${session.name || "浏览器"} 打开了登录页。\n` +
-                `在里面选「手机登录」，填 ${masked}，把图片转正、收到验证码后填进去；登录完成这个窗口会自动接上，不用回来点任何东西。\n` +
-                `（想全自动的话：magpie 设置 → 识图模型，选一个能看图的，下次就只需要填手机号和验证码。）`
-              : `没能自己拉起浏览器${why ? `（${why}）` : "（本机没找到 Chromium 内核浏览器）"}，已改用系统浏览器打开登录页。\n` +
-                `登录完成后，在页面里按 F12 → Console 粘这一行：\n${CLIP_HINT}`,
-            method: "auto",
-            async callback() {
-              let got = null
-              if (session && browser) {
-                got = await browser.waitForCreds(session, hostFragment).catch(() => null)
-                await browser.closeSession(session).catch(() => {})
-              }
-              if (!got && !session) {
-                got = await pollClipboard({ skip: "" }).catch(() => null)
-              }
-              if (!got) {
-                return {
-                  type: "failed",
-                  error: session
-                    ? "浏览器开着了，但 5 分钟内没在里面读到登录状态 —— 是还没登完，还是登的不是这个站点？"
-                    : "5 分钟内没拿到登录状态。可以改用「登录态（JWT + 组织码）」那条备选。",
-                }
-              }
-              try {
-                if (!got.org) throw new Error("只拿到 JWT，没有组织码")
-                return await completeSignIn(c, got.jwt, got.org)
-              } catch (e) {
-                return { type: "failed", error: String(e?.message ?? e).slice(0, 500) }
-              }
-            },
+  const looksInvalid = (ident) => (isEmail ? !EMAIL_RE.test(ident.email) : !/^1\d{10}$/.test(ident.mobile))
+
+  return {
+    type: "oauth",
+    label: `${c.SHORT} ${what}验证码`,
+    prompts: [
+      isEmail
+        ? {
+            type: "text",
+            key: "email",
+            message: "邮箱",
+            placeholder: "you@example.com",
+            validate: (v) =>
+              EMAIL_RE.test(String(v || "").trim()) ? undefined : "填一个完整邮箱，例如 you@example.com",
           }
-        }
+        : {
+            type: "text",
+            key: "phone",
+            message: "手机号",
+            placeholder: "13800138000",
+            validate: (v) =>
+              /^1\d{10}$/.test(String(v || "").replace(/[\s-]/g, "")) ? undefined : "11 位手机号，只要数字",
+          },
+    ],
+    async authorize(inputs) {
+      const ident = identOf(inputs)
+      // ⚠ 这里是 authorize，失败只能抛异常，不能返回 { type: "failed" }（见文件头铁律）
+      if (looksInvalid(ident)) throw new Error(`${what}不完整`)
 
-        // 邀请码两条路都要出现：登录页的 URL，以及最终注册时服务端读到的那份。
-        // ⚠ 无头这条路**没有**「打开带邀请码的页面」这一步，所以邀请码只能靠
-        //   `redirect` 传 —— 网页表单的初始值里 redirect 就是 window.location.href，
-        //   服务端从它上面取 `?invitation=`。少了它，新注册的号就没有邀请关系。
-        const inviteCode = inviteToUse(c.id)
-        const loginUrl = inviteCode
-          ? `${c.web}/login?invitation=${encodeURIComponent(inviteCode)}`
-          : `${c.web}/login`
+      const shown = displayOf(ident)
+
+      // 邀请码两条路都要出现：登录页的 URL，以及最终注册时服务端读到的那份。
+      // ⚠ 无头这条路**没有**「打开带邀请码的页面」这一步，所以邀请码只能靠
+      //   `redirect` 传 —— 网页表单的初始值里 redirect 就是 window.location.href，
+      //   服务端从它上面取 `?invitation=`。少了它，新注册的号就没有邀请关系。
+      const inviteCode = inviteToUse(c.id)
+      const loginUrl = inviteCode
+        ? `${c.web}/login?invitation=${encodeURIComponent(inviteCode)}`
+        : `${c.web}/login`
 
-        // 发短信这一步最慢（过验证最多试 3 张图、每张问两遍模型）。
-        // 但必须等它结束才能告诉用户「验证码已发出」—— 所以这里不甩到 callback 里。
-        let sent
+      /**
+       * 需要过图、但用户没配识图模型 → 回退到浏览器，让他自己转那一下。
+       *
+       * ⚠ 只有**这个号还没注册**时才该走到这里：已注册的号服务端根本不发旋转图，
+       *   `startCodeLogin` 会直接发码（见 headless.mjs 里那段说明）。
+       *
+       * 为什么不在这里瞎猜角度：容差 ±10° 意味着瞎猜命中率只有 ~5.6%（20/360），
+       * 平均要试十几次，而服务端有「验证提交过于频繁」和「验证次数已超限」两道风控 ——
+       * 等不到猜中，先被限流。所以老老实实让用户转那一下。
+       */
+      async function browserFallback() {
+        const url = loginUrl
+        const hostFragment = new URL(c.web).hostname
+        let browser = null
+        let why = ""
         try {
-          sent = await startSmsLogin(c, { mobile: phone })
+          browser = await import("../browser-login.mjs")
         } catch (e) {
-          // 同上：这里也不能 return failed —— 点「重试」会重新走 authorize，
-          // 返回没有 callback 的对象会让 magpie 崩在 `.callback()`
-          throw new Error(String(e?.message ?? e).slice(0, 500))
+          why = `浏览器登录模块加载失败：${String(e?.message ?? e).slice(0, 200)}`
+          noteLoginFailure(c.id, why)
         }
 
+        const session = browser
+          ? await browser.launchLoginBrowser(url).catch((e) => {
+              why = String(e?.message ?? e).slice(0, 300)
+              noteLoginFailure(c.id, `launch: ${why}`)
+              return null
+            })
+          : null
+
         return {
-          url: loginUrl,
-          instructions:
-            `验证码已发送到 ${masked}。\n` +
-            `旋转验证由识图模型（${vision}）自动通过，试了 ${sent.rounds} 张图。\n` +
-            `把收到的 6 位验证码填进下面的框就行。`,
-          method: "code",
-          // ⚠ 必须是 true。这条链路**全在后台走完**，不需要任何浏览器；
-          //   opened: false 会让 magpie 拿 url 去开**系统默认浏览器** —— 而那个浏览器里
-          //   往往本来就登着这个站，用户看到的是已登录界面，根本进不了「添加新号」，
-          //   还会以为插件把他登进了旧账号。这正是浏览器登录那条路修过的坑。
-          opened: true,
-          async callback(code) {
-            const c0 = String(code || "").replace(/\D/g, "")
-            if (c0.length < 4) return { type: "failed", error: "验证码是 4~8 位数字" }
-            let creds
-            try {
-              creds = await finishSmsLogin(c, { mobile: phone, code: c0, redirect: loginUrl })
-            } catch (e) {
-              return { type: "failed", error: String(e?.message ?? e).slice(0, 500) }
+          url,
+          ...(session ? { opened: true } : {}),
+          instructions: session
+            ? `没有配置识图模型，那个「拖动滑块使图片角度为正」得你自己转一下 —— 已经用 ${session.name || "浏览器"} 打开了登录页。\n` +
+              `在里面选「${tab}」，填 ${shown}，把图片转正、收到验证码后填进去；登录完成这个窗口会自动接上，不用回来点任何东西。\n` +
+              `（想全自动的话：magpie 设置 → 识图模型，选一个能看图的，下次就只需要填${what}和验证码。）`
+            : `没能自己拉起浏览器${why ? `（${why}）` : "（本机没找到 Chromium 内核浏览器）"}，已改用系统浏览器打开登录页。\n` +
+              `登录完成后，在页面里按 F12 → Console 粘这一行：\n${CLIP_HINT}`,
+          method: "auto",
+          async callback() {
+            let got = null
+            if (session && browser) {
+              got = await browser.waitForCreds(session, hostFragment).catch(() => null)
+              await browser.closeSession(session).catch(() => {})
+            }
+            if (!got && !session) {
+              got = await pollClipboard({ skip: "" }).catch(() => null)
+            }
+            if (!got) {
+              return {
+                type: "failed",
+                error: session
+                  ? "浏览器开着了，但 5 分钟内没在里面读到登录状态 —— 是还没登完，还是登的不是这个站点？"
+                  : "5 分钟内没拿到登录状态。可以改用「登录态（JWT + 组织码）」那条备选。",
+              }
             }
             try {
-              // 传 masked（打码手机号）当 accountId —— 浏览器登录那条路拿到的也是
-              // 这个字符串，两边一致才不会把同一个号加成两条
-              return await completeSignIn(c, creds.jwt, creds.org, creds.orgs, masked)
+              if (!got.org) throw new Error("只拿到 JWT，没有组织码")
+              return await completeSignIn(c, got.jwt, got.org)
             } catch (e) {
-              return { type: "failed", error: `登录成功了，但换 key 失败：${String(e?.message ?? e).slice(0, 300)}` }
+              return { type: "failed", error: String(e?.message ?? e).slice(0, 500) }
             }
           },
         }
-      },
+      }
+
+      // 发码这一步最慢（要给新号过验证时最多试 4 张图、每张问两遍模型）。
+      // 但必须等它结束才能告诉用户「验证码已发出」—— 所以这里不甩到 callback 里。
+      let sent
+      try {
+        sent = await startCodeLogin(c, ident)
+      } catch (e) {
+        if (e?.code === "no-vision-model") {
+          // ⚡ 只有这一种情况才回退到浏览器：这个号**还没注册**（服务端给了旋转图），
+          //    而用户没配识图模型。已注册的号走不到这里 —— 服务端不出图。
+          return browserFallback()
+        }
+        // 其余一律抛：authorize 里 return failed 会让 magpie 崩在 `.callback()`
+        throw new Error(String(e?.message ?? e).slice(0, 500))
+      }
+
+      return {
+        url: loginUrl,
+        instructions: sent.skippedCaptcha
+          ? `验证码已发送到 ${shown}。\n` +
+            `这个号服务端那边已经注册过，旋转验证直接放行 —— 这一环跳过了，识图模型这次也用不上。\n` +
+            `把收到的 6 位验证码填进下面的框就行。`
+          : `验证码已发送到 ${shown}。\n` +
+            `旋转验证由识图模型（${readVisionModel()}）自动通过，试了 ${sent.rounds} 张图。\n` +
+            `把收到的 6 位验证码填进下面的框就行。`,
+        method: "code",
+        // ⚠ 必须是 true。这条链路**全在后台走完**，不需要任何浏览器；
+        //   opened: false 会让 magpie 拿 url 去开**系统默认浏览器** —— 而那个浏览器里
+        //   往往本来就登着这个站，用户看到的是已登录界面，根本进不了「添加新号」，
+        //   还会以为插件把他登进了旧账号。这正是浏览器登录那条路修过的坑。
+        opened: true,
+        async callback(code) {
+          const c0 = String(code || "").replace(/\D/g, "")
+          if (c0.length < 4) return { type: "failed", error: "验证码是 4~8 位数字" }
+          let creds
+          try {
+            creds = await finishCodeLogin(c, { ...ident, code: c0, redirect: loginUrl })
+          } catch (e) {
+            return { type: "failed", error: String(e?.message ?? e).slice(0, 500) }
+          }
+          try {
+            // 手机号：把打码号钉成 accountId（浏览器登录那条路拿到的也是这个字符串）；
+            // 邮箱：优先让 who 决定（那才是浏览器登录会给出的一致值），who 挂了才退回邮箱
+            return await completeSignIn(
+              c,
+              creds.jwt,
+              creds.org,
+              creds.orgs,
+              isEmail ? null : shown,
+              isEmail ? ident.email : null,
+            )
+          } catch (e) {
+            return { type: "failed", error: `登录成功了，但换 key 失败：${String(e?.message ?? e).slice(0, 300)}` }
+          }
+        },
+      }
     },
+  }
+}
+
+export function makeMethods(c) {
+  // 顺序 = magpie 登录方式列表里的顺序。
+  //
+  // ⚠ **邮箱验证码只有国际站有**，国内站不给。实测两件事：
+  //   ① www.letsmagic.cn/login 的登录方式只有 微信 / 苹果 / 密码 / 手机 / 私有部署，
+  //      **没有邮箱**（国际站 www.magicrew.ai/login 才有 `switch-to-email`）；
+  //   ② 同一个发信请求，国内站 `/v4/user/send-email` 回 `2000 服务异常，请联系管理员`，
+  //      国际站回 `1000 请求成功`。
+  //   国内站既然没有邮箱入口，也就不存在邮箱注册的账号 —— 把这条方法摆出来，
+  //   只会让用户填完邮箱撞一个看不懂的错。
+  const codeMethods =
+    c.id === "magicrew-intl"
+      ? [makeCodeMethod(c, "email"), makeCodeMethod(c, "mobile")]
+      : [makeCodeMethod(c, "mobile")]
+
+  return [
+    ...codeMethods,
 
     {
       type: "oauth",

package/src/vision.mjs

@@ -128,49 +128,107 @@ function lastClock(text) {
 }
 
 async function askClock(base, model, imageDataUrl, variant) {
-  const res = await fetch(`${base}/chat/completions`, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
+  const body = {
+    model,
+    // ⚠ 这个上限是**给推理 token 留的**，不是给答案留的。
+    //
+    //   实测（2026-10-28，`workbuddy/deepseek-v4.1-flash`）：max_tokens=400 时
+    //   `finish_reason:"length"`、`reasoning_tokens:400`、**`content` 是 null** ——
+    //   推理过程把额度吃干净，答案一个字都没输出。判官拿到空串 ⇒ 判成
+    //   「不可信」⇒ 整条无头登录挂掉。给到 6000 时 reasoning 用 899 就收尾，
+    //   `content` 正常回 "10"。
+    //   ⇒ 别按「答案就一个数字」去估这个值；它买的是模型的思考空间。
+    max_tokens: 6000,
+    // ⚠ `reasoning_effort: "low"` —— 实测有据的省法（2026-10-29，同一模型同一批图，
+    //   每个配置各跑 6 轮）：
+    //
+    //     |            | 出数字 | 平均耗时 | 平均 tokens | 平均 reasoning |
+    //     | 不传        |  5/6  | 20.6 s   |   2343      |    3581 字     |
+    //     | low         |  6/6  |  8.4 s   |   1007      |    1646 字     |
+    //
+    //   更快、更省、而且**更稳**（不传的那一组有一次把 6000 token 全烧在思考上、
+    //   `content` 交白卷）。判出来的角度两者一致。
+    //
+    //   ⚠ 别指望「彻底不思考」——这个模型在网关侧关不掉，实测 12 组参数：
+    //     `enable_thinking:false` / `thinking_budget:0` → 思考**更长**且 content 空；
+    //     `reasoning_effort:"none"/"minimal"` → 比不传还长；
+    //     `thinking:{type:"disabled"}` / `chat_template_kwargs` / `extra_body` /
+    //     `reasoning:{enabled:false}` → 都只是小幅缩短，没有一个真的关掉。
+    //     要真不思考，只能换一个**非推理**的视觉模型（那由用户在 magpie 设置里选）。
+    //
+    //   ⚠ 它**不是** OpenAI 规范字段：下面 send() 里有一层兜底，被 400 就退一步重发。
+    reasoning_effort: "low",
     // temperature 0 是为了同一张图两次问法之外的噪声尽量小；
     // 两次用不同措辞（variant）而不是靠随机温度，好复现
-    body: JSON.stringify({
-      model,
-      max_tokens: 400,
-      temperature: 0,
-      messages: [
-        {
-          role: "user",
-          content: [
-            { type: "text", text: CLOCK_PROMPT(variant) },
-            { type: "image_url", image_url: { url: imageDataUrl } },
-          ],
-        },
-      ],
-    }),
-    signal: AbortSignal.timeout(45_000),
-  })
+    temperature: 0,
+    messages: [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: CLOCK_PROMPT(variant) },
+          { type: "image_url", image_url: { url: imageDataUrl } },
+        ],
+      },
+    ],
+  }
+
+  const send = (b) =>
+    fetch(`${base}/chat/completions`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(b),
+      signal: AbortSignal.timeout(90_000),
+    })
+
+  let res = await send(body)
+  if (res.status === 400 && Object.hasOwn(body, "reasoning_effort")) {
+    // 兼容兜底：识图模型是**用户自己选的**，不是我们能假设的（插件声明的模型目录里
+    // 什么都可能有，magpie 也允许自定义 provider）。有的 OpenAI 兼容端认出这个字段、
+    // 有的直接为未知字段回 400。宁可少省那几秒，也不要因为一个可选的优化把整条
+    // 无头登录打死 —— 去掉它重发一次，行为退回「不传」的那一档。
+    delete body.reasoning_effort
+    res = await send(body)
+  }
   if (!res.ok) throw new Error(`识图模型回 HTTP ${res.status}`)
   const j = await res.json()
-  const text = j?.choices?.[0]?.message?.content ?? ""
-  return { clock: lastClock(text), text: String(text).trim().slice(0, 200) }
+  const m = j?.choices?.[0]?.message ?? {}
+  const content = String(m.content ?? "").trim()
+  const reasoning = String(m.reasoning_content ?? "")
+  // ① 正常情况：答案在 content 里
+  if (content) return { clock: lastClock(content), text: content.slice(-200), from: "content" }
+  // ② 兜底：推理模型被截断、content 为空 —— 答案在 reasoning 的最后一段里
+  //    （实测尾巴就是「最终决定：10。」这种形状）。只看尾巴 300 字，
+  //    别把前面推理中间提到的钟点当答案。
+  if (reasoning) {
+    const tail = reasoning.slice(-300)
+    return { clock: lastClock(tail), text: tail.slice(-200), from: "reasoning" }
+  }
+  return { clock: null, text: "", from: "empty" }
 }
 
 /**
  * 让识图模型判断「该顺时针转多少度」。
  *
+ * @param {string} imageDataUrl 验证码图的 data URL
+ * @param {{model?:string}} [opts] `model` 可覆盖设置里那个（给对比脚本 / 测试用；
+ *   正常运行不传，读用户选的）
  * @returns {Promise<{ok:true, deg:number, clock:number, spread:number, model:string}
  *                  |{ok:false, reason:string, detail?:string}>}
  */
-export async function decideDegFromImage(imageDataUrl) {
-  const model = readVisionModel()
+export async function decideDegFromImage(imageDataUrl, { model: overrideModel } = {}) {
+  const model = overrideModel || readVisionModel()
   if (!model) return { ok: false, reason: "no-vision-model" }
 
   const base = await resolveGatewayBase()
   if (!base) return { ok: false, reason: "no-gateway", detail: "连不上 magpie 自己的网关（试过 3425/3426/8080）" }
 
   const img = await toPngDataUrl(imageDataUrl)
-  const a = await askClock(base, model, img, 0).catch((e) => ({ clock: null, text: String(e?.message ?? e) }))
-  const b = await askClock(base, model, img, 1).catch(() => ({ clock: null, text: "" }))
+  // ⚠ **两个判官并行**：串行等两次就把延迟叠成两倍（实测单次 5～20 秒），
+  //   而它们互不依赖 —— 一起发，耗时等于较慢的那一次。
+  const [a, b] = await Promise.all([
+    askClock(base, model, img, 0).catch((e) => ({ clock: null, text: String(e?.message ?? e) })),
+    askClock(base, model, img, 1).catch(() => ({ clock: null, text: "" })),
+  ])
 
   if (a.clock == null && b.clock == null) {
     return { ok: false, reason: "unparsable", detail: `${a.text} / ${b.text}` }