magpie-gemini-web 0.5.5 → 0.6.0

package/README.en.md

@@ -14,10 +14,10 @@ The plugin provides two independent providers that can be used individually or t
 | :--- | :--- | :--- |
 | **Best for** | **Coding agents (recommended)** | General chat, web-only models & web quota |
 | **Tool calling** | **Native Function Calling**, reliable | Prompt-emulated (experimental; Flash often skips tools) |
-| **Thinking levels** | `minimal` / `low` / `medium` / `high` (`minimal` is fastest & cheapest) | `low` (base) / `high` (`-thinking` extended thinking) |
+| **Thinking levels** | `minimal` / `low` / `medium` / `high` (`minimal` is fastest & cheapest) | `low` (base) / `medium` (`-thinking-medium`, `gemini-4-argon` only) / `high` (`-thinking` extended thinking) |
 | **Sign-in method** | Sign in directly in an isolated popup browser window | Copy `cookie` from a private/incognito window |
 | **Usage cards** | Shows models currently on cooldown and recovery times | Syncs **5-hour** & **weekly** usage and reset times from the web |
-| **Local backend** | AIStudio2API (`v0.2.14`) | gemini-web2api-go (`4.22.0-magpie.1` optimized build) |
+| **Local backend** | AIStudio2API (`v0.2.16`) | gemini-web2api-go (`4.26.0-magpie.1` optimized build) |
 
 ---
 
@@ -34,7 +34,7 @@ Install **magpie-gemini-web** from the Magpie plugin market, then sign in to eit
 
 ### Option 2: Gemini Web (`gemini-web`)
 
-1. Sign in to **Gemini Web** in Magpie and choose **「一键配置本地 Gemini Web（推荐）」** (One-click local setup).
+1. Sign in to **Gemini Web** in Magpie and choose **「一键配置本地 Gemini Web（推荐）」** (One-click local setup). If you need a proxy to reach Google, enter its URL (e.g. `http://127.0.0.1:7890`) when prompted at the start of sign-in, or leave it blank for direct connection / existing proxy pool.
 2. Copy your cookie using a **private / incognito window** (Firefox recommended):
    1. Open <https://gemini.google.com/app> in the private window and sign in to your Google account.
    2. Press `F12` (`⌥⌘I` on macOS), switch to the **Network** tab, and reload the page.
@@ -42,6 +42,8 @@ Install **magpie-gemini-web** from the Magpie plugin market, then sign in to eit
    4. **Close the private window directly—do not sign out** (signing out invalidates the cookie).
 3. The plugin verifies the account and completes sign-in. Repeat the steps above to add more accounts.
 
+> **Backend upgrade required during sign-in?** An older background process may still be running. Exit Magpie, stop the matching `gemini-web2api-go` process (Windows: Task Manager → Details → `gemini-web2api-go.exe`), then run the full installation command shown in the error. It preserves accounts and configuration and selects the plugin's managed backend. Set `GEMINI_WEB_PROXY` first if the download needs a proxy. Reopen Magpie and sign in after installation.
+
 > **Why is a private window required?** The backend periodically refreshes this session to keep it alive. If it shares a session with your daily browser, Google will revoke the session and sign your browser out of all Google services. A private window (or a dedicated secondary Google account) gives the backend an isolated session.
 
 ---
@@ -84,6 +86,7 @@ magpie plugin options magpie-gemini-web '{"studio":{"proxy":"http://127.0.0.1:78
 | `allowImages` | `false` | Shared (override via `studio.allowImages`) | Allow image input |
 | `requestTimeoutMs` / `modelTimeoutMs` | Web: `240000` / `10000`; Studio: `1800000` / `10000` | Shared (override via `studio.*`) | Timeout (ms) per backend wait or model list fetch; resets on stream data, explicit settings take precedence |
 | `stripCitations` | `true` | `gemini-web` only | Strip `[cite: 1]` and `[cite_start]` markers from replies and tool arguments (not supported on AI Studio) |
+| `proxy` | none | `gemini-web` only | Proxy for the managed Gemini Web backend to reach Google (`http` / `https` / `socks5` / `socks5h`), or set `GEMINI_WEB_PROXY` env var / enter during sign-in |
 | `baseURL` | `http://127.0.0.1:8083/v1` | `gemini-web` only | Default Gemini Web backend URL |
 | `contextLimit` / `outputLimit` | `1000000` / `8192` | `gemini-web` only | Context and output limits reported to clients |
 | `studio.proxy` | none | `ai-studio` only | Proxy for reaching Google (`http` / `https` / `socks5`), or set `AI_STUDIO_PROXY` env var; when set, it takes precedence over the proxy saved in the admin page. An empty value counts as unset |
@@ -97,7 +100,7 @@ magpie plugin options magpie-gemini-web '{"studio":{"proxy":"http://127.0.0.1:78
   - **The backend uses neither Magpie's proxies (including the provider proxy set for `ai-studio`) nor `HTTPS_PROXY` and similar variables**: it keeps running after Magpie quits, when a proxy borrowed from Magpie may be gone. Use one of the options above. A backend started by a plugin version from before this fix may still be using a proxy from the environment it was started in (Magpie's, for example); the "代理出口" line marks it and says what a restart changes.
   - The usage card's "代理出口" (proxy) line, the Google sign-in instructions and failure messages, and `npm run studio:status` show the proxy the backend actually uses, where it comes from, and whether a new setting still needs a restart.
   - The listen address, API key and admin credentials are managed by the plugin; changing them in the admin page has no effect.
-- **Gemini Web:** The backend ignores `HTTP_PROXY`. Add your proxy to the proxy pool in the local admin panel at `http://127.0.0.1:8083/admin` (password is `adminToken` in `secrets.json` inside the data directory).
+- **Gemini Web:** The backend ignores system proxies and `HTTP_PROXY`. Enter your proxy URL when prompted at the start of "One-click local setup", set the `proxy` plugin option or `GEMINI_WEB_PROXY` environment variable, or add it to the proxy pool in the local admin panel at `http://127.0.0.1:8083/admin` (password is `adminToken` in `secrets.json` inside the data directory).
   - *Note:* When using a proxy pool, send one request with a newly added account so the backend binds it to a proxy, then re-add it via "Add an existing Google account from the local backend" to load its email and usage (SOCKS proxies are not supported for usage reads).
 
 **Connecting a self-hosted backend:**
