magpie-gemini-web 0.3.2 → 0.3.3

package/README.en.md

@@ -43,7 +43,7 @@ magpie plugin options magpie-gemini-web '{"allowTools":true,"allowImages":true}'
 
 ## Thinking effort
 
-You can switch a model between `low` and `high` effort in Magpie if it has a `-thinking` version. `low` uses the base model and `high` uses the `-thinking` model with extended thinking. After upgrading the plugin, run `magpie provider models gemini-web` to refresh the model list. Argon's medium tier will be added once upstream supports it ([#5](https://github.com/BUKOWSKIREAL/magpie-gemini-web/issues/5)).
+You can switch a model between `low` and `high` effort in Magpie if it has a `-thinking` version. `low` uses the base model and `high` uses the `-thinking` model with extended thinking, so the `-thinking` model isn't listed on its own. After upgrading the plugin, run `magpie provider models gemini-web` to refresh the model list. Argon's medium tier will be added once upstream supports it ([#5](https://github.com/BUKOWSKIREAL/magpie-gemini-web/issues/5)).
 
 ## Security and data
 
@@ -61,6 +61,15 @@ Magpie's usage cards show each Google account's **5-hour** and **weekly** usage
 
 Note that the backend picks the Google account for each request from its pool in turn: how Magpie spreads requests over the cards doesn't decide which account serves them. Only the one-click local backend has usage; a backend you connect to yourself keeps its cookies out of the plugin's reach.
 
+To send Google fewer requests, usage isn't read on every refresh. An account is read again once the backend has used it or one of its windows has reset, and never twice within 10 minutes. An idle account is read at most every 6 hours, which also picks up what you used in the Gemini web app.
+
+Usage and emails are read the way the backend reaches Google for that account. When that way isn't certain, nothing is read and the card says why:
+
+- the backend has a proxy pool, but the account isn't bound to a proxy yet (the backend binds it on its first request);
+- the account's proxy is disabled, or is a SOCKS proxy.
+
+So with a proxy pool, an account just added by one-click setup has no email yet. Send one request with it, sign in to it again with **「添加本地后端里已有的 Google 账号」**, then remove the sign-in without an email.
+
 ## Limitations
 
 - Upstream emulates tool calls with prompts, so they aren't always reliable. Flash models often don't call tools.
@@ -68,7 +77,7 @@ Note that the backend picks the Google account for each request from its pool in
 
 ## Argon patched build (optional)
 
-The official backend already supports `gemini-4-argon`, which needs a paid or Ultra account. This repo's patched build also verifies that responses really come from Argon, so a silent downgrade is caught, and it lowers latency. Building it requires Go 1.26+:
+The official backend already supports `gemini-4-argon`, which needs a paid or Ultra account. This repo's patched build also verifies that responses really come from Argon, so a silent downgrade is caught, and it lowers latency. It also makes the backend's requests look more like a browser's: on a direct connection every request carries the full set of Chrome headers (the official build's direct chat requests say `Go-http-client/2.0`), and refreshing the cookies to keep a session alive no longer fetches the `/app` page right away. Building it requires Go 1.26+:
 
 ```bash
 git clone https://github.com/BUKOWSKIREAL/magpie-gemini-web.git && cd magpie-gemini-web
@@ -81,6 +90,15 @@ npm run backend:install:argon
 
 Restart Magpie when the install finishes, and the plugin starts the Argon build in the background. If an older backend is still running, stop it first with `kill $(cat ~/.local/share/magpie-gemini-web/backend.pid)`. Run `npm run backend:install` to switch back to the official build.
 
+When `patches/argon.patch` changes (after you pull a new version of this repo, say), apply it again to clean sources and rebuild. Once the old backend is stopped, the plugin starts the new one on the next request:
+
+```bash
+git -C backend-source checkout -- . && git -C backend-source clean -fdq
+git -C backend-source apply ../patches/argon.patch
+npm run backend:build:argon && npm run backend:install:argon
+kill $(cat ~/.local/share/magpie-gemini-web/backend.pid)
+```
+
 ## License
 
 MIT. The upstream gemini-web2api-go project is also MIT (see `LICENSE-UPSTREAM`).

package/README.md

@@ -43,7 +43,7 @@ magpie plugin options magpie-gemini-web '{"allowTools":true,"allowImages":true}'
 
 ## 思考档位
 
-有 `-thinking` 版本的模型可以在 Magpie 里切换 `low` / `high`：`low` 用普通模型，`high` 用 `-thinking` 模型（扩展思考）。升级插件后执行 `magpie provider models gemini-web` 刷新模型列表。Argon 的「中」档等上游支持（[#5](https://github.com/BUKOWSKIREAL/magpie-gemini-web/issues/5)）。
+有 `-thinking` 版本的模型可以在 Magpie 里切换 `low` / `high`：`low` 用普通模型，`high` 用 `-thinking` 模型（扩展思考）。`-thinking` 模型因此不再单独列出。升级插件后执行 `magpie provider models gemini-web` 刷新模型列表。Argon 的「中」档等上游支持（[#5](https://github.com/BUKOWSKIREAL/magpie-gemini-web/issues/5)）。
 
 ## 安全与数据
 
@@ -61,6 +61,15 @@ Magpie 的额度卡片会显示 Google 账号的 **5 小时** 和 **每周** 用
 
 注意：请求最终由后端在账号池里轮流挑选 Google 账号，Magpie 在几张卡片之间怎么分配请求，不决定实际用的是哪个账号。只有一键配置的本地后端能显示用量；「连接已有后端」模式下读不到账号的 Cookie。
 
+为了少向 Google 发请求，用量不会每次刷新都去查：账号经后端用过、或者某个窗口到了重置时间，才重新读取，两次至少间隔 10 分钟；账号闲着时最多每 6 小时读一次（顺带反映你在 Gemini 网页里的用量）。
+
+读取用量和邮箱时，走的是后端访问 Google 的同一个出口。出口不确定时不读取，卡片上会写明原因：
+
+- 配了代理池，但账号还没绑定代理（后端在它第一次请求时绑定）；
+- 账号绑定的代理已停用，或者是 SOCKS 代理。
+
+所以配了代理池时，一键配置刚添加的账号暂时没有邮箱。先用它发一次请求，再用「添加本地后端里已有的 Google 账号」重新登录它，然后删掉没有邮箱的那个登录。
+
 ## 局限
 
 - 工具调用由上游用提示词模拟，不一定可靠，Flash 系列经常不调用工具。
@@ -68,7 +77,7 @@ Magpie 的额度卡片会显示 Google 账号的 **5 小时** 和 **每周** 用
 
 ## Argon 增强版（可选）
 
-官方后端已支持 `gemini-4-argon`（需付费 / Ultra 账号）。本仓库的补丁版额外校验返回的确实是 Argon（防止被静默降级），并降低延迟。需要 Go 1.26+：
+官方后端已支持 `gemini-4-argon`（需付费 / Ultra 账号）。本仓库的补丁版额外校验返回的确实是 Argon（防止被静默降级），并降低延迟。它也让后端的请求更像浏览器：直连时每个请求都带齐 Chrome 请求头（官方版直连时，对话请求的 UA 是 `Go-http-client/2.0`），保活刷新 Cookie 后也不再立即重新抓取 `/app` 页面。需要 Go 1.26+：
 
 ```bash
 git clone https://github.com/BUKOWSKIREAL/magpie-gemini-web.git && cd magpie-gemini-web
@@ -81,6 +90,19 @@ npm run backend:install:argon
 
 安装后重启 Magpie 即可，插件会在后台启动 Argon 版（如有旧后端在运行，先 `kill $(cat ~/.local/share/magpie-gemini-web/backend.pid)`）。运行 `npm run backend:install` 可切回官方版。
 
+`patches/argon.patch` 更新后（比如拉取了本仓库的新版本），需要在干净的源码上重新应用补丁并重新构建。停掉旧后端后，插件会在下一个请求时启动新版：
+
+```bash
+git -C backend-source checkout -- . && git -C backend-source clean -fdq
+git -C backend-source apply ../patches/argon.patch
+npm run backend:build:argon && npm run backend:install:argon
+kill $(cat ~/.local/share/magpie-gemini-web/backend.pid)
+```
+
+## 友链
+
+[LINUX DO](https://linux.do/) — 真诚、友善、团结、专业的技术社区。
+
 ## 许可证
 
 MIT。上游 gemini-web2api-go 同为 MIT（见 `LICENSE-UPSTREAM`）。

package/index.mjs

@@ -1,7 +1,7 @@
 import { normalizeBaseURL, settings, credentials, listModels, forward, UNREACHABLE_HEADER } from './lib/backend.mjs';
 import { ensureBackend, localBackend } from './lib/native.mjs';
 import { parseCookieInput, importCookie } from './lib/setup.mjs';
-import { usage, poolChoices, accountEmail } from './lib/usage.mjs';
+import { usage, poolChoices, poolAccounts, accountEmail } from './lib/usage.mjs';
 
 const ID = 'gemini-web';
 const GEMINI_URL = 'https://gemini.google.com/app';
@@ -22,7 +22,9 @@ const COOKIE_STEPS = [
 // signInFor is the Magpie sign-in for one account of the local backend's pool: the backend's
 // key, with the account's id for its usage card and its Google email, which names the card and
 // keeps each Google account a sign-in of its own (Magpie takes two sign-ins with one email for
-// one account, and two with neither for one when their key is the same).
+// one account, and two with neither for one when their key is the same). The account is the
+// pool's own entry (see poolAccounts), which says the way out to read the email by; without
+// one the email isn't read.
 async function signInFor(local, account) {
   const email = account.email || await accountEmail(account).catch(() => undefined);
   return {
@@ -96,7 +98,8 @@ export const GeminiWebPlugin = async (_input, options = {}) => {
               } catch (err) {
                 return { type: 'failed', error: err.message };
               }
-              return signInFor(local, { id: added.id, cookie });
+              const account = (await poolAccounts().catch(() => [])).find(a => a.id === added.id);
+              return signInFor(local, account || { id: added.id });
             }
           };
         }
@@ -182,8 +185,8 @@ export const GeminiWebPlugin = async (_input, options = {}) => {
         if (!managedBackend(c.baseURL)) {
           return { error: '只能读取插件自己管理的本地后端的额度（连接已有后端时读不到）', windows: [], signIn: 'kept' };
         }
-        const account = auth.metadata?.account;
-        return { ...(await usage(Number.isInteger(account) ? { account } : {})), signIn: 'kept' };
+        const { account, email } = auth.metadata || {};
+        return { ...(await usage(Number.isInteger(account) ? { account, email } : {})), signIn: 'kept' };
       }
     },
     provider: {

package/lib/backend.mjs

@@ -7,8 +7,9 @@ const CONTROL_CHARS = /[\x00-\x1f\x7f]/;
 const NEWLINE_CHARS = /[\r\n]/;
 
 // The backend has no effort parameter: extended thinking is a separate "<id>-thinking" model.
-// A base model with such a twin offers low (itself) and high (the twin). Magpie maps any other
-// level to the nearest declared one before it reaches us; direct callers get the same rule.
+// A base model with such a twin offers low (itself) and high (the twin), and the twin isn't
+// listed on its own; a request that names it still goes through. Magpie maps any other level to
+// the nearest declared one before it reaches us; direct callers get the same rule.
 const THINKING_SUFFIX = '-thinking';
 const LOW_EFFORTS = new Set(['none', 'minimal', 'low']);
 const MODEL_CACHE_MS = 10 * 60 * 1000;
@@ -285,6 +286,7 @@ export async function listModels(c, opts) {
 
   const result = Object.create(null);
   for (const id of validIds) {
+    if (id.endsWith(THINKING_SUFFIX) && ids.has(id.slice(0, -THINKING_SUFFIX.length))) continue;
     const hasTwin = !id.endsWith(THINKING_SUFFIX) && ids.has(id + THINKING_SUFFIX);
     result[id] = {
       id,

package/lib/usage.mjs

@@ -23,7 +23,26 @@ const USAGE_VARIABLES = {
     }]
   }
 };
-const USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36';
+// The browser the backend says it is when it reaches Google (gemini-web2api-go v4.22.0:
+// ChromeUA and applyChromeHeaders in client.go), so these reads come from the same client as
+// its own requests on the account. The TLS handshake is still Bun's, as the backend's own is
+// Go's when it goes through a proxy.
+const CLIENT_HEADERS = {
+  'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36',
+  'Accept-Language': 'en-US,en;q=0.9',
+  'Sec-CH-UA': '"Chromium";v="146", "Google Chrome";v="146", "Not?A_Brand";v="24"',
+  'Sec-CH-UA-Mobile': '?0',
+  'Sec-CH-UA-Platform': '"Windows"'
+};
+
+// When an account's pools are read again. They move only while the account is used, which the
+// backend records (usedAt, see poolAccounts), or when a window starts over; use from the Gemini
+// app itself is caught by USAGE_MAX_AGE_MS. No two reads of an account are closer than
+// USAGE_MIN_GAP_MS: Magpie set to read allowances automatically asks every few minutes, far
+// more often than a person opens the Usage page. A failed read stands that long too, so a
+// cookie Google turned away isn't asked about again on every refresh.
+export const USAGE_MIN_GAP_MS = 10 * 60 * 1000;
+export const USAGE_MAX_AGE_MS = 6 * 3600 * 1000;
 
 // The pools the Usage page shows, under the names Magpie gives the same windows elsewhere.
 const POOLS = [
@@ -45,12 +64,18 @@ async function openReadOnly(file) {
 }
 
 // poolAccounts lists the enabled accounts in the backend's pool, each with the proxy it is
-// bound to, if any.
+// bound to, if any, and whether that proxy is enabled (proxyEnabled), whether the pool has
+// proxies at all (pooled: disabled ones count, as they do for the backend), and when the
+// backend last used it (usedAt, Unix seconds): the later of when it last took the account for
+// a request and when it last finished one.
 export async function poolAccounts(dataDir = getDataDir()) {
   const db = await openReadOnly(path.join(dataDir, 'gemini.db'));
   try {
-    return db.all(`SELECT a.id, a.label, a.cookie, p.url AS proxy
-      FROM accounts a LEFT JOIN proxies p ON p.id = a.proxy_id AND p.enabled = 1
+    return db.all(`SELECT a.id, a.label, a.cookie, p.url AS proxy, p.enabled AS proxyEnabled,
+        EXISTS (SELECT 1 FROM proxies) AS pooled,
+        MAX(a.last_used_at, COALESCE((SELECT MAX(r.ts) FROM requests r
+          WHERE r.ts >= a.last_used_at AND r.account_id = a.id), 0)) AS usedAt
+      FROM accounts a LEFT JOIN proxies p ON p.id = a.proxy_id
       WHERE a.status = 'enabled' ORDER BY a.id`);
   } finally {
     db.close();
@@ -71,17 +96,49 @@ export function parseUsage(text) {
   throw new Error('Gemini 的回复里没有用量数据');
 }
 
-// geminiRequest is one signed-in request to gemini.google.com as the account, through the
-// proxy the backend bound it to. A redirect is Google sending a dead cookie to sign-in.
+// The variables that send Bun's fetch, or Node's with NODE_USE_ENV_PROXY, through a proxy
+// even when the request names none.
+const PROXY_ENV = ['HTTPS_PROXY', 'https_proxy', 'HTTP_PROXY', 'http_proxy', 'ALL_PROXY', 'all_proxy'];
+
+// egress is the proxy a read for the account goes through: the way the backend reaches Google
+// for it, since a read from anywhere else would show Google the session at a second address.
+// A read is made only when that way is certain, as poolAccounts tells it:
+//   - a pool without proxies (none at all, not just none enabled): the backend goes direct,
+//     and so does the read, unless proxy variables would take it elsewhere;
+//   - an account bound to an enabled proxy: that proxy, which its requests and keepalive both
+//     take. Only Bun's fetch takes a proxy (a fetchFn passed in stands for it), and only an
+//     HTTP(S) one;
+//   - anything else is unknown: an account not bound yet (the backend binds one on its first
+//     request, and keeps it alive direct until then), one bound to a disabled proxy (its
+//     requests take another, its keepalive still that one), or one poolAccounts didn't list.
+function egress(account, options) {
+  if (account.pooled == null) throw new Error('不知道后端给这个账号走哪个出口，先不读用量');
+  if (!account.pooled) {
+    const env = options.env ?? process.env;
+    const set = PROXY_ENV.find(k => env[k]);
+    if (set) throw new Error(`后端直连 Google，但这里设置了 ${set}，读取会改走代理，先不读用量`);
+    return undefined;
+  }
+  if (!account.proxy) throw new Error('这个账号还没绑定代理池里的出口（第一次请求后后端会自动绑定），先不读用量，免得从别的 IP 访问 Google');
+  if (!account.proxyEnabled) throw new Error('这个账号绑定的代理已停用，后端的请求和保活会走不同出口，先不读用量');
+  if (!/^https?:\/\//i.test(account.proxy) || !(options.fetchFn || globalThis.Bun)) {
+    throw new Error('这个账号绑定的代理插件用不了（只支持 HTTP / HTTPS 代理），不读用量，免得从别的 IP 访问 Google');
+  }
+  return account.proxy;
+}
+
+// geminiRequest is one signed-in request to gemini.google.com as the account, the way out the
+// backend takes (egress). It always names its proxy, none included: Magpie's host gives a fetch
+// that names none Magpie's own proxy, which the backend doesn't take. A redirect is Google
+// sending a dead cookie to sign-in.
 async function geminiRequest(url, account, headers, options) {
   const fetchFn = options.fetchFn || globalThis.fetch;
   const init = {
-    headers: { ...headers, Cookie: account.cookie, 'User-Agent': USER_AGENT },
+    headers: { ...CLIENT_HEADERS, ...headers, Cookie: account.cookie },
     redirect: 'manual',
+    proxy: egress(account, options),
     signal: AbortSignal.timeout(options.timeoutMs ?? 15000)
   };
-  // Bun's fetch takes an HTTP proxy; an account bound to one reaches Google only through it.
-  if (/^https?:\/\//i.test(account.proxy || '')) init.proxy = account.proxy;
   const res = await fetchFn(url, init);
   if (res.status >= 300 && res.status < 400 || res.status === 401 || res.status === 403) {
     throw new Error('Cookie 已失效，请重新走一遍一键配置');
@@ -96,21 +153,61 @@ export async function accountUsage(account, options = {}) {
   return parseUsage(await geminiRequest(url, account, {
     Accept: 'application/json',
     Origin: 'https://gemini.google.com',
-    Referer: 'https://gemini.google.com/usage'
+    Referer: 'https://gemini.google.com/usage',
+    'Sec-Fetch-Dest': 'empty',
+    'Sec-Fetch-Mode': 'cors',
+    'Sec-Fetch-Site': 'same-origin'
   }, options));
 }
 
+// The last read of each account: id -> { at, read, pools }, pools once it has succeeded.
+const reads = new Map();
+
+// due says whether the account's last read is to be made again (see USAGE_MIN_GAP_MS).
+function due(last, account, options) {
+  const now = Date.now();
+  const age = now - last.at;
+  if (age < (options.minGapMs ?? USAGE_MIN_GAP_MS)) return false;
+  if (!last.pools || age >= (options.maxAgeMs ?? USAGE_MAX_AGE_MS)) return true;
+  if ((account.usedAt ?? 0) >= Math.floor(last.at / 1000)) return true;
+  return last.pools.some(p => {
+    const at = Date.parse(p?.gxu?.windowRefreshesAt ?? '');
+    return at > last.at && at <= now;
+  });
+}
+
+function readUsage(account, options) {
+  const last = reads.get(account.id);
+  if (last && !due(last, account, options)) return last.read;
+  const entry = { at: Date.now() };
+  entry.read = accountUsage(account, options).then(u => ((entry.pools = u.pools), u));
+  reads.set(account.id, entry);
+  return entry.read;
+}
+
 // The Google account's email, from the signed-in app page's bootstrap data (WIZ_global_data's
-// oPEP7c), kept per backend account: the page is large and the email doesn't change.
-const emails = new Map();
+// oPEP7c), kept per backend account: the page is large and the email doesn't change. A page
+// that didn't give it is asked for again no sooner than USAGE_MAX_AGE_MS: the email only names
+// a card. An account with no certain way out (egress) isn't asked yet, and that isn't a try.
+const emails = new Map(); // id -> { email }, or { at } since the last try that got none
 const EMAIL_FIELD = /"oPEP7c":"([^"@\s]+@[^"\s]+)"/;
 
 export async function accountEmail(account, options = {}) {
   const known = emails.get(account.id);
-  if (known) return known;
-  const page = await geminiRequest('https://gemini.google.com/app', account, { Accept: 'text/html' }, options);
+  if (known?.email) return known.email;
+  if (known && Date.now() - known.at < (options.maxAgeMs ?? USAGE_MAX_AGE_MS)) return undefined;
+  egress(account, options);
+  emails.set(account.id, { at: Date.now() });
+  const page = await geminiRequest('https://gemini.google.com/app', account, {
+    Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+    'Sec-Fetch-Dest': 'document',
+    'Sec-Fetch-Mode': 'navigate',
+    'Sec-Fetch-Site': 'none',
+    'Sec-Fetch-User': '?1',
+    'Upgrade-Insecure-Requests': '1'
+  }, options);
   const email = EMAIL_FIELD.exec(page)?.[1];
-  if (email) emails.set(account.id, email);
+  if (email) emails.set(account.id, { email });
   return email;
 }
 
@@ -153,6 +250,7 @@ export function poolWindows(read) {
 // usage is the Magpie usage card: one account's 5-hour and weekly windows, as
 // gemini.google.com/usage shows them, when the sign-in names its backend account; else the
 // whole pool's, as one card. Accounts go by their Google emails (#id until that is known).
+// An account is read from Google again only when due (see USAGE_MIN_GAP_MS).
 // Magpie hides a card's windows behind an error, so a pool account that can't be read only
 // says so in the tooltip while the others still show.
 export async function usage(options = {}) {
@@ -165,11 +263,15 @@ export async function usage(options = {}) {
   if (options.account !== undefined) {
     accounts = accounts.filter(a => a.id === options.account);
     if (!accounts.length) return { error: `本地后端里已经没有这个账号（#${options.account}），可能被停用或删除了`, windows: [] };
+    // The sign-in already names its account's email: no app page to fetch for it.
+    if (typeof options.email === 'string' && options.email && !emails.get(options.account)?.email) {
+      emails.set(options.account, { email: options.email });
+    }
   }
   if (!accounts.length) return { error: '本地后端里没有启用的 Google 账号', windows: [] };
 
   const read = await Promise.all(accounts.map(async a => {
-    const [u, email] = await Promise.allSettled([accountUsage(a, options), accountEmail(a, options)]);
+    const [u, email] = await Promise.allSettled([readUsage(a, options), accountEmail(a, options)]);
     const who = (email.status === 'fulfilled' && email.value) || `#${a.id}`;
     return u.status === 'fulfilled' ? { who, windows: windowsOf(u.value.pools) } : { who, error: u.reason?.message || String(u.reason) };
   }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magpie-gemini-web",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "Gemini Web provider for Magpie, backed by gemini-web2api-go",
   "type": "module",
   "main": "./index.mjs",

package/patches/argon.patch

@@ -699,6 +699,53 @@ index 0000000..e5f1b6f
 +	}
 +	t.Fatal("没有记录这次请求")
 +}
+diff --git a/internal/app/client.go b/internal/app/client.go
+index 1750391..e613956 100644
+--- a/internal/app/client.go
++++ b/internal/app/client.go
+@@ -154,17 +154,32 @@ func makeSAPISIDHash(sapisid string) string {
+ 	return fmt.Sprintf("SAPISIDHASH %d_%s", ts, hex.EncodeToString(h[:]))
+ }
+ 
+-// ChromeUA 是给 stdlib 走代理时用的 Chrome 146 真实 UA 模板。
++// ChromeUA 是 Chrome 146 的真实 UA 模板。
+ const ChromeUA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36"
+ 
+-// applyChromeHeaders 给 stdlib 请求填上模拟 Chrome 146 的应用层 header。
+-// utls 那层做 TLS/HTTP2 指纹我们做不到（走代理），但 header 一定要齐。
++// chromeHeaders 是模拟 Chrome 146 的应用层 header，两条传输路径都要带齐：
++// 走代理时 utls 那层的 TLS/HTTP2 指纹我们做不到（stdlib），但 header 一定要齐；
++// 直连时 tls-client 只管指纹、不填 header，什么都不带的话 UA 是 Go-http-client/2.0，
++// 跟 Chrome 的握手对不上，同一个账号也会因为走没走代理而呈现两种客户端。
++var chromeHeaders = [][2]string{
++	{"User-Agent", ChromeUA},
++	{"Sec-CH-UA", `"Chromium";v="146", "Google Chrome";v="146", "Not?A_Brand";v="24"`},
++	{"Sec-CH-UA-Mobile", "?0"},
++	{"Sec-CH-UA-Platform", `"Windows"`},
++	{"Sec-Fetch-Dest", "empty"},
++	{"Sec-Fetch-Mode", "cors"},
++	{"Sec-Fetch-Site", "same-origin"},
++}
++
++// setChromeHeaders 把 chromeHeaders 填进 net/http 或 fhttp 的 Header（两者都有 Set）。
++// 调用方之后再写自己的 header，同名的以调用方为准。
++func setChromeHeaders(h interface{ Set(key, value string) }) {
++	for _, kv := range chromeHeaders {
++		h.Set(kv[0], kv[1])
++	}
++}
++
++// applyChromeHeaders 给 stdlib 请求填上 chromeHeaders。
+ func applyChromeHeaders(req *http.Request) {
+-	req.Header.Set("User-Agent", ChromeUA)
+-	req.Header.Set("Sec-CH-UA", `"Chromium";v="146", "Google Chrome";v="146", "Not?A_Brand";v="24"`)
+-	req.Header.Set("Sec-CH-UA-Mobile", "?0")
+-	req.Header.Set("Sec-CH-UA-Platform", `"Windows"`)
+-	req.Header.Set("Sec-Fetch-Dest", "empty")
+-	req.Header.Set("Sec-Fetch-Mode", "cors")
+-	req.Header.Set("Sec-Fetch-Site", "same-origin")
++	setChromeHeaders(req.Header)
+ }
 diff --git a/internal/app/context_file.go b/internal/app/context_file.go
 index bfc577b..cb60661 100644
 --- a/internal/app/context_file.go
@@ -779,7 +826,7 @@ index bfc577b..cb60661 100644
 +	return promptParts{body: parts}.join()
  }
 diff --git a/internal/app/conversation.go b/internal/app/conversation.go
-index aef12eb..cbf1371 100644
+index aef12eb..8ba963f 100644
 --- a/internal/app/conversation.go
 +++ b/internal/app/conversation.go
 @@ -1,6 +1,7 @@
@@ -790,7 +837,23 @@ index aef12eb..cbf1371 100644
  	"crypto/sha256"
  	"encoding/hex"
  	"encoding/json"
-@@ -244,8 +245,11 @@ const webUA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 " +
+@@ -205,7 +206,7 @@ func getAnonSession(proxyURL string) (string, error) {
+ 		if err != nil {
+ 			return nil, nil, nil, err
+ 		}
+-		r.Header.Set("User-Agent", webUA)
++		setChromeHeaders(r.Header)
+ 		resp, err := getTLSClient().Do(r)
+ 		if err != nil {
+ 			return nil, nil, nil, err
+@@ -237,15 +238,14 @@ func getAnonSession(proxyURL string) (string, error) {
+ 	return strings.Join(pairs, "; "), nil
+ }
+ 
+-// webUA 是匿名 GET /app 的 User-Agent（tls-client 路径要手动带）。
+-const webUA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 " +
+-	"(KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36"
+-
  // streamGenerateConv 发一路会话的一轮。turn==0 是首轮（建会话），>0 是续接（只发新消息）。
  // 整条会话绑定 conv.cookie / conv.proxyID，中途不换号不换出口。成功后回填 conv 的
  // cid/rid/rcid/tok26 和 turn+1，供下一轮续接。
@@ -803,7 +866,7 @@ index aef12eb..cbf1371 100644
  	p, slotOK, slotErr := acquireSlot(conv.proxyID)
  	if !slotOK {
  		return &StreamResult{}, slotErr
-@@ -365,13 +369,19 @@ func streamGenerateConv(prompt string, mc ModelConfig, conv *convState,
+@@ -365,13 +365,19 @@ func streamGenerateConv(prompt string, mc ModelConfig, conv *convState,
  	t0 := time.Now()
  	var lastErr error
  	for attempt := 0; attempt < rtCfg().RetryAttempts; attempt++ {
@@ -824,7 +887,7 @@ index aef12eb..cbf1371 100644
  			if err == nil && statusCode == 200 {
  				lastErr = fmt.Errorf("续接无内容帧（会话可能已失效，raw %d 字节）", len(raw))
  			} else if err != nil {
-@@ -386,7 +396,9 @@ func streamGenerateConv(prompt string, mc ModelConfig, conv *convState,
+@@ -386,7 +392,9 @@ func streamGenerateConv(prompt string, mc ModelConfig, conv *convState,
  				break
  			}
  			if attempt < rtCfg().RetryAttempts-1 {
@@ -835,7 +898,7 @@ index aef12eb..cbf1371 100644
  			}
  			continue
  		}
-@@ -427,7 +439,7 @@ func streamGenerateConv(prompt string, mc ModelConfig, conv *convState,
+@@ -427,7 +435,7 @@ func streamGenerateConv(prompt string, mc ModelConfig, conv *convState,
  //   - 没命中 → 新建会话，首轮发全量拼接的历史（含 tools 指令，把当前上下文交给服务端）。
  //
  // 支持 tools（续接里也解析 ```tool_call``` 围栏）；图片走原单轮路径（callGemini）。
@@ -844,7 +907,7 @@ index aef12eb..cbf1371 100644
  	tools []map[string]interface{}, toolChoice interface{},
  	onDelta, onReasoning func(string)) (string, []ToolCall, *StreamResult, error) {
  	parentKey := convParentKey(messages)
-@@ -462,7 +474,7 @@ func callGeminiConv(messages []map[string]interface{}, mc ModelConfig,
+@@ -462,7 +470,7 @@ func callGeminiConv(messages []map[string]interface{}, mc ModelConfig,
  		logf("[conv] 续接命中 turn=%d，只发 %d 字节（历史留服务端）", conv.turn, len(prompt))
  	}
  
@@ -854,7 +917,7 @@ index aef12eb..cbf1371 100644
  		if !fresh {
  			// 续接失败：这路会话作废，客户端重试时会当新会话全量重发。
 diff --git a/internal/app/gemini.go b/internal/app/gemini.go
-index 723725f..a1e5221 100644
+index 723725f..150b022 100644
 --- a/internal/app/gemini.go
 +++ b/internal/app/gemini.go
 @@ -3,6 +3,7 @@ package app
@@ -1148,7 +1211,7 @@ index 723725f..a1e5221 100644
  		if err != nil {
  			return resp.StatusCode, nil, ttfb, resp.Header.Values("Set-Cookie"), err
  		}
-@@ -844,7 +944,7 @@ func doGeminiRequest(endpoint, body string, headers map[string]string, proxyURL
+@@ -844,10 +944,11 @@ func doGeminiRequest(endpoint, body string, headers map[string]string, proxyURL
  	}
  
  	// 直连 → tls-client，保留 chrome146 TLS/HTTP2 真指纹
@@ -1157,7 +1220,11 @@ index 723725f..a1e5221 100644
  	if err != nil {
  		return 0, nil, 0, nil, err
  	}
-@@ -857,7 +957,7 @@ func doGeminiRequest(endpoint, body string, headers map[string]string, proxyURL
++	setChromeHeaders(req.Header)
+ 	for k, v := range headers {
+ 		req.Header.Set(k, v)
+ 	}
+@@ -857,7 +958,7 @@ func doGeminiRequest(endpoint, body string, headers map[string]string, proxyURL
  		return 0, nil, 0, nil, err
  	}
  	defer resp.Body.Close()
@@ -1166,6 +1233,14 @@ index 723725f..a1e5221 100644
  	if err != nil {
  		return resp.StatusCode, nil, ttfb, resp.Header.Values("Set-Cookie"), err
  	}
+@@ -1159,6 +1260,7 @@ func probeGemini(prompt, proxyURL string) ProbeResult {
+ 			res.Diagnostic = "构建请求失败: " + e.Error()
+ 			return res
+ 		}
++		setChromeHeaders(req.Header)
+ 		for k, v := range headers {
+ 			req.Header.Set(k, v)
+ 		}
 diff --git a/internal/app/gemini_test.go b/internal/app/gemini_test.go
 index 00eb305..2b4c6ca 100644
 --- a/internal/app/gemini_test.go
@@ -1178,12 +1253,114 @@ index 00eb305..2b4c6ca 100644
  	}
  	for _, c := range cases {
  		name, mc, err := resolveModel(c.name)
+diff --git a/internal/app/headers_test.go b/internal/app/headers_test.go
+new file mode 100644
+index 0000000..b80a9fa
+--- /dev/null
++++ b/internal/app/headers_test.go
+@@ -0,0 +1,96 @@
++package app
++
++import (
++	"context"
++	"net/http"
++	"net/http/httptest"
++	"testing"
++
++	tls_client "github.com/bogdanfinn/tls-client"
++)
++
++// 同一个账号的请求不能因为走没走代理而呈现两种客户端：两条路径都要带齐 chromeHeaders，
++// 调用方自己的 header 照样生效。直连那条以前一个都不带，UA 是 Go-http-client/2.0。
++//
++// 直连走 tls-client，这里换成跳过证书校验的同款客户端，打本机的 HTTPS 测试服务器；
++// 代理那条把 http:// 目标以绝对 URI 发给代理，测试服务器本身就能当代理（同 cancel_test）。
++func TestDirectAndProxyPathsSendSameBrowserHeaders(t *testing.T) {
++	got := map[string]http.Header{}
++	record := func(name string) http.Handler {
++		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
++			got[name] = r.Header.Clone()
++			w.WriteHeader(200)
++		})
++	}
++	direct := httptest.NewUnstartedServer(record("direct"))
++	direct.EnableHTTP2 = true
++	direct.StartTLS()
++	defer direct.Close()
++	proxy := httptest.NewServer(record("proxy"))
++	defer proxy.Close()
++
++	key := rtCfg().Impersonate
++	insecure, err := tls_client.NewHttpClient(tls_client.NewNoopLogger(),
++		tls_client.WithClientProfile(resolveProfile(key)),
++		tls_client.WithInsecureSkipVerify(),
++		tls_client.WithNotFollowRedirects())
++	if err != nil {
++		t.Fatal(err)
++	}
++	clientCacheMu.Lock()
++	prev, had := clientCache[key]
++	clientCache[key] = insecure
++	clientCacheMu.Unlock()
++	t.Cleanup(func() {
++		clientCacheMu.Lock()
++		defer clientCacheMu.Unlock()
++		if had {
++			clientCache[key] = prev
++		} else {
++			delete(clientCache, key)
++		}
++	})
++
++	own := map[string]string{"Accept-Language": "en-US,en;q=0.9", "X-Same-Domain": "1"}
++	paths := []struct {
++		name string
++		send func(endpoint, proxyURL string)
++	}{
++		{"StreamGenerate", func(endpoint, proxyURL string) {
++			doGeminiRequestStop(context.Background(), endpoint, "f.req=x", own, proxyURL, nil, nil)
++		}},
++		{"upload", func(endpoint, proxyURL string) {
++			uploadPostCtx(context.Background(), endpoint, own, []byte("x"), proxyURL)
++		}},
++		{"media", func(endpoint, proxyURL string) {
++			mediaGetOnce(endpoint, own, proxyURL)
++		}},
++		{"image", func(endpoint, proxyURL string) {
++			fetchImage(endpoint, proxyURL, 0)
++		}},
++	}
++	for _, p := range paths {
++		clear(got)
++		p.send(direct.URL+"/x", "")
++		p.send("http://upstream.invalid/x", proxy.URL)
++		d, pr := got["direct"], got["proxy"]
++		if d == nil || pr == nil {
++			t.Fatalf("%s: 没收到请求（direct=%v proxy=%v）", p.name, d != nil, pr != nil)
++		}
++		if ua := d.Get("User-Agent"); ua != ChromeUA {
++			t.Errorf("%s: 直连 UA = %q", p.name, ua)
++		}
++		for _, kv := range chromeHeaders {
++			if d.Get(kv[0]) != pr.Get(kv[0]) {
++				t.Errorf("%s: %s 直连 %q，代理 %q", p.name, kv[0], d.Get(kv[0]), pr.Get(kv[0]))
++			}
++		}
++		if p.name != "image" {
++			for k, v := range own {
++				if d.Get(k) != v || pr.Get(k) != v {
++					t.Errorf("%s: 调用方的 %s 没生效（直连 %q，代理 %q）", p.name, k, d.Get(k), pr.Get(k))
++				}
++			}
++		}
++	}
++}
 diff --git a/internal/app/latency_test.go b/internal/app/latency_test.go
 new file mode 100644
-index 0000000..9329309
+index 0000000..b30336f
 --- /dev/null
 +++ b/internal/app/latency_test.go
-@@ -0,0 +1,299 @@
+@@ -0,0 +1,297 @@
 +package app
 +
 +import (
@@ -1406,17 +1583,15 @@ index 0000000..9329309
 +	}
 +}
 +
-+// 轮转后重取失败时必须作废缓存，否则失效的号会一直拿着旧 token 被当成可用。
-+func TestRefreshXSRFFailureDropsCache(t *testing.T) {
++// 后台重取失败时必须作废缓存，否则失效的号会一直拿着旧 token 被当成可用。
++func TestRefreshAppTokensFailureDropsCache(t *testing.T) {
 +	cookie := "SAPISID=sap2; __Secure-1PSID=psid2"
 +	xsrfMu.Lock()
 +	xsrfCache[cookieKey(cookie)] = xsrfEntry{token: "stale", fetched: time.Now()}
 +	xsrfMu.Unlock()
 +	t.Cleanup(func() { invalidateXSRF(cookie) })
 +
-+	if err := refreshXSRF(cookie, "http://127.0.0.1:1"); err == nil {
-+		t.Fatal("不可达出口应报错")
-+	}
++	refreshAppTokens(cookieKey(cookie), cookie, "http://127.0.0.1:1")
 +	xsrfMu.Lock()
 +	_, ok := xsrfCache[cookieKey(cookie)]
 +	xsrfMu.Unlock()
@@ -1483,6 +1658,18 @@ index 0000000..9329309
 +		t.Fatalf("非流式: stop=%v reads=%d tracker=%q", lh.stop.Load(), src.reads, lh.tracker.emitted)
 +	}
 +}
+diff --git a/internal/app/media.go b/internal/app/media.go
+index 9844778..03610f9 100644
+--- a/internal/app/media.go
++++ b/internal/app/media.go
+@@ -505,6 +505,7 @@ func mediaGetOnce(rawURL string, headers map[string]string, proxyURL string) (in
+ 	if err != nil {
+ 		return 0, nil, nil, err
+ 	}
++	setChromeHeaders(req.Header)
+ 	for k, v := range headers {
+ 		req.Header.Set(k, v)
+ 	}
 diff --git a/internal/app/messages.go b/internal/app/messages.go
 index 376171f..87b91fe 100644
 --- a/internal/app/messages.go
@@ -1680,26 +1867,6 @@ index 376171f..87b91fe 100644
  // parseToolChoice 解析 OpenAI 的 tool_choice。
  // 返回 (mode, forcedName)：mode ∈ {"auto","none","required"}；
  // forcedName 非空表示客户端点名了某个函数。
-diff --git a/internal/app/rotate.go b/internal/app/rotate.go
-index e082b15..908a052 100644
---- a/internal/app/rotate.go
-+++ b/internal/app/rotate.go
-@@ -95,7 +95,14 @@ func rotateAccount(a CookieAccount) (time.Duration, []string, error) {
- 	if cookie != a.Cookie {
- 		old := a.Cookie
- 		updateAccountCookie(a.ID, cookie)
--		invalidateXSRF(old)
-+		// 轮转本身不在请求路径上，顺手用新 cookie 重取 token：既验证轮转结果，
-+		// 又让下一个请求直接命中缓存。失败时缓存已作废，下个请求同步重取。
-+		if err := refreshXSRF(cookie, proxyURL); err != nil {
-+			logf("[rotate] 账号 #%d 轮转后取 XSRF 失败: %v", a.ID, err)
-+		}
-+		if cookieKey(old) != cookieKey(cookie) {
-+			invalidateXSRF(old) // 身份项都变了（理论上不会）：旧键别留着
-+		}
- 	}
- 	if len(names) > 0 {
- 		logf("[rotate] 账号 #%d 刷新了 %s", a.ID, strings.Join(names, ", "))
 diff --git a/internal/app/server.go b/internal/app/server.go
 index c3a7df1..eb02909 100644
 --- a/internal/app/server.go
@@ -1808,7 +1975,7 @@ index c3a7df1..eb02909 100644
  		if stream {
  			writeEvent("response.failed", map[string]interface{}{
 diff --git a/internal/app/upload.go b/internal/app/upload.go
-index 7747a72..09e8a04 100644
+index 7747a72..2753f93 100644
 --- a/internal/app/upload.go
 +++ b/internal/app/upload.go
 @@ -2,6 +2,7 @@ package app
@@ -1865,7 +2032,7 @@ index 7747a72..09e8a04 100644
  		if err != nil {
  			return 0, nil, nil, err
  		}
-@@ -131,7 +142,7 @@ func uploadPost(url string, headers map[string]string, body []byte, proxyURL str
+@@ -131,10 +142,11 @@ func uploadPost(url string, headers map[string]string, body []byte, proxyURL str
  		}
  		return resp.StatusCode, h, b, err
  	}
@@ -1874,6 +2041,10 @@ index 7747a72..09e8a04 100644
  	if err != nil {
  		return 0, nil, nil, err
  	}
++	setChromeHeaders(req.Header)
+ 	for k, v := range headers {
+ 		req.Header.Set(k, v)
+ 	}
 diff --git a/internal/app/videos.go b/internal/app/videos.go
 index 390b580..0365a78 100644
 --- a/internal/app/videos.go
@@ -1895,8 +2066,20 @@ index 390b580..0365a78 100644
  	if err != nil {
  		recordRequest("videos", j.Model, j.Prompt, "", res, 502, err.Error(), false)
  		finishVideoJob(j, nil, "", err.Error())
+diff --git a/internal/app/vision.go b/internal/app/vision.go
+index b0c9724..b1ca7cb 100644
+--- a/internal/app/vision.go
++++ b/internal/app/vision.go
+@@ -160,6 +160,7 @@ func fetchImage(src, proxyURL string, idx int) (pendingUpload, error) {
+ 		if err != nil {
+ 			return pendingUpload{}, err
+ 		}
++		setChromeHeaders(req.Header)
+ 		resp, err := getTLSClient().Do(req)
+ 		if err != nil {
+ 			return pendingUpload{}, fmt.Errorf("image %d: fetch failed: %w", idx, err)
 diff --git a/internal/app/xsrf.go b/internal/app/xsrf.go
-index c43b104..55634b6 100644
+index c43b104..d3d7145 100644
 --- a/internal/app/xsrf.go
 +++ b/internal/app/xsrf.go
 @@ -27,15 +27,23 @@ var (
@@ -1961,7 +2144,7 @@ index c43b104..55634b6 100644
  
  	e, err := fetchAppTokens(cookie, proxyURL)
  	if err != nil {
-@@ -84,16 +99,59 @@ func getXSRF(cookie, proxyURL string) (string, error) {
+@@ -84,16 +99,48 @@ func getXSRF(cookie, proxyURL string) (string, error) {
  	return e.token, nil
  }
  
@@ -1988,17 +2171,6 @@ index c43b104..55634b6 100644
 +	}
 +}
 +
-+// refreshXSRF 立即重抓页面并写回缓存，失败则作废缓存。
-+//
-+// 给本来就不在请求关键路径上的调用方用（cookie 轮转）：轮转后直接作废的话，
-+// 缓存按账号身份取键，下一个请求就得同步抓一次页面（实测约 1.2 秒）。
-+func refreshXSRF(cookie, proxyURL string) error {
-+	if cookie == "" {
-+		return nil
-+	}
-+	return storeAppTokens(cookieKey(cookie), cookie, proxyURL)
-+}
-+
 +func storeAppTokens(key, cookie, proxyURL string) error {
 +	e, err := fetchAppTokens(cookie, proxyURL)
 +	xsrfMu.Lock()
@@ -2025,3 +2197,11 @@ index c43b104..55634b6 100644
  
  	e, err := fetchAppTokens(cookie, proxyURL)
  	if err != nil {
+@@ -146,6 +193,7 @@ func fetchAppPage(cookie, proxyURL string) ([]byte, error) {
+ 		if err != nil {
+ 			return nil, err
+ 		}
++		setChromeHeaders(req.Header)
+ 		for k, v := range headers {
+ 			req.Header.Set(k, v)
+ 		}

package/scripts/backend-argon.mjs

@@ -41,7 +41,7 @@ async function main() {
       const sha256 = crypto.createHash('sha256').update(bytes).digest('hex');
 
       const manifest = {
-        version: '4.22.0-argon.1',
+        version: '4.22.0-argon.2',
         sourceCommit: pinned,
         sha256,
         platform: 'darwin',