magpie-gemini-web 0.3.2 → 0.4.0

package/README.en.md

@@ -26,15 +26,15 @@ From then on, Magpie starts the backend automatically every time it launches. To
 
 ## Plugin options
 
-Tool calls and image input are off by default. Turn them on if a coding agent needs tools:
+Tool calls are on by default (coding agents send tools with every request); image input is off. To allow images:
 
 ```bash
-magpie plugin options magpie-gemini-web '{"allowTools":true,"allowImages":true}'
+magpie plugin options magpie-gemini-web '{"allowImages":true}'
 ```
 
 | Option | Default | Description |
 | :--- | :--- | :--- |
-| `allowTools` | `false` | Allows tool calls (experimental). When off, requests with tools get a 400 |
+| `allowTools` | `true` | Allows tool calls (experimental; upstream emulates them with prompts). When `false`, requests with tools get a 400 |
 | `allowImages` | `false` | Allows image input |
 | `baseURL` | `http://127.0.0.1:8083/v1` | Default backend URL |
 | `contextLimit` / `outputLimit` | `1000000` / `8192` | Context and output limits reported to clients |
@@ -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,14 +61,29 @@ 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.
 - Only text models whose names start with `gemini-` are exposed. A `cost` of 0 doesn't reflect your actual Google quota.
 
+## Native Task on macOS (experimental)
+
+On macOS, sign-in offers one more option, "macOS 原生 Task（实验性）": requests skip the Gemini Web backend and go to a local daemon that runs them in Gemini.app's own Task mode, with tool calls on its native Function Calling channel, as the model `gemini-task-argon`. Windows and Linux don't offer it; keep using one-click setup there.
+
+This is an alpha: it supports only the verified Gemini.app build, needs a local setup first (Gemini.app signed in, plus session templates), hasn't passed an end-to-end check against real Argon yet, and shows no usage. See [native-task/README.md](native-task/README.md) for setup, session requirements and limitations.
+
 ## 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 +96,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

@@ -26,15 +26,15 @@
 
 ## 插件选项
 
-工具调用和图片输入默认关闭，Coding Agent 需要工具时请开启：
+工具调用默认开启（Coding Agent 每个请求都带工具），图片输入默认关闭。需要图片输入时：
 
 ```bash
-magpie plugin options magpie-gemini-web '{"allowTools":true,"allowImages":true}'
+magpie plugin options magpie-gemini-web '{"allowImages":true}'
 ```
 
 | 选项 | 默认值 | 说明 |
 | :--- | :--- | :--- |
-| `allowTools` | `false` | 允许工具调用（实验性）。关闭时带工具的请求会返回 400 |
+| `allowTools` | `true` | 允许工具调用（实验性，由上游用提示词模拟）。设为 `false` 时带工具的请求会返回 400 |
 | `allowImages` | `false` | 允许图片输入 |
 | `baseURL` | `http://127.0.0.1:8083/v1` | 默认后端地址 |
 | `contextLimit` / `outputLimit` | `1000000` / `8192` | 向客户端声明的上下文 / 输出上限 |
@@ -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,14 +61,29 @@ Magpie 的额度卡片会显示 Google 账号的 **5 小时** 和 **每周** 用
 
 注意：请求最终由后端在账号池里轮流挑选 Google 账号，Magpie 在几张卡片之间怎么分配请求，不决定实际用的是哪个账号。只有一键配置的本地后端能显示用量；「连接已有后端」模式下读不到账号的 Cookie。
 
+为了少向 Google 发请求，用量不会每次刷新都去查：账号经后端用过、或者某个窗口到了重置时间，才重新读取，两次至少间隔 10 分钟；账号闲着时最多每 6 小时读一次（顺带反映你在 Gemini 网页里的用量）。
+
+读取用量和邮箱时，走的是后端访问 Google 的同一个出口。出口不确定时不读取，卡片上会写明原因：
+
+- 配了代理池，但账号还没绑定代理（后端在它第一次请求时绑定）；
+- 账号绑定的代理已停用，或者是 SOCKS 代理。
+
+所以配了代理池时，一键配置刚添加的账号暂时没有邮箱。先用它发一次请求，再用「添加本地后端里已有的 Google 账号」重新登录它，然后删掉没有邮箱的那个登录。
+
 ## 局限
 
 - 工具调用由上游用提示词模拟，不一定可靠，Flash 系列经常不调用工具。
 - 只开放 `gemini-` 开头的文本模型；`cost` 显示为 0 不代表 Google 的实际配额。
 