@@ -144,7 +147,7 @@ When a plugin error asks you to run a command, it includes the full ready-to-cop
 - Concurrency is capped at 1, but Google account rate-limiting or flagging cannot be completely ruled out—use at your own risk.
 
 **AI Studio upgrades and model selection:**
-- The plugin pins SHA-256-verified `v0.2.14-magpie.1`, based on upstream `v0.2.14`. Upgrade the plugin to update the backend. Official releases at or below that upstream version, and managed backends an older plugin installed, are upgraded on the next managed startup, preserving accounts, port and sign-in credentials.
+- The plugin pins SHA-256-verified `v0.2.16-magpie.1`, based on upstream `v0.2.16`. Upgrade the plugin to update the backend. Official releases at or below that upstream version, and managed backends an older plugin installed, are upgraded on the next managed startup, preserving accounts, port and sign-in credentials.
 - **Online updates are disabled in the managed backend on macOS, Linux, and Windows.** The admin page says updates are managed by magpie-gemini-web; the update endpoint returns HTTP 409 and update checks do not contact GitHub. Independently managed external servers are unaffected. See [docs/studio-release.md](docs/studio-release.md) for how the managed build is made and reproduced.
 - Managed Unix installs still attempt to set `package/` to `0555` as additional file protection. Permission failures do not block service, and disabling online updates does not depend on permissions. To reset by manually deleting the data directory, stop the service first, then run `chmod -R u+w "<data-dir>/package"` before deleting it; replace `<data-dir>` with the actual path.
 - If a newer or custom version is installed, the plugin reports a conflict with `stop`, `install`, and `start` commands carrying the correct `--data-dir`. Stop can recover a changed listener PID and verifies its executable path before signaling it. If HTTP is down but the process is still alive, the plugin refuses to reinstall or launch a second process.
@@ -154,11 +157,11 @@ When a plugin error asks you to run a command, it includes the full ready-to-cop
 - Models with `-build` or `assistant_route` are filtered out: they inject the Build coding assistant's own system prompt and are not offered as ordinary Agent models. Refresh with `magpie provider models ai-studio` after upgrading.
 
 **Gemini Web optimized backend upgrades & rollback:**
-- One-click setup uses [4.22.0-magpie.1](https://github.com/BUKOWSKIREAL/magpie-gemini-web/releases/tag/backend-v4.22.0-magpie.1) by default (built from pinned upstream v4.22.0 with XSRF caching, request cancellation propagation, early tool-call completion, and Argon model verification).
+- One-click setup uses [4.26.0-magpie.1](https://github.com/BUKOWSKIREAL/magpie-gemini-web/releases/tag/backend-v4.26.0-magpie.1) by default (built from pinned upstream v4.26.0 with XSRF caching, request cancellation propagation, early tool-call completion, and Argon model verification).
 - **Upgrading:** Running backends are not interrupted automatically. Stop the existing process (PID in `backend.pid` inside the data directory); the next Magpie launch or request will upgrade the binary while preserving config and cookies.
 - **Rollback to upstream / restore optimized build** (run in the plugin directory after stopping the backend):
   ```bash
-  npm run backend:install:upstream  # Roll back and pin to official v4.22.0
+  npm run backend:install:upstream  # Roll back and pin to official v4.26.0
   npm run backend:install           # Restore default optimized build
   ```
 - For reproducible builds and release procedures, see [docs/backend-release.md](docs/backend-release.md).

package/README.md

@@ -14,10 +14,10 @@
 | :--- | :--- | :--- |
 | **适用场景** | **推荐 Coding Agent 使用** | 日常对话、使用网页版专属模型与额度 |
 | **工具调用** | **原生 Function Calling**，稳定可靠 | 提示词模拟（实验性，Flash 系列常不调工具） |
-| **思考档位** | `minimal` / `low` / `medium` / `high` 四档（`minimal` 最快最省） | `low`（普通）/ `high`（`-thinking` 扩展思考）两档 |
+| **思考档位** | `minimal` / `low` / `medium` / `high` 四档（`minimal` 最快最省） | `low`（普通）/ `medium`（`-thinking-medium`，仅 `gemini-4-argon`）/ `high`（`-thinking` 扩展思考） |
 | **登录方式** | 弹出独立浏览器窗口直接登录 Google | 用无痕窗口登录并复制 `cookie` |
 | **额度卡片** | 显示冷却中的模型与恢复时间 | 同步网页版 **5 小时** 与 **每周** 用量及重置时间 |
-| **本地后端** | AIStudio2API (`v0.2.14`) | gemini-web2api-go (`4.22.0-magpie.1` 优化版) |
+| **本地后端** | AIStudio2API (`v0.2.16`) | gemini-web2api-go (`4.26.0-magpie.1` 优化版) |
 
 ---
 
@@ -34,7 +34,7 @@
 
 ### 方式二：Gemini Web (`gemini-web`)
 
-1. 在 Magpie 中登录 **Gemini Web**，选择 **「一键配置本地 Gemini Web（推荐）」**。
+1. 在 Magpie 中登录 **Gemini Web**，选择 **「一键配置本地 Gemini Web（推荐）」**（若访问 Google 需要代理，可在第一步提示中直接填写代理地址，例如 `http://127.0.0.1:7890`，无需代理或已配置代理池可留空）。
 2. 打开浏览器**无痕 / 隐私窗口**（推荐 Firefox）获取 Cookie：
    1. 访问 <https://gemini.google.com/app> 并登录 Google 账号；
    2. 按 `F12`（macOS 按 `⌥⌘I`）切到 **Network（网络）**，刷新页面；
@@ -42,6 +42,8 @@
    4. **直接关闭无痕窗口，不要点退出登录**（点退出会使 Cookie 失效）。
 3. 插件验证账号可用后即完成登录。想添加更多账号，重复上述步骤即可。
 
+> **升级后提示后端不支持登录时绑定代理？** 旧后台进程可能仍在运行。请按提示先退出 Magpie，停止对应的 `gemini-web2api-go` 进程（Windows：任务管理器 → 详细信息 → `gemini-web2api-go.exe`），再运行提示中的完整安装命令。它会保留账号和配置，并切换到插件的托管后端；如下载需要代理，先设置 `GEMINI_WEB_PROXY`。完成后重新打开 Magpie 登录。
+
 > **为什么必须用无痕窗口？** 后端会定时刷新会话来保活。若与日常浏览器共用同一登录会话，Google 会将整个会话作废，导致你的浏览器退出所有 Google 服务。使用无痕窗口（或单独准备 Google 小号）可提供独立会话。
 
 ---
@@ -84,6 +86,7 @@ magpie plugin options magpie-gemini-web '{"studio":{"proxy":"http://127.0.0.1:78
 | `allowImages` | `false` | 共用（可用 `studio.allowImages` 单独覆盖） | 允许图片输入 |
 | `requestTimeoutMs` / `modelTimeoutMs` | Web：`240000` / `10000`；Studio：`1800000` / `10000` | 共用（`studio.*` 可覆盖） | 单次等待后端 / 拉取模型列表的超时（毫秒）；收到流数据后重新计时，显式配置优先 |
 | `stripCitations` | `true` | 仅 `gemini-web` | 剥离回复与工具参数中的 `[cite: 1]`、`[cite_start]` 标记（AI Studio 不支持剥离） |
+| `proxy` | 无 | 仅 `gemini-web` | 一键配置后端访问 Google 的代理（`http` / `https` / `socks5` / `socks5h`），也可用环境变量 `GEMINI_WEB_PROXY` 或在登录第一步填写 |
 | `baseURL` | `http://127.0.0.1:8083/v1` | 仅 `gemini-web` | Gemini Web 默认后端地址 |
 | `contextLimit` / `outputLimit` | `1000000` / `8192` | 仅 `gemini-web` | 向客户端声明的上下文 / 输出上限 |
 | `studio.proxy` | 无 | 仅 `ai-studio` | 访问 Google 的代理（`http` / `https` / `socks5`），也可用环境变量 `AI_STUDIO_PROXY`；设置后优先于管理页里保存的代理，留空等于不设置 |
@@ -97,7 +100,7 @@ magpie plugin options magpie-gemini-web '{"studio":{"proxy":"http://127.0.0.1:78
   - **后端不使用 Magpie 的代理（包括给 `ai-studio` 设置的供应商代理），也不读取 `HTTPS_PROXY` 等环境变量**：它在 Magpie 退出后仍会运行，借用 Magpie 的代理到时可能已经失效。请用上面两种方式之一设置。加入这项修复之前的插件版本启动的后端，可能还在用启动时环境变量里的代理（比如 Magpie 的）；「代理出口」一行会标出来，并说明重启后会怎样。
   - 额度卡片的「代理出口」一行会显示后端当前实际使用的代理、它来自哪里，以及新设置是否还要重启才生效；登录 Google 时的说明、登录失败的提示和 `npm run studio:status` 也会显示。
   - 监听地址、API Key、管理员账号等由插件管理，在管理页修改不会生效。
-- **Gemini Web**：后端不读取 `HTTP_PROXY`，请打开本地管理面板 `http://127.0.0.1:8083/admin` 在代理池中添加（登录口令为数据目录 `secrets.json` 中的 `adminToken`）。
+- **Gemini Web**：后端不读取系统代理或 `HTTP_PROXY`。可在「一键配置本地 Gemini Web」登录第一步直接填写代理地址，或设置插件选项 `proxy` / 环境变量 `GEMINI_WEB_PROXY`，也可以打开本地管理面板 `http://127.0.0.1:8083/admin` 在代理池中添加（登录口令为数据目录 `secrets.json` 中的 `adminToken`）。
   - *注意*：配置代理池后，新添加的账号需先发送一次请求以绑定代理，再通过「添加本地后端里已有的 Google 账号」重新添加，才能正常读取邮箱和用量（不支持通过 SOCKS 代理读取用量）。
 
 **连接自建后端：**
@@ -144,7 +147,7 @@ magpie plugin options magpie-gemini-web '{"studio":{"proxy":"http://127.0.0.1:78
 - 插件将请求并发限制为 1，但仍无法完全排除 Google 账号风控风险，请自行评估使用。
 
 **AI Studio 升级与模型范围：**
-- 插件固定使用经过 SHA-256 校验的 `v0.2.14-magpie.1`（基于上游 `v0.2.14`），通过升级插件更新后端。同基线或更旧的官方版、以及旧版插件装的托管后端，在下次管理启动时自动升级，保留账号、端口与登录凭据。
+- 插件固定使用经过 SHA-256 校验的 `v0.2.16-magpie.1`（基于上游 `v0.2.16`），通过升级插件更新后端。同基线或更旧的官方版、以及旧版插件装的托管后端，在下次管理启动时自动升级，保留账号、端口与登录凭据。
 - **托管后端已在 macOS、Linux、Windows 统一禁用在线更新**：管理页提示“更新由 magpie-gemini-web 管理”，更新接口返回 HTTP 409，检查更新也不会访问 GitHub。用户自行连接的外部服务不受影响。托管构建方式和可复现构建流程见 [docs/studio-release.md](docs/studio-release.md)。
 - Unix 的 `package/` 仍尽力设置为 `0555`，作为额外的文件保护；权限设置失败不阻断服务，在线更新的禁用也不依赖该权限。若要手动删除数据目录来重置，请先停止服务，再运行 `chmod -R u+w "<数据目录>/package"` 恢复可写权限，然后删除；将 `<数据目录>` 替换为实际路径。
 - 若自行更新到更新版或定制版，插件会提示版本冲突，并提供带正确 `--data-dir` 的 `stop`、`install`、`start` 命令。停止时会找回更新后的监听进程 PID，并核对可执行文件路径；无法核实身份就不会发送终止信号。HTTP 端口关闭但进程尚未退出时，插件不会重装或启动第二个进程。
@@ -154,11 +157,11 @@ magpie plugin options magpie-gemini-web '{"studio":{"proxy":"http://127.0.0.1:78
 - 模型列表过滤 `-build` / `assistant_route` 模型：这类模型附带 Build 写代码助手的系统提示词，不作为普通 Agent 模型提供。升级后可执行 `magpie provider models ai-studio` 刷新列表。
 
 **Gemini Web 优化后端升级与回退：**
-- 插件默认使用本仓库发布的 [4.22.0-magpie.1](https://github.com/BUKOWSKIREAL/magpie-gemini-web/releases/tag/backend-v4.22.0-magpie.1)（基于上游 v4.22.0 集成 XSRF 缓存、请求取消传播、工具调用提前收尾与 Argon 校验补丁）。
+- 插件默认使用本仓库发布的 [4.26.0-magpie.1](https://github.com/BUKOWSKIREAL/magpie-gemini-web/releases/tag/backend-v4.26.0-magpie.1)（基于上游 v4.26.0 集成 XSRF 缓存、请求取消传播、工具调用提前收尾与 Argon 校验补丁）。
 - **旧版升级**：插件不会打断运行中的后端。先停止旧进程（PID 见数据目录 `backend.pid`），下次启动 Magpie 或发请求时会自动更新二进制并保留原有配置与账号。
 - **回退官方版 / 恢复优化版**（停止后端后在插件目录执行）：
   ```bash
-  npm run backend:install:upstream  # 回退并固定使用官方 v4.22.0
+  npm run backend:install:upstream  # 回退并固定使用官方 v4.26.0
   npm run backend:install           # 恢复默认优化版
   ```
 - 源码复现构建与发布流程见 [docs/backend-release.md](docs/backend-release.md)。

package/docs/backend-release.md

@@ -28,4 +28,6 @@ The metadata records `CGO_ENABLED=0`, the exact Go toolchain, upstream commit, p
 
 Existing running processes are left alone to avoid interrupting requests. Once an old official backend is stopped, automatic startup installs the optimized build while preserving configuration, secrets and the database. A download or checksum failure keeps the old file and never starts an unverified replacement.
 
-An explicit `npm run backend:install:upstream` installs the pinned upstream v4.22.0 and persists `upstream` in `backend-channel.json`. Automatic startup respects that choice. `npm run backend:install` returns to the optimized channel. Stop a running backend before replacing it, particularly on Windows. Explicit local Argon builds remain trusted through their existing build manifest.
+New cookie imports require the running backend to advertise `capabilities.account_proxy_binding: true` at `/`. The plugin checks this before changing the proxy pool and again before submitting a cookie, so a reused older or upstream backend cannot silently ignore `proxy_id`. Unsupported builds receive instructions to stop the old process and run the installed plugin's CLI with `install --data-dir=<path>`. This explicitly selects the optimized channel, including for previous upstream or custom-build installations. The check does not interrupt existing conversations. Release smoke verifies the capability and actual proxy selection; version strings alone do not establish support.
+
+An explicit `npm run backend:install:upstream` installs the pinned upstream v4.26.0 and persists `upstream` in `backend-channel.json`. Automatic startup respects that choice. `npm run backend:install` returns to the optimized channel. Stop a running backend before replacing it, particularly on Windows. Explicit local Argon builds remain trusted through their existing build manifest.

package/docs/studio-release.md

@@ -1,12 +1,12 @@
 # AI Studio 托管后端构建
 
-插件使用 `0.2.14-magpie.1`，基于 AIStudio2API `v0.2.14` 的固定 commit。上游版本、commit、Go 工具链、安装包及二进制 SHA-256 均记录在 `lib/studio-release.json`。`upstream.camoufox` 是这个 commit 要求的 Camoufox 版本（上游 `internal/camoufoxnative/download.go` 里的 `camoufoxRelease`），插件靠它判断登录时要不要重新下载 Camoufox；更新上游 commit 时要一起改，构建脚本发现不一致会报错。MIT 许可见 `LICENSE-AISTUDIO`。
+插件使用 `0.2.16-magpie.1`，基于 AIStudio2API `v0.2.16` 的固定 commit。上游版本、commit、Go 工具链、安装包及二进制 SHA-256 均记录在 `lib/studio-release.json`。`upstream.camoufox` 是这个 commit 要求的 Camoufox 版本（上游 `internal/camoufoxnative/download.go` 里的 `camoufoxRelease`），插件靠它判断登录时要不要重新下载 Camoufox；更新上游 commit 时要一起改，构建脚本发现不一致会报错。MIT 许可见 `LICENSE-AISTUDIO`。
 
 ## 在线更新策略
 
 上游从 v0.2.14 起支持由分发方管理更新，不再需要补丁。构建时通过 `-ldflags` 写入两个值：
 
-- `internal/app.version=v0.2.14-magpie.1`：明确的版本标识。插件把同基线或更旧的官方版、以及更旧的托管版（`-magpie.N` 的基线更低，或同基线但 N 更小）视为需要升级；更新的官方版、更新的托管版或不认识的定制版仍提示冲突。
+- `internal/app.version=v0.2.16-magpie.1`：明确的版本标识。插件把同基线或更旧的官方版、以及更旧的托管版（`-magpie.N` 的基线更低，或同基线但 N 更小）视为需要升级；更新的官方版、更新的托管版或不认识的定制版仍提示冲突。
 - `internal/app.managedBy=magpie-gemini-web`：更新模式为 `managed`。`GET /api/update`（包括 `?refresh=1`）只返回本地版本、`mode: managed` 和 `managed_by`，不访问 GitHub；`POST /api/update` 返回 HTTP 409，说明更新由 magpie-gemini-web 管理，不下载、不替换文件、不重启。这两个值在链接时写死，没有环境变量或管理页开关，在所有构建平台相同。
 - 管理页版本面板显示当前版本和"更新由 magpie-gemini-web 管理"，不显示检查更新或安装按钮。上游的在线更新代码仍然编译在内，但托管模式下走不到；`studio:managed:smoke` 用真实二进制验证这一点。
 - 构建不带 `desktop` 标签，即上游的命令行版，不包含桌面窗口。
@@ -30,7 +30,7 @@ node scripts/studio-release.mjs --write-pins
 node scripts/studio-release.mjs --source=/path/to/AIStudio2API --verify
 ```
 
-输出在 `studio-build/release/`，不进入 npm 包。包含 macOS x64/arm64、Linux x64/arm64、Windows x64 安装包，以及构建记录、SHA256SUMS 和上游许可证。每个安装包携带许可证和托管升级说明。Go 的标准 tar/zip/gzip 写入器固定文件顺序、权限与时间；编译使用 `-trimpath -buildvcs=false`。
+输出在 `studio-build/release/`，不进入 npm 包。包含 macOS x64/arm64、Linux x64/arm64、Windows x64 安装包，以及构建记录、SHA256SUMS 和上游许可证。每个安装包携带许可证和托管升级说明。Go 的标准 tar/zip/gzip 写入器固定文件顺序、权限与时间；编译使用 `-trimpath -buildvcs=false`。上游前端构建用 Node 的 zlib 预压缩网页资源（`.gz`），其输出随 CPU 和系统不同，而这些资源嵌入二进制；构建脚本在前端构建后用 `scripts/studio-regzip.go` 以 Go 的 gzip 重新压缩，使各平台构建结果一致。
 
 ## 验证与发布
 
@@ -44,6 +44,6 @@ AI_STUDIO_TEST_ARCHIVE=/absolute/path/to/archive.tar.gz npm test
 
 真实安装验证检查启动、版本、GET 更新状态、POST 更新返回 409、二进制及 PID 不变、管理页面显示托管提示、停止与状态。`.github/workflows/studio.yml` 在五种系统/架构上重新构建、对比 SHA-256 并运行该验证；本机交叉编译不代替 Windows 真机验证。
 
-发布时先审查构建记录和各平台 CI 结果，再将安装包及许可证上传到本仓库 `studio-v0.2.14-magpie.1` release。该 release 可公开下载后，才能发布引用它的插件版本，否则新安装会遇到 404。构建脚本及 CI 不自动发布 release，也不发布 npm 包。
+发布时先审查构建记录和各平台 CI 结果，再将安装包及许可证上传到本仓库 `studio-v0.2.16-magpie.1` release。该 release 可公开下载后，才能发布引用它的插件版本，否则新安装会遇到 404。构建脚本及 CI 不自动发布 release，也不发布 npm 包。
 
-本地试用无需发布：先停止当前托管后端，再执行 `node scripts/studio.mjs install --archive /absolute/path/to/archive` 和 `node scripts/studio.mjs start`。可用 `--data-dir` 指定目录。修改前备份账号和配置；该版本与上游 v0.2.14 使用相同的数据格式。v0.2.14 对数据的改动都是新增的（账号记录的可选字段、新的 `runtime/prompts.db`、`.env` 的新设置），用真实账号验证过：`v0.2.13-magpie.1` 的数据可以直接被它读取，用它运行过之后退回 `v0.2.13-magpie.1` 也能正常使用。
+本地试用无需发布：先停止当前托管后端，再执行 `node scripts/studio.mjs install --archive /absolute/path/to/archive` 和 `node scripts/studio.mjs start`。可用 `--data-dir` 指定目录。修改前备份账号和配置；该版本与上游 v0.2.16 使用相同的数据格式。

package/index.mjs

@@ -1,6 +1,6 @@
 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 { parseCookieInput, importCookie, ensureProxy, validateProxyURL, requireLoginBackend } from './lib/setup.mjs';
 import { usage, poolChoices, poolAccounts, accountEmail } from './lib/usage.mjs';
 import { taskSupported, taskMethod, taskLoader, taskModels, isTaskAuth } from './lib/task.mjs';
 
@@ -55,7 +55,7 @@ async function forwardManaged(input, init, getAuth, opts) {
   }
   if (!managedBackend(c.baseURL)) return res;
   try {
-    await ensureBackend();
+    await ensureBackend({ proxy: opts.proxy });
   } catch {
     return res;
   }
@@ -68,11 +68,30 @@ export const GeminiWebPlugin = async (_input, options = {}) => {
   }
   const { studio: _studio, ...webOptions } = options;
   const opts = settings(webOptions);
+  const proxyPrompt = {
+    type: 'text',
+    key: 'proxy',
+    message: '访问 Google 的代理地址（无需代理或已在代理池配置可留空）',
+    placeholder: opts.proxy || 'http://127.0.0.1:7890',
+    validate: value => {
+      try {
+        validateProxyURL(value);
+      } catch (e) {
+        return e.message;
+      }
+    }
+  };
 
   // Bring a backend set up earlier back after Magpie or the computer restarts. Not awaited:
   // requests that arrive first start it themselves through forwardManaged.
   if (localBackend()) {
-    ensureBackend().catch(err => console.error(`[gemini-web] could not start the local backend: ${err.message}`));
+    ensureBackend({ proxy: opts.proxy })
+      .then(async local => {
+        if (!opts.proxy) return;
+        await requireLoginBackend(local);
+        await ensureProxy(local, opts.proxy);
+      })
+      .catch(err => console.error(`[gemini-web] could not start the local backend: ${err.message}`));
   }
 
   return {
@@ -86,20 +105,29 @@ export const GeminiWebPlugin = async (_input, options = {}) => {
       methods: [{
         type: 'oauth',
         label: '一键配置本地 Gemini Web（推荐）',
-        // Installs and starts the pinned backend, then takes the Gemini cookie the user pastes.
+        prompts: [proxyPrompt],
+        ask(inputs) {
+          return inputs && 'proxy' in inputs ? null : proxyPrompt;
+        },
+        // Installs and starts the pinned backend while the user copies the Gemini cookie; the
+        // callback then waits for it, configures its proxy pool when a proxy URL is given, and
+        // imports the cookie (importCookie checks the backend can bind the account to a proxy).
         // The result carries the backend's own API key, so Magpie saves an API-key sign-in,
         // one for each Google account (see signInFor).
-        async authorize() {
-          const local = await ensureBackend();
+        async authorize(inputs) {
+          const proxy = validateProxyURL(inputs?.proxy || opts.proxy || '');
+          const ready = ensureBackend({ proxy });
+          ready.catch(() => {});
           return {
             url: GEMINI_URL,
             method: 'code',
             instructions: COOKIE_STEPS,
             async callback(code) {
-              let cookie, added;
+              let local, cookie, added;
               try {
                 cookie = parseCookieInput(code);
-                added = await importCookie(local, cookie);
+                local = await ready;
+                added = await importCookie(local, cookie, proxy ? { proxy } : {});
               } catch (err) {
                 return { type: 'failed', error: err.message };
               }
@@ -206,7 +234,7 @@ export const GeminiWebPlugin = async (_input, options = {}) => {
           return await listModels(c, opts);
         } catch (err) {
           if (!err.unreachable || !managedBackend(c.baseURL)) throw err;
-          await ensureBackend();
+          await ensureBackend({ proxy: opts.proxy });
           return listModels(c, opts);
         }
       }

package/lib/backend-release.json

@@ -1,36 +1,36 @@
 {
-  "version": "4.22.0-magpie.1",
+  "version": "4.26.0-magpie.1",
   "repository": "BUKOWSKIREAL/magpie-gemini-web",
-  "tag": "backend-v4.22.0-magpie.1",
+  "tag": "backend-v4.26.0-magpie.1",
   "upstream": {
     "repository": "https://github.com/zexadev/gemini-web2api-go.git",
-    "commit": "a65b1d1a5ac614c1b455857334b4f1c73ab8fcfb"
+    "commit": "7ce02d89512058b2bd147fb2dc4e40187f5135ad"
   },
   "goVersion": "1.27.1",
   "binaries": {
     "darwin-arm64": {
-      "asset": "gemini-web2api-go_v4.22.0-magpie.1_darwin_arm64",
-      "sha256": "833dd54e7c0df927afc1d4e0f6443bcc03b7f0a4d04d24cdfde47d5dd27349c5"
+      "asset": "gemini-web2api-go_v4.26.0-magpie.1_darwin_arm64",
+      "sha256": "ae2581dfba30d7566c2c55cd53b0b65c56aab5e5f592ccac983a65c4444f069e"
     },
     "darwin-x64": {
-      "asset": "gemini-web2api-go_v4.22.0-magpie.1_darwin_amd64",
-      "sha256": "d65b053a0e5f8e1065ea35835b3a7d12f783d97964c02bef49679df7ead92fd4"
+      "asset": "gemini-web2api-go_v4.26.0-magpie.1_darwin_amd64",
+      "sha256": "e220a5c53284c0c17ca9bc1a3e454448c95b84155fc460c17e0c8fcbae3b9d88"
     },
     "linux-x64": {
-      "asset": "gemini-web2api-go_v4.22.0-magpie.1_linux_amd64",
-      "sha256": "94f082e666b34051f191959de3f2cd601078d117b1d3ededcdcd6b2201c48ef9"
+      "asset": "gemini-web2api-go_v4.26.0-magpie.1_linux_amd64",
+      "sha256": "cbbb9784823301f4f90e44d33a087d4d745770f4f35d77735fbae370087a7a43"
     },
     "linux-arm64": {
-      "asset": "gemini-web2api-go_v4.22.0-magpie.1_linux_arm64",
-      "sha256": "4a7cbca2771acc9e836a5a986e11b3b247baf77e9900262cb588b515a1161aaa"
+      "asset": "gemini-web2api-go_v4.26.0-magpie.1_linux_arm64",
+      "sha256": "cf503f30ed3cfd358de926cf58b455b9ce7951dfa51b24584bd11559e9cfe7c0"
     },
     "win32-x64": {
-      "asset": "gemini-web2api-go_v4.22.0-magpie.1_windows_amd64.exe",
-      "sha256": "61d279d50c6c09ffe81ed059a557077900948d0ae598e4c4b3a5d5c213ad5e5c"
+      "asset": "gemini-web2api-go_v4.26.0-magpie.1_windows_amd64.exe",
+      "sha256": "e0d0bc52acd1c0c7dc7d1bdc8eb3da09dee2be8ed9a36173ab3be1bf4c58f667"
     },
     "win32-arm64": {
-      "asset": "gemini-web2api-go_v4.22.0-magpie.1_windows_arm64.exe",
-      "sha256": "20bad088b114d3dc989830ff35f7e56c1e0026caf9721b739fe982f5fd3d1880"
+      "asset": "gemini-web2api-go_v4.26.0-magpie.1_windows_arm64.exe",
+      "sha256": "d038049af66365f0a6ab634664ca3d3715dd26e42d67f4c7f0b4f2ccba64f143"
     }
   }
 }

package/lib/backend.mjs

@@ -1,4 +1,5 @@
 import { citeStream, citeJSON } from './cite.mjs';
+import { validateProxyURL } from './setup.mjs';
 
 export const DEFAULT_BASE = 'http://127.0.0.1:8083/v1';
 
@@ -6,11 +7,13 @@ const MEDIA_SPECIAL = /(?:^|[-_])(image|music|canvas|video|research)(?:[-_]|$)/i
 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), 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.
+// The backend has no effort parameter: extended thinking uses separate "<id>-thinking-medium"
+// and "<id>-thinking" models. A base model with such twins offers low (itself), medium (when
+// "<id>-thinking-medium" exists), and high ("<id>-thinking"), while the twins aren't listed on
+// their own; a request that names one directly 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 MEDIUM_THINKING_SUFFIX = '-thinking-medium';
 const LOW_EFFORTS = new Set(['none', 'minimal', 'low']);
 const MODEL_CACHE_MS = 10 * 60 * 1000;
 const knownModels = new Map();
@@ -21,6 +24,7 @@ export const UNREACHABLE_HEADER = 'X-Gemini-Web-Backend';
 
 const KNOWN_OPTIONS = new Set([
   'baseURL',
+  'proxy',
   'allowTools',
   'allowImages',
   'contextLimit',
@@ -115,6 +119,13 @@ export function settings(options = {}) {
     baseURL = normalizeBaseURL(options.baseURL);
   }
 
+  let proxy = '';
+  if (options.proxy !== undefined) {
+    proxy = validateProxyURL(options.proxy);
+  } else if (process.env.GEMINI_WEB_PROXY) {
+    proxy = validateProxyURL(process.env.GEMINI_WEB_PROXY);
+  }
+
   // 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;
@@ -181,6 +192,7 @@ export function settings(options = {}) {
 
   return {
     baseURL,
+    proxy,
     allowTools,
     allowImages,
     contextLimit,
@@ -289,7 +301,16 @@ 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);
+    if (id.endsWith(MEDIUM_THINKING_SUFFIX) && ids.has(id.slice(0, -MEDIUM_THINKING_SUFFIX.length))) continue;
+    const isTwin = id.endsWith(THINKING_SUFFIX) || id.endsWith(MEDIUM_THINKING_SUFFIX);
+    const hasMedium = !isTwin && ids.has(id + MEDIUM_THINKING_SUFFIX);
+    const hasHigh = !isTwin && ids.has(id + THINKING_SUFFIX);
+    const variants = {};
+    if (hasMedium || hasHigh) {
+      variants.low = {};
+      if (hasMedium) variants.medium = {};
+      if (hasHigh) variants.high = {};
+    }
     result[id] = {
       id,
       providerID: 'gemini-web',
@@ -326,7 +347,7 @@ export async function listModels(c, opts) {
       },
       options: {},
       headers: {},
-      variants: hasTwin ? { low: {}, high: {} } : {},
+      variants,
       status: 'active'
     };
   }
@@ -345,7 +366,7 @@ async function thinkingTwin(body, c, opts) {
   const effort = body.reasoning_effort;
   const model = body.model;
   if (typeof effort !== 'string' || LOW_EFFORTS.has(effort)) return null;
-  if (typeof model !== 'string' || model.endsWith(THINKING_SUFFIX)) return null;
+  if (typeof model !== 'string' || model.endsWith(THINKING_SUFFIX) || model.endsWith(MEDIUM_THINKING_SUFFIX)) return null;
 
   let cached = knownModels.get(modelCacheKey(c));
   if (!cached || Date.now() - cached.at > MODEL_CACHE_MS) {
@@ -356,6 +377,9 @@ async function thinkingTwin(body, c, opts) {
     }
     cached = knownModels.get(modelCacheKey(c));
   }
+  if (effort === 'medium' && cached?.ids.has(model + MEDIUM_THINKING_SUFFIX)) {
+    return model + MEDIUM_THINKING_SUFFIX;
+  }
   const twin = model + THINKING_SUFFIX;
   return cached?.ids.has(twin) ? twin : null;
 }
@@ -535,12 +559,14 @@ export async function forward(input, init, getAuth, opts) {
   let upstreamRes;
   timer.start();
   try {
+    // Bun's fetch drops a connection idle for 300 s; the timer sets the deadline instead.
     upstreamRes = await fetch(incomingUrl, {
       method: req.method,
       headers,
       body: rawBody,
       signal,
-      redirect: 'error'
+      redirect: 'error',
+      timeout: false
     });
   } catch (err) {
     if (req.signal.aborted) {

package/lib/native.mjs

@@ -2,23 +2,24 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import crypto from 'node:crypto';
-import { spawn } from 'node:child_process';
+import { spawn, execFile } from 'node:child_process';
+import { validateProxyURL } from './setup.mjs';
 import release from './backend-release.json' with { type: 'json' };
 
 export const BACKEND_VERSION = `v${release.version}`;
 const RELEASE_BASE = `https://github.com/${release.repository}/releases/download/${release.tag}/`;
 export const PINNED_BINARIES = release.binaries;
 
-const UPSTREAM_VERSION = 'v4.22.0';
+const UPSTREAM_VERSION = 'v4.26.0';
 const UPSTREAM_BASE = `https://github.com/zexadev/gemini-web2api-go/releases/download/${UPSTREAM_VERSION}/`;
 // Retained for an explicit, checksum-verified rollback to the upstream release.
 export const UPSTREAM_BINARIES = {
-  'darwin-arm64': { asset: 'gemini-web2api-go_v4.22.0_darwin_arm64', sha256: 'c69ca75cf43017cf2a62dbf5c12b07f6bde66f403f714c32209b1ad350ed24c9' },
-  'darwin-x64': { asset: 'gemini-web2api-go_v4.22.0_darwin_amd64', sha256: '384e617bcc30aacac6b7c4e4d0490e88d282b13b29f7a0a20d645b69514cd405' },
-  'linux-x64': { asset: 'gemini-web2api-go_v4.22.0_linux_amd64', sha256: '21fcc81e0ad8ce0921e6b6c2cafce1089852530142b37e0289355c6e72df5299' },
-  'linux-arm64': { asset: 'gemini-web2api-go_v4.22.0_linux_arm64', sha256: 'f2822fa0f1a7d2b37c2bc9cbb30a95c2e8028462453a110389511408bdfd4fd7' },
-  'win32-x64': { asset: 'gemini-web2api-go_v4.22.0_windows_amd64.exe', sha256: '17e37f7e5c813b2a8d90c9a0265e6cde3bcfa4e814822af999fe8c4178f02729' },
-  'win32-arm64': { asset: 'gemini-web2api-go_v4.22.0_windows_arm64.exe', sha256: 'b42e951bfc08d7fe8bdb436dca87fc6a1b7948bb8d10e110653bcf13a790756c' }
+  'darwin-arm64': { asset: 'gemini-web2api-go_v4.26.0_darwin_arm64', sha256: 'cb1afabb5c5db57f99dc67b7cdf8c862a6e7aa33883cbe5355da6f696f02bc41' },
+  'darwin-x64': { asset: 'gemini-web2api-go_v4.26.0_darwin_amd64', sha256: 'de4e519a65caa168b49d906c73e9012a0b8f09ec80978dc8d3efcb674bb28c8f' },
+  'linux-x64': { asset: 'gemini-web2api-go_v4.26.0_linux_amd64', sha256: '2c0c4cb73989a34ca76a9e75c79e0e8684c6d7abc58231c65ef1eca4c411be81' },
+  'linux-arm64': { asset: 'gemini-web2api-go_v4.26.0_linux_arm64', sha256: '5518a5f055e025b118d327b361f8c9f81df319132ed5e064eea191bbe129a50a' },
+  'win32-x64': { asset: 'gemini-web2api-go_v4.26.0_windows_amd64.exe', sha256: '32717fed3ed02b5c82950a01ab3a49e6724de21be8b31c7bb83e8e2e8e454128' },
+  'win32-arm64': { asset: 'gemini-web2api-go_v4.26.0_windows_arm64.exe', sha256: 'ed5a4f0b6f6b0078ff2173f9b3128ed0836748e42e35ea78ff1bc6e1f456e37d' }
 };
 
 export function pinnedBinary(platform = process.platform, arch = process.arch, channel = 'optimized') {
@@ -76,6 +77,7 @@ export async function installBackend(options = {}) {
   const expectedHash = options.expectedHash || pin.sha256;
   const downloadUrl = options.url || pin.url;
   const fetchFn = options.fetchFn || globalThis.fetch;
+  const proxy = validateProxyURL(options.proxy ?? process.env.GEMINI_WEB_PROXY ?? '');
 
   const dataDir = options.dataDir || getDataDir();
   fs.mkdirSync(dataDir, { recursive: true, mode: 0o700 });
@@ -98,24 +100,57 @@ export async function installBackend(options = {}) {
 
   if (!binaryReady) {
     console.log(`Downloading backend binary from ${downloadUrl}...`);
-    const res = await fetchFn(downloadUrl, {
-      signal: AbortSignal.timeout(300000)
-    });
-    if (!res.ok) {
-      throw new Error(`Failed to download binary: HTTP ${res.status}`);
-    }
-
-    const arrayBuffer = await res.arrayBuffer();
-    const buffer = Buffer.from(arrayBuffer);
-    const downloadedHash = crypto.createHash('sha256').update(buffer).digest('hex');
-
-    if (downloadedHash !== expectedHash) {
-      throw new Error(`SHA256 checksum mismatch: expected ${expectedHash}, got ${downloadedHash}`);
-    }
-
     const tmpPath = path.join(binDir, `gemini-web2api-go.tmp.${Date.now()}.${crypto.randomBytes(4).toString('hex')}`);
     try {
-      fs.writeFileSync(tmpPath, buffer, { mode: 0o700 });
+      // A slow download goes on while data keeps coming; a minute without any gives it up.
+      if (proxy && (!options.fetchFn || options.fetchFn === globalThis.fetch)) {
+        const curlArgs = [
+          '--fail', '--location', '--silent', '--show-error',
+          '--connect-timeout', '15', '--speed-limit', '1', '--speed-time', '60',
+          '--proxy', proxy,
+          '-o', tmpPath, downloadUrl
+        ];
+        await new Promise((resolve, reject) => {
+          execFile('curl', curlArgs, (err, _stdout, stderr) => {
+            if (!err) return resolve();
+            const status = err.code || err.status || 'failed';
+            const reason = String(stderr || '').trim().slice(0, 500);
+            reject(new Error(`Failed to download binary via curl (status: ${status})${reason ? `: ${reason}` : ''}`));
+          });
+        });
+        fs.chmodSync(tmpPath, 0o700);
+      } else {
+        const stall = new AbortController();
+        let timer;
+        const rearm = () => {
+          clearTimeout(timer);
+          timer = setTimeout(() => stall.abort(new Error('Failed to download binary: no data for 60 s')), 60000);
+        };
+        const chunks = [];
+        try {
+          rearm();
+          const res = await fetchFn(downloadUrl, {
+            ...(proxy ? { proxy } : {}),
+            signal: stall.signal
+          });
+          if (!res.ok) {
+            throw new Error(`Failed to download binary: HTTP ${res.status}`);
+          }
+          for await (const chunk of res.body) {
+            chunks.push(chunk);
+            rearm();
+          }
+        } finally {
+          clearTimeout(timer);
+        }
+        fs.writeFileSync(tmpPath, Buffer.concat(chunks), { mode: 0o700 });
+      }
+
+      const downloadedHash = computeFileHash(tmpPath);
+      if (downloadedHash !== expectedHash) {
+        throw new Error(`SHA256 checksum mismatch: expected ${expectedHash}, got ${downloadedHash}`);
+      }
+
       fs.renameSync(tmpPath, binPath);
       fs.chmodSync(binPath, 0o700);
       console.log(`Backend binary installed: ${binPath}`);
@@ -341,9 +376,19 @@ async function withLock(dataDir, fn, timeoutMs) {
       await sleep(300);
     }
   }
+  // A download has no overall deadline, so the holder keeps the lock fresh while it works;
+  // only a lock left by a process that is gone goes stale.
+  const keepFresh = setInterval(() => {
+    try {
+      const now = new Date();
+      fs.utimesSync(lockPath, now, now);
+    } catch {}
+  }, Math.max(1000, Math.floor(timeoutMs / 4)));
+  keepFresh.unref?.();
   try {
     return await fn();
   } finally {
+    clearInterval(keepFresh);
     fs.rmSync(lockPath, { force: true });
   }
 }
@@ -376,7 +421,7 @@ export async function ensureBackend(options = {}) {
     const trusted = trustedHashes(dataDir, platform, arch);
     const binPath = binaryPath(dataDir, platform);
     if (!fs.existsSync(binPath) || !trusted.includes(computeFileHash(binPath))) {
-      await installBackend({ dataDir, platform, arch, fetchFn, channel: backendChannel(dataDir) });
+      await installBackend({ dataDir, platform, arch, fetchFn, channel: backendChannel(dataDir), proxy: options.proxy });
     } else {
       ensureDataFiles(dataDir);
     }
@@ -389,8 +434,9 @@ export async function ensureBackend(options = {}) {
     const launch = prepareLaunch(dataDir, trusted, platform);
     const logPath = path.join(dataDir, 'backend.log');
     const log = fs.openSync(logPath, 'a', 0o600);
+    let child;
     try {
-      const child = spawnFn(launch.binPath, launch.args, {
+      child = spawnFn(launch.binPath, launch.args, {
         env: launch.env,
         detached: true,
         stdio: ['ignore', log, log],
@@ -408,6 +454,11 @@ export async function ensureBackend(options = {}) {
       if (await backendState(setup, fetchFn) === 'up') return setup;
       await sleep(300);
     }
+    try { child?.kill?.('SIGTERM'); } catch {}
+    if (child?.pid && typeof child?.kill !== 'function') {
+      try { process.kill(child.pid, 'SIGTERM'); } catch {}
+    }
+    fs.rmSync(path.join(dataDir, 'backend.pid'), { force: true });
     throw new Error(`Gemini Web backend did not start within ${Math.round(startTimeoutMs / 1000)}s; see ${logPath}`);
   }, 600000);
 }