+## macOS 原生 Task（实验性）
+
+在 macOS 上登录时会多出一个「macOS 原生 Task（实验性）」选项：请求不走 Gemini Web 后端，而是交给本机常驻服务，由 Gemini.app 自己的 Task 模式执行，工具调用走原生的 Function Calling 通道，模型为 `gemini-task-argon`。Windows 和 Linux 上不会出现这个选项，请继续使用上面的一键配置。
+
+当前为 Alpha：仅支持已验证的 Gemini.app 版本，选这个选项之前需要先在本机完成 setup（需要 Gemini.app 已登录，以及会话模板），尚未完成真实 Argon 的端到端验收，读不到额度。配置步骤、会话要求和限制见 [native-task/README.md](native-task/README.md)。
+
 ## 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 +96,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,8 @@
 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';
+import { taskSupported, taskMethod, taskLoader, taskModels, isTaskAuth } from './lib/task.mjs';
 
 const ID = 'gemini-web';
 const GEMINI_URL = 'https://gemini.google.com/app';
@@ -22,7 +23,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 +99,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 });
             }
           };
         }
@@ -155,9 +159,10 @@ export const GeminiWebPlugin = async (_input, options = {}) => {
             callback: async () => signInFor(local, chosen)
           };
         }
-      }],
+      }, ...(taskSupported() ? [taskMethod] : [])],
       async loader(getAuth) {
         const auth = await getAuth();
+        if (isTaskAuth(auth)) return taskLoader(auth);
         if (auth?.type !== 'api') return {};
         const c = credentials(auth, opts);
         return {
@@ -173,6 +178,7 @@ export const GeminiWebPlugin = async (_input, options = {}) => {
       async usage(getAuth) {
         const auth = await getAuth();
         if (auth?.type !== 'api') return { error: 'Gemini Web 还没有登录', windows: [], signIn: 'kept' };
+        if (isTaskAuth(auth)) return { error: '原生 Task 登录读不到额度', windows: [], signIn: 'kept' };
         let c;
         try {
           c = credentials(auth, opts);
@@ -182,14 +188,15 @@ 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: {
       id: ID,
       async models(provider, { auth } = {}) {
         if (auth?.type !== 'api') return provider.models;
+        if (isTaskAuth(auth)) return taskModels(auth, ID);
         const c = credentials(auth, opts);
         try {
           return await listModels(c, opts);
@@ -199,6 +206,16 @@ export const GeminiWebPlugin = async (_input, options = {}) => {
           return listModels(c, opts);
         }
       }
+    },
+    // The Task bridge keeps a conversation's state by its session, so each request carries the
+    // host's session id. The Web backend's forward() passes on only the headers it needs, so
+    // this doesn't reach it.
+    async 'chat.headers'(input, output) {
+      if (input?.model?.providerID !== ID && input?.provider?.info?.id !== ID) return;
+      if (typeof input.sessionID === 'string' && input.sessionID) {
+        output.headers ??= {};
+        output.headers['X-Gemini-Session'] = input.sessionID;
+      }
     }
   };
 };

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;
@@ -114,7 +115,9 @@ export function settings(options = {}) {
     baseURL = normalizeBaseURL(options.baseURL);
   }
 
-  let allowTools = false;
+  // On by default: coding agents send tools with every request and don't read toolcall,
+  // so turning this off only means every one of their requests gets a 400.
+  let allowTools = true;
   if (options.allowTools !== undefined) {
     if (typeof options.allowTools !== 'boolean') {
       throw new Error('Invalid option allowTools: must be a boolean');
@@ -285,6 +288,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,
@@ -438,7 +442,7 @@ export async function forward(input, init, getAuth, opts) {
     const hasTools = (Array.isArray(body.tools) && body.tools.length > 0) ||
                      (Array.isArray(body.functions) && body.functions.length > 0);
     if (!opts.allowTools && hasTools) {
-      return makeOpenAIError(400, 'Experimental tools are disabled; set allowTools: true');
+      return makeOpenAIError(400, `Tool calls are turned off for magpie-gemini-web. Turn them on with: magpie plugin options magpie-gemini-web '{"allowTools":true}'`);
     }
 
     if (body.messages !== undefined) {
@@ -460,7 +464,7 @@ export async function forward(input, init, getAuth, opts) {
               }
             } else if (part.type === 'image_url') {
               if (!opts.allowImages) {
-                return makeOpenAIError(400, 'Image input is disabled; set allowImages: true');
+                return makeOpenAIError(400, `Image input is turned off for magpie-gemini-web. Turn it on with: magpie plugin options magpie-gemini-web '{"allowImages":true}'`);
               }
               if (!part.image_url || typeof part.image_url.url !== 'string' || !part.image_url.url.trim()) {
                 return makeOpenAIError(400, 'Image content must contain an image_url URL');

package/lib/task.mjs

@@ -0,0 +1,87 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createForwarder, ensureService, getDefaultDataDir } from '../native-task/lib/runtime.mjs';
+
+// The experimental Task route: on macOS, a sign-in can go to the native-task bridge (see
+// native-task/), which runs Gemini.app's own Task mode, instead of the Gemini Web backend.
+// The sign-in says which with metadata.mode.
+
+export const TASK_MODE = 'task';
+export const TASK_MODEL = 'gemini-task-argon';
+
+const BRIDGE_CLI = fileURLToPath(new URL('../native-task/scripts/bridge.mjs', import.meta.url));
+
+// taskSupported is whether this computer can run the bridge: it drives Gemini.app for macOS.
+export function taskSupported(platform = process.platform) {
+  return platform === 'darwin';
+}
+
+export function isTaskAuth(auth) {
+  return auth?.type === 'api' && auth.metadata?.mode === TASK_MODE;
+}
+
+// startTask starts the bridge set up in dataDir. The bridge's setup needs files only a capture
+// gives, so the plugin can't run it: without one, the error says how.
+async function startTask(dataDir = getDefaultDataDir()) {
+  if (!fs.existsSync(path.join(dataDir, 'config.json'))) {
+    throw new Error(`还没有配置本机 Task 服务（${dataDir}）。先在终端运行 node "${BRIDGE_CLI}" setup，需要的文件见 native-task/README.md`);
+  }
+  return ensureService({ dataDir });
+}
+
+// taskMethod is the Magpie sign-in method for the bridge.
+export const taskMethod = {
+  type: 'oauth',
+  label: 'macOS 原生 Task（实验性，需先完成本机 setup）',
+  async authorize() {
+    const service = await startTask();
+    return {
+      url: '',
+      method: 'auto',
+      instructions: '',
+      callback: async () => ({
+        type: 'success',
+        key: service.apiKey,
+        accountId: `native:${service.instance_id}`,
+        metadata: { mode: TASK_MODE, baseURL: `${service.baseURL}/v1`, dataDir: service.dataDir }
+      })
+    };
+  }
+};
+
+// taskLoader is the auth loader for a Task sign-in: requests go to the bridge, starting it when
+// it isn't running.
+export async function taskLoader(auth) {
+  const service = await startTask(auth.metadata?.dataDir);
+  if (auth.key !== service.apiKey) {
+    throw Object.assign(new Error('本机 Task 服务的密钥变了，请重新登录'), { signIn: 'expired' });
+  }
+  return { apiKey: auth.key, baseURL: `${service.baseURL}/v1`, fetch: createForwarder(service) };
+}
+
+// taskModels is the one model the bridge serves, in the shape listModels gives.
+export function taskModels(auth, providerID) {
+  return {
+    [TASK_MODEL]: {
+      id: TASK_MODEL,
+      providerID,
+      name: 'Argon Task',
+      api: { id: TASK_MODEL, url: auth.metadata?.baseURL, npm: '@ai-sdk/openai-compatible' },
+      limit: { context: 65536, output: 8192 },
+      capabilities: {
+        temperature: false,
+        reasoning: false,
+        attachment: false,
+        toolcall: true,
+        input: { text: true, image: false },
+        output: { text: true }
+      },
+      cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+      options: {},
+      headers: {},
+      variants: {},
+      status: 'active'
+    }
+  };
+}

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/native-task/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 magpie-gemini-web contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.