magpie-gemini-web 0.7.0 → 0.8.0

package/README.en.md

@@ -17,9 +17,11 @@ 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** | Supported levels from the model catalog: `minimal` / `low` / `medium` / `high` | `low` (base) / `medium` (`-thinking-medium`, `gemini-4-argon` only) / `high` (`-thinking` extended thinking) |
+| **Image input** | On by default; chat models read images | Off by default; needs a signed-in cookie once on (see below) |
+| **Image generation** | Nano Banana models, for Magpie's image generation (Magpie v0.1.2075+, see below) | Not supported |
 | **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.17`) | gemini-web2api-go (`4.26.0-magpie.1` optimized build) |
+| **Local backend** | AIStudio2API (`v0.2.18`) | gemini-web2api-go (`4.26.0-magpie.1` optimized build) |
 
 ---
 
@@ -31,7 +33,7 @@ Install **magpie-gemini-web** from the Magpie plugin market, then sign in to eit
 
 1. Sign in to **Google AI Studio** in Magpie and choose **「用 Google 账号登录（推荐）」** (Sign in with a Google account).
 2. Sign in to your Google account in the separate login window that opens (your regular browser is unaffected), then close the window.
-   > On first run, the local service (~30 MB) and the login browser Camoufox (~300 MB) are downloaded first, so the window may take a few minutes to appear. While they download, Magpie opens a progress page in your browser. Magpie waits at most 10 minutes, downloads included, so finish signing in promptly; if GitHub is unreachable, set `studio.proxy` first (see plugin options and proxy settings below).
+   > On first run, the local service (~40 MB) and the login browser Camoufox (~300 MB) are downloaded first, so the window may take a few minutes to appear. While they download, Magpie opens a progress page in your browser. Magpie waits at most 10 minutes, downloads included, so finish signing in promptly; if GitHub is unreachable, set `studio.proxy` first (see plugin options and proxy settings below).
 3. **Managing accounts:** Choose "Sign in with a Google account" again at any time to **add a new account**, create a card for an existing local account, or **re-authenticate** an expired account.
 
 ### Option 2: Gemini Web (`gemini-web`)
@@ -61,6 +63,18 @@ Install **magpie-gemini-web** from the Magpie plugin market, then sign in to eit
 
 ---
 
+## Image Generation (AI Studio)
+
+`ai-studio` lists the Nano Banana image models your account can use (such as `gemini-3.1-flash-image` and `gemini-3-pro-image`), for Magpie's image generation. **This needs Magpie v0.1.2075 or later**, the first to take a plugin's Gemini image models as models that draw.
+
+- **No need to tick them, or to pick them for a chat:** Magpie's Settings list them under **Images → Image generation**. Pick one there, or leave it on Automatic.
+- **How agents draw:** an agent calls Magpie's `generate_image` tool (the Magpie Image MCP from the Library), which draws with the model picked there; reference images make it an edit. To try it from the command line: `magpie tool generate_image "a magpie on a branch, watercolour" --size 16:9 -o magpie.png`.
+- **Size:** `size` gives the aspect ratio. A ratio (such as `16:9` or `1:4`) is used as it is when the model takes it, else the nearest one it does; a size such as `1536x1024` is made the nearest usual ratio by Magpie first. `quality` makes no difference for these models.
+- **Don't tick them as chat models:** Magpie still keeps a plugin's models that draw in its chat model lists ([yetone/magpie#2792](https://github.com/yetone/magpie/issues/2792)). They take no tool calls and have 32K–128K context windows, so they make poor chat models for agents.
+- If you don't want the image models, turn them off with `studio.imageModels` (see the options below).
+
+---
+
 ## Configuration & Advanced Usage
 
 <details>
@@ -68,12 +82,15 @@ Install **magpie-gemini-web** from the Magpie plugin market, then sign in to eit
 
 <br>
 
-Tool calling is enabled by default; image input is disabled by default. Configure plugin options via the CLI:
+Tool calling is enabled by default. Image input is on by default for AI Studio and off for Gemini Web. Configure plugin options via the CLI:
 
 ```bash
-# Enable image input (applies to both providers)
+# Turn image input on for both providers
 magpie plugin options magpie-gemini-web '{"allowImages":true}'
 
+# Turn image input off for AI Studio
+magpie plugin options magpie-gemini-web '{"studio":{"allowImages":false}}'
+
 # Configure a proxy for AI Studio
 magpie plugin options magpie-gemini-web '{"studio":{"proxy":"http://127.0.0.1:7890"}}'
 ```
@@ -85,7 +102,7 @@ magpie plugin options magpie-gemini-web '{"studio":{"proxy":"http://127.0.0.1:78
 | Option | Default | Scope | Description |
 | :--- | :--- | :--- | :--- |
 | `allowTools` | `true` | Shared (override via `studio.allowTools`) | Allow tool calls. When `false`, requests with tools return 400 |
-| `allowImages` | `false` | Shared (override via `studio.allowImages`) | Allow image input |
+| `allowImages` | Web: `false`; Studio: `true` | Shared (override via `studio.allowImages`) | Allow image input in a chat (an image model's reference images don't need it). Gemini Web reads images only when signed in and returns 400 otherwise; in testing, `gemini-3.6-flash` waited until the timeout on a chat with an image, while `gemini-3.5-flash-lite` and `gemini-3.8-flash` answered |
 | `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 |
@@ -94,6 +111,7 @@ magpie plugin options magpie-gemini-web '{"studio":{"proxy":"http://127.0.0.1:78
 | `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 |
 | `studio.baseURL` | `http://127.0.0.1:2048/v1` | `ai-studio` only | Default URL when connecting an existing AIStudio2API instance |
 | `studio.contextLimit` / `studio.outputLimit` | Model catalog defaults | `ai-studio` only | Limits reported to clients (can only lower the catalog defaults) |
+| `studio.imageModels` | `true` | `ai-studio` only | List the Nano Banana image models, for Magpie's image generation; `false` lists text models only |
 
 **Using a proxy to reach Google:**
 - **AI Studio:** Preferably set it in the local admin page. Open the address on the usage card's "管理页" (admin page) line (default `http://127.0.0.1:2048`) and sign in as `magpie` with `adminPassword` from `config.json` in the data directory. Save the proxy, then restart the service from the admin page. The plugin keeps the saved value when it restarts the backend.
@@ -149,7 +167,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.17-magpie.1`, based on upstream `v0.2.17`. 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.18-magpie.1`, based on upstream `v0.2.18`. 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.

package/README.md

@@ -17,9 +17,11 @@
 | **适用场景** | **推荐 Coding Agent 使用** | 日常对话、使用网页版专属模型与额度 |
 | **工具调用** | **原生 Function Calling**，稳定可靠 | 提示词模拟（实验性，Flash 系列常不调工具） |
 | **思考档位** | 按模型目录提供 `minimal` / `low` / `medium` / `high` 中支持的档位 | `low`（普通）/ `medium`（`-thinking-medium`，仅 `gemini-4-argon`）/ `high`（`-thinking` 扩展思考） |
+| **图片输入** | 默认开启，对话模型可以读图 | 默认关闭；开启后需要登录（挂 Cookie），见下文 |
+| **图片生成** | Nano Banana 系列模型，供 Magpie 的图片生成使用（需要 Magpie v0.1.2075+，见下文） | 不支持 |
 | **登录方式** | 弹出独立浏览器窗口直接登录 Google | 用无痕窗口登录并复制 `cookie` |
 | **额度卡片** | 显示冷却中的模型与恢复时间 | 同步网页版 **5 小时** 与 **每周** 用量及重置时间 |
-| **本地后端** | AIStudio2API (`v0.2.17`) | gemini-web2api-go (`4.26.0-magpie.1` 优化版) |
+| **本地后端** | AIStudio2API (`v0.2.18`) | gemini-web2api-go (`4.26.0-magpie.1` 优化版) |
 
 ---
 
@@ -31,7 +33,7 @@
 
 1. 在 Magpie 中登录 **Google AI Studio**，选择 **「用 Google 账号登录（推荐）」**。
 2. 在弹出的独立登录窗口中登录 Google 账号（不影响日常浏览器），完成后直接关闭窗口。
-   > 首次使用要先下载本地服务（约 30 MB）和登录浏览器 Camoufox（约 300 MB），弹窗可能需要等几分钟才出现。需要下载时，Magpie 会在浏览器里打开一个进度页，显示下载进度。Magpie 最多等 10 分钟（下载的时间也算在内），请尽快完成登录；连不上 GitHub 时，先按下面「插件选项与代理配置」设置 `studio.proxy`。
+   > 首次使用要先下载本地服务（约 40 MB）和登录浏览器 Camoufox（约 300 MB），弹窗可能需要等几分钟才出现。需要下载时，Magpie 会在浏览器里打开一个进度页，显示下载进度。Magpie 最多等 10 分钟（下载的时间也算在内），请尽快完成登录；连不上 GitHub 时，先按下面「插件选项与代理配置」设置 `studio.proxy`。
 3. **后续管理**：再次点击「用 Google 账号登录」，可选择**添加新账号**、为本机已有账号建卡，或为过期账号**重新登录**。
 
 ### 方式二：Gemini Web (`gemini-web`)
@@ -61,6 +63,18 @@
 
 ---
 
+## 图片生成（AI Studio）
+
+`ai-studio` 会列出账号可用的 Nano Banana 系列图像模型（如 `gemini-3.1-flash-image`、`gemini-3-pro-image`），供 Magpie 的图片生成使用。**需要 Magpie v0.1.2075 及以上**：从这个版本起，Magpie 才会把插件的 Gemini 图像模型列为出图模型。
+
+- **不用勾选，也不用在对话里选它们**：Magpie 设置的 **Images → Image generation** 会直接列出这些模型，选中一个，或保持 Automatic（自动）即可。
+- **Agent 怎么出图**：Agent 调用 Magpie 的 `generate_image` 工具（Library 里的 Magpie Image MCP），Magpie 用上面选的模型出图；带参考图就是改图。也可以在命令行试：`magpie tool generate_image "a magpie on a branch, watercolour" --size 16:9 -o magpie.png`。
+- **尺寸**：`size` 决定宽高比：写比例（如 `16:9`、`1:4`）时，模型支持就照用，不支持就取它支持的最接近的比例；写 `1536x1024` 这样的尺寸时，Magpie 先换成最接近的常用比例。`quality` 对这些模型不起作用。
+- **别把它们勾进对话模型**：Magpie 目前会把能出图的插件模型也留在对话模型列表里（[yetone/magpie#2792](https://github.com/yetone/magpie/issues/2792)）。它们不支持工具调用，上下文也只有 32K–128K，不适合当 Agent 的对话模型。
+- 不需要图像模型时，可以用 `studio.imageModels` 关掉（见下方选项）。
+
+---
+
 ## 配置与进阶
 
 <details>
@@ -68,12 +82,15 @@
 
 <br>
 
-工具调用默认开启，图片输入默认关闭。可通过命令行修改插件配置：
+工具调用默认开启。图片输入在 AI Studio 默认开启，在 Gemini Web 默认关闭。可通过命令行修改插件配置：
 
 ```bash
-# 开启图片输入（对两个 Provider 生效）
+# 两个 Provider 都开启图片输入
 magpie plugin options magpie-gemini-web '{"allowImages":true}'
 
+# 关闭 AI Studio 的图片输入
+magpie plugin options magpie-gemini-web '{"studio":{"allowImages":false}}'
+
 # 为 AI Studio 配置代理
 magpie plugin options magpie-gemini-web '{"studio":{"proxy":"http://127.0.0.1:7890"}}'
 ```
@@ -85,7 +102,7 @@ magpie plugin options magpie-gemini-web '{"studio":{"proxy":"http://127.0.0.1:78
 | 选项 | 默认值 | 适用范围 | 说明 |
 | :--- | :--- | :--- | :--- |
 | `allowTools` | `true` | 共用（可用 `studio.allowTools` 单独覆盖） | 允许工具调用。设为 `false` 时带工具的请求返回 400 |
-| `allowImages` | `false` | 共用（可用 `studio.allowImages` 单独覆盖） | 允许图片输入 |
+| `allowImages` | Web：`false`；Studio：`true` | 共用（可用 `studio.allowImages` 单独覆盖） | 允许对话中的图片输入（图像模型的参考图不受它限制）。Gemini Web 读图需要登录，未登录时返回 400；实测 `gemini-3.6-flash` 带图请求会一直等到超时，`gemini-3.5-flash-lite`、`gemini-3.8-flash` 正常 |
 | `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` 或在登录第一步填写 |
@@ -94,6 +111,7 @@ magpie plugin options magpie-gemini-web '{"studio":{"proxy":"http://127.0.0.1:78
 | `studio.proxy` | 无 | 仅 `ai-studio` | 访问 Google 的代理（`http` / `https` / `socks5`），也可用环境变量 `AI_STUDIO_PROXY`；设置后优先于管理页里保存的代理，留空等于不设置 |
 | `studio.baseURL` | `http://127.0.0.1:2048/v1` | 仅 `ai-studio` | 连接已有 AIStudio2API 时的默认地址 |
 | `studio.contextLimit` / `studio.outputLimit` | 模型目录默认值 | 仅 `ai-studio` | 向客户端声明的上限（仅支持在目录值基础上调低） |
+| `studio.imageModels` | `true` | 仅 `ai-studio` | 列出 Nano Banana 等图像模型，供 Magpie 的图片生成使用；设为 `false` 时只列文本模型 |
 
 **配置代理访问 Google：**
 - **AI Studio**：推荐在本地管理页设置。打开额度卡片「管理页」一行里的地址（默认 `http://127.0.0.1:2048`），用户名 `magpie`，密码是数据目录 `config.json` 里的 `adminPassword`；保存代理后在管理页重启服务即可生效，之后插件重启后端也不会覆盖它。
@@ -149,7 +167,7 @@ magpie plugin options magpie-gemini-web '{"studio":{"proxy":"http://127.0.0.1:78
 - 插件将请求并发限制为 1，但仍无法完全排除 Google 账号风控风险，请自行评估使用。
 
 **AI Studio 升级与模型范围：**
-- 插件固定使用经过 SHA-256 校验的 `v0.2.17-magpie.1`（基于上游 `v0.2.17`），通过升级插件更新后端。同基线或更旧的官方版、以及旧版插件装的托管后端，在下次管理启动时自动升级，保留账号、端口与登录凭据。
+- 插件固定使用经过 SHA-256 校验的 `v0.2.18-magpie.1`（基于上游 `v0.2.18`），通过升级插件更新后端。同基线或更旧的官方版、以及旧版插件装的托管后端，在下次管理启动时自动升级，保留账号、端口与登录凭据。
 - **托管后端已在 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 端口关闭但进程尚未退出时，插件不会重装或启动第二个进程。

package/docs/studio-release.md

@@ -1,36 +1,43 @@
 # AI Studio 托管后端构建
 
-插件使用 `0.2.17-magpie.1`，基于 AIStudio2API `v0.2.17` 的固定 commit。上游版本、commit、Go 版本、C 工具链（`toolchains`）、补丁列表、安装包及二进制 SHA-256 均记录在 `lib/studio-release.json`。`upstream.camoufox` 是这个 commit 要求的 Camoufox 版本（上游 `internal/camoufoxnative/download.go` 里的 `camoufoxRelease`），更新上游 commit 时要一起核对，构建脚本发现不一致会报错。MIT 许可见 `LICENSE-AISTUDIO`。
+插件使用 `0.2.18-magpie.1`，基于 AIStudio2API `v0.2.18` 的固定 commit。上游版本、commit、Go 版本、C/C++ 工具链与 SpiderMonkey 静态库（`toolchains`）、补丁列表、安装包及二进制 SHA-256 均记录在 `lib/studio-release.json`。`upstream.camoufox` 是这个 commit 要求的 Camoufox 版本（上游 `internal/camoufoxnative/download.go` 里的 `camoufoxRelease`），更新上游 commit 时要一起核对，构建脚本发现不一致会报错。MIT 许可见 `LICENSE-AISTUDIO`。
 
 ## 升级兼容
 
+- 上游 v0.2.18 删除了纯 Go（goja）的 WAA 后端 `go`，改为经 CGO 内嵌 Firefox 的 JS 引擎 SpiderMonkey（`WAA_BACKEND=spidermonkey`）。插件固定使用 `spidermonkey`：生成仍在服务进程内完成，不需要浏览器；Camoufox 仍只用于 Google 登录。上游默认的 `camoufox` 后端未采用。
+- SpiderMonkey 使用上游自己发布时用的预编译静态库（`Mag1cFall/firefox` 的 `v152.0.4-aistudio2api.1` release），每个目标的归档名与 SHA-256 记录在 `toolchains.spidermonkey`，构建时下载到 `studio-build/toolchains/` 并校验。头文件与库经 `CGO_CXXFLAGS` / `CGO_LDFLAGS` 传入，库名由上游 `internal/waa/mozjs` 的 `#cgo` 指令给出，与上游 `.github/actions/spidermonkey` 一致。
+- 新增设置 `SEARCH_MODEL_ALIASES`、`GOOGLE_SEARCH`、`CONTINUATION_REWRITE`、`CONTINUATION_PROMPT` 保留管理页保存的值，并隔离宿主环境同名变量。上游默认开启 `SEARCH_MODEL_ALIASES`，把每个可搜索的对话模型再列一份 `<id>-search`；插件在 `.env` 缺少该项时写入 `false`，避免 Magpie 的模型列表大多重复一遍，用户可在管理页开启。其余三项沿用上游默认。
+- Gemini 原生接口（`/v1beta`，Magpie 画图用）在 v0.2.18 按 Gemini 的方式拒绝密钥：错误密钥返回 400 `API_KEY_INVALID`，缺少密钥返回 403。插件把这两种情况当作 401 处理，提示重新登录；Google 自身返回的 403（如 code 7 “The caller does not have permission”）属于账号问题，原样传回。
 - 上游 v0.2.17 改用需要 CGO 的原生 SQLite。账号和配置沿用原目录；首次打开旧数据库会整理空闲页。降级前应停止服务并备份完整数据目录，旧版不保证能读取迁移后的数据。
-- 上游会删除旧的请求正文 `bodies` 表。`patches/studio-0.2.17-preserve-request-bodies.patch` 改为在事务内压缩并迁移到 `request_bodies`，已有新版同 ID 记录优先，成功后才删除旧表；失败回滚。补丁包含旧正文读取、重复打开及迁移失败回滚测试，随上游测试一起运行。
+- 上游（v0.2.17 起，v0.2.18 仍然）会删除旧的请求正文 `bodies` 表。`patches/studio-0.2.17-preserve-request-bodies.patch` 改为在事务内压缩并迁移到 `request_bodies`，已有新版同 ID 记录优先，成功后才删除旧表；失败回滚。补丁原样适用于 v0.2.18，供从 0.2.16 及更早版本直接升级的用户使用；它包含旧正文读取、重复打开及迁移失败回滚测试，随上游测试一起运行。
 - 新增的 `FIRST_EVENT_HEDGE` 保留管理页保存的值，同时隔离宿主环境同名变量。默认仍由上游设为 `off`。备用请求需要空闲账号和 Worker；插件默认单 Worker，不自动提高并发。
-- 模型档位优先使用 `/v1/models` 返回的 `thinking_levels`；旧外部服务未返回该字段时沿用四档。Playground 通道、纯 Go WAA、托管更新限制及插件默认并发保持原设置。
+- 模型档位优先使用 `/v1/models` 返回的 `thinking_levels`；旧外部服务未返回该字段时沿用四档。Playground 通道、托管更新限制及插件默认并发保持原设置。
 - macOS 与 Windows 都可能使用系统代理；显式代理及管理页设置仍优先，宿主的 `HTTP_PROXY` 等变量不传入服务。
 
 ## 在线更新策略
 
 上游从 v0.2.14 起原生支持分发方管理更新。构建时通过 `-ldflags` 写入两个值：
 
-- `internal/app.version=v0.2.17-magpie.1`：明确的版本标识。同基线或更旧的官方版、以及更旧的托管版需要升级；更新的官方版、更新的托管版或不认识的定制版仍提示冲突。
+- `internal/app.version=v0.2.18-magpie.1`：明确的版本标识。同基线或更旧的官方版、以及更旧的托管版需要升级；更新的官方版、更新的托管版或不认识的定制版仍提示冲突。
 - `internal/app.managedBy=magpie-gemini-web`：`GET /api/update`（包括 `?refresh=1`）只返回本地版本、`mode: managed` 和 `managed_by`，不访问 GitHub；`POST /api/update` 返回 HTTP 409，不下载、不替换文件、不重启。管理页显示“更新由 magpie-gemini-web 管理”。
 
 构建不带 `desktop` 标签，不包含桌面窗口。普通插件升级、账户登录、模型调用及管理功能继续保留，用户自行连接的外部服务不受影响。
 
 ## 复现构建
 
-维护者需要 Git、tar、curl、Node.js 26.8.2、Go 1.27.1，以及 `lib/studio-release.json` 的 `toolchains` 固定的 C 工具链。SQLite 需要 CGO，C 工具链因此也是 pin 的一部分：
+维护者需要 Git、tar、curl、Node.js 26.8.2、Go 1.27.1，以及 `lib/studio-release.json` 的 `toolchains` 固定的 C/C++ 工具链。SQLite 需要 C、SpiderMonkey 需要 C++，工具链因此也是 pin 的一部分：
 
 | 目标 | 工具链 | 跨机器字节一致 |
 |---|---|---|
-| Linux x64/arm64 | Zig `toolchains.zig`，musl 静态链接，不依赖构建机器的 glibc | 是：Zig 是自带 libc 的交叉编译器，任何主机产物相同 |
-| Windows x64 | llvm-mingw `toolchains.llvmMingw`（Clang + LLD + UCRT），静态链接，PE 时间戳为 0 | 是：同上；构建脚本自动下载并按 SHA-256 校验 |
+| Linux x64/arm64 | Zig `toolchains.zig`（`zig cc` / `zig c++`），musl 静态链接，不依赖构建机器的 glibc | 是：Zig 是自带 libc 的交叉编译器，任何主机产物相同 |
+| Windows x64 | llvm-mingw `toolchains.llvmMingw`（Clang + LLD + UCRT），静态链接，PE 时间戳为 0 | 是：同上；构建脚本自动下载并按 SHA-256 校验。Windows 的库（含 C++ 运行库）取自 Linux x64 归档，见下 |
 | macOS arm64/x64 | Xcode `toolchains.xcode`，最低目标 macOS 13（与 Go 1.27 一致），只能在 macOS 上构建 | 仅在同一 Xcode 下：Apple 链接器和 SDK 随 Xcode 变化 |
 
 - Zig 默认从 PATH 查找，也可用 `STUDIO_ZIG=/absolute/path/to/zig` 指定。
-- llvm-mingw 首次使用时下载到 `studio-build/toolchains/`（macOS、Linux x64、Windows x64 主机各有固定的归档及 SHA-256），之后复用。`STUDIO_MINGW_CC` 可指定其他 `x86_64-w64-mingw32-clang`，但 `--verify` / `--write-pins` 要求其版本与 pin 一致。
+- llvm-mingw 首次使用时下载到 `studio-build/toolchains/`（macOS、Linux x64、Windows x64 主机各有固定的归档及 SHA-256），之后复用。`STUDIO_MINGW_CC` 可指定其他 `x86_64-w64-mingw32-clang`（C++ 编译器取同目录的 `clang++`），但 `--verify` / `--write-pins` 要求其版本与 pin 一致。
+- llvm-mingw 的 Linux 与 Windows 归档里 Windows 目标库逐字节相同，macOS 归档里的是另行构建的，其中 C++ 运行库（libc++abi）会把各自的构建路径写进可执行文件。因此在 macOS 上构建 Windows 时，链接 Linux x64 归档（同样固定 SHA-256）里的目标库；各主机都以一个 `-L` 指明目标库目录，因为 cgo 会把每个链接参数写成生成代码的一行，参数个数不同会改变可执行文件里的行号表。
+- SpiderMonkey 静态库同样在首次使用时按目标下载到 `studio-build/toolchains/` 并校验 SHA-256，之后复用。
+- Linux（musl）的 SpiderMonkey 静态库带有 mozglue 的环境变量拦截函数（`libjs_static.a` 的 `Unified_cpp_mozglue_interposers0.o`）：除 `getenv` 外，`setenv` 等都经 `dlsym(RTLD_NEXT)` 找 C 库原函数，静态链接的程序找不到，便有意崩溃（`MOZ_CRASH`）；Go 的 `os.Setenv` 在 cgo 程序里正走这条路。构建脚本校验下载后用 `zig ar` 删除这个目标文件，改用 musl 自己的函数；找不到该文件时报错，提示核对新版 SpiderMonkey。上游测试只在动态链接的 glibc 库（`linux-amd64-gnu`）上运行，不会遇到这个问题。
 - Xcode 用 `DEVELOPER_DIR=/Applications/Xcode_<版本>.app/Contents/Developer` 选择，不需要改系统默认。不要用 beta 版 Xcode 制作发布包。
 - 所有目标都以 `-trimpath -buildvcs=false -ldflags=-buildid=` 编译：Go 默认的 build ID 会哈希 C 编译器路径等构建输入，导致不同机器上内容相同的程序哈希不同。
 - Windows 使用 Git Bash 执行命令，安装包运行和解压使用 Windows 自带 PowerShell。最终用户不需要构建工具。
@@ -86,7 +93,20 @@ AI_STUDIO_TEST_ARCHIVE=/absolute/path/to/archive.tar.gz npm test
 
 真实安装验证检查旧版请求正文迁移及重启后可读、管理页保存的备用请求设置、启动、版本、GET 更新状态、POST 更新返回 409、二进制及 PID 不变、管理页面显示托管提示、停止与状态。`.github/workflows/studio.yml` 在五种系统/架构的原生 runner 上重新构建、对比 SHA-256 并运行该验证；本机交叉编译不能代替 Linux/Windows 真机验证。
 
-## 本次升级验证（2026-10-29）
+## 0.2.18 升级验证（2026-10-30）
+
+以下为本分支的实际状态，发布前以最新 CI 结果为准。
+
+- 首次候选构建（run 41025535280）中，Linux x64/arm64 在上游测试 `TestUserCacheRootWithoutEnvironment` 的 `t.Setenv` 处崩溃（见上文环境变量拦截函数），Windows 的 macOS 本机交叉编译结果与 CI 不同（见上文 C++ 运行库）。两处修复后的候选构建（run 41033635405）五个平台都通过上游测试、真实安装冒烟验证（含 `waa_backend=spidermonkey`、`search_model_aliases=false`）与插件测试。
+- 跨机器一致性：Linux x64/arm64 与 Windows x64 的 CI 候选哈希与 macOS arm64 本机交叉编译完全一致；darwin-arm64 两次 CI 构建得到相同哈希。pin 来自第二次候选构建，随后的严格验证构建（run 41036094948）在五个平台的全新 runner 上重新构建，哈希与 pin 完全一致，冒烟验证与插件测试通过。
+- Linux 二进制为静态链接，不含环境变量拦截函数；Windows 二进制只导入系统 DLL（UCRT、KERNEL32 等），C++ 运行库静态链接，PE 时间戳为 0。
+- 真实账号端到端验证（CI 构建的 darwin-arm64 安装包，一个已登录账号复制到临时数据目录，原服务在验证期间停止、结束后恢复）：服务 8 秒就绪，WAA 后端为 spidermonkey，全程未启动 Camoufox；45 个模型中无 `-search` 副本；`gemini-3.8-flash` 文本（4 秒）、流式（3 秒）和图片输入（17 秒，答对左右两半颜色）正常；经插件用 `gemini-3.1-flash-image` 按 16:9 画图得到 1376×768 图片（9 秒）；错误密钥在 Gemini 接口上返回 400 `API_KEY_INVALID`，与插件的判断一致。
+- Google 登录（Camoufox 登录窗口）本次未验证：使用的是已登录账号。
+- 此分支未发布后端 release 或 npm 包。
+
+## 0.2.17 升级验证（2026-10-29，历史记录）
+
+以下为上一版 `0.2.17-magpie.1` 的验证结果，不代表 0.2.18。
 
 - 上游前端 lint/build、Go 测试（含迁移补丁测试）通过；插件完整测试 207 项通过，无跳过。
 - Linux 二进制为静态链接，Windows 二进制只导入 UCRT 与 KERNEL32、PE 时间戳为 0；npm 打包检查包含迁移补丁，排除构建产物。
@@ -95,14 +115,14 @@ AI_STUDIO_TEST_ARCHIVE=/absolute/path/to/archive.tar.gz npm test
 - 新版 Google 登录/生成端到端验证尚未完成。
 - 此分支未发布后端 release 或 npm 包。本机日常后端仍使用 `0.2.16-magpie.1`，新版仅在临时数据目录运行。
 
-发布前必须审查各平台 CI 与构建记录，再将安装包及许可证上传到本仓库 `studio-v0.2.17-magpie.1` release。该 release 可公开下载后，才能发布引用它的插件版本，否则新安装会遇到 404。构建脚本及验证 CI 不自动发布 release 或 npm 包。
+发布前必须审查各平台 CI 与构建记录，再将安装包及许可证上传到本仓库 `studio-v0.2.18-magpie.1` release。该 release 可公开下载后，才能发布引用它的插件版本，否则新安装会遇到 404。构建脚本及验证 CI 不自动发布 release 或 npm 包。
 
 本地试用建议使用独立数据目录：
 
 ```bash
-node scripts/studio.mjs install --data-dir /path/to/studio-017-trial --archive /absolute/path/to/archive
-node scripts/studio.mjs start --data-dir /path/to/studio-017-trial
-node scripts/studio.mjs stop --data-dir /path/to/studio-017-trial
+node scripts/studio.mjs install --data-dir /path/to/studio-018-trial --archive /absolute/path/to/archive
+node scripts/studio.mjs start --data-dir /path/to/studio-018-trial
+node scripts/studio.mjs stop --data-dir /path/to/studio-018-trial
 ```
 
 使用现有账号数据测试前，先停止旧服务并备份；不要让两个进程同时写同一个数据目录。

package/lib/backend.mjs

@@ -426,6 +426,68 @@ function timedBody(body, timer) {
   });
 }
 
+// keyRefused says whether an error on Gemini's own API is the AI Studio service refusing the key.
+// From 0.2.18 it says so as Gemini does: 400 API_KEY_INVALID for a wrong key, 403 for none. A 403
+// from Google itself ("The caller does not have permission") is about the account, not the key.
+function keyRefused(status, text) {
+  let error;
+  try {
+    const body = JSON.parse(text);
+    error = (Array.isArray(body) ? body[0] : body)?.error;
+  } catch {
+    return false;
+  }
+  if (status === 400) return Array.isArray(error?.details) && error.details.some(detail => detail?.reason === 'API_KEY_INVALID');
+  return error?.status === 'PERMISSION_DENIED' && /unregistered callers/.test(error.message);
+}
+
+const GEMINI_CALL = /^\/models\/([^/:]+):(generateContent|streamGenerateContent)$/;
+
+// geminiTarget is where a call on Gemini's own API goes at the AI Studio service, with the model
+// it names: the service's /v1beta, beside the /v1 that baseURL always ends in. Magpie draws with
+// an image model there (the model's npm is @ai-sdk/google, see listStudioModels), asking
+// <baseURL>/models/<id>:streamGenerateContent?alt=sse. null for any other request, and for one
+// with any other query.
+function geminiTarget(url, baseURL) {
+  const base = new URL(baseURL);
+  if (url.origin !== base.origin || !url.pathname.startsWith(base.pathname + '/')) return null;
+  const m = GEMINI_CALL.exec(url.pathname.slice(base.pathname.length));
+  if (!m || url.hash || (url.search && url.search !== '?alt=sse')) return null;
+  let model;
+  try {
+    model = decodeURIComponent(m[1]);
+  } catch {
+    return null;
+  }
+  return { url: `${baseURL}beta/models/${m[1]}:${m[2]}${url.search}`, model };
+}
+
+// The line Magpie ends a drawing's prompt with when a size is asked for (drawPrompt): a ratio
+// given as one, or the nearest of its usual ones to a WIDTHxHEIGHT size.
+const ASPECT_LINE = /\n\nAspect ratio: (\d+(?:\.\d+)?):(\d+(?:\.\d+)?)\./;
+
+// aspectRatio moves the aspect ratio a generateContent request's prompt names to
+// imageConfig.aspectRatio, as one of aspects, the model's: the one named when the model takes it,
+// else the nearest. With the line in its prompt, gemini-3.1-flash-lite-image (seen on
+// AIStudio2API 0.2.17) answered with no image at all, each of three times; with imageConfig it
+// drew. A request that names a ratio in imageConfig already is left as it is.
+function aspectRatio(body, aspects) {
+  const config = body.generationConfig && typeof body.generationConfig === 'object' ? body.generationConfig : {};
+  if (config.imageConfig?.aspectRatio) return;
+  const contents = Array.isArray(body.contents) ? body.contents : [];
+  const content = contents.findLast(c => c?.role === 'user' && Array.isArray(c.parts));
+  const part = content?.parts.find(p => typeof p?.text === 'string' && ASPECT_LINE.test(p.text));
+  if (!part) return;
+  const [, w, h] = ASPECT_LINE.exec(part.text);
+  const asked = `${w}:${h}`;
+  const log = r => Math.log(Number(r.split(':')[0]) / Number(r.split(':')[1]));
+  const nearest = aspects.includes(asked)
+    ? asked
+    : aspects.reduce((best, r) => Math.abs(log(r) - log(asked)) < Math.abs(log(best) - log(asked)) ? r : best);
+  part.text = part.text.replace(ASPECT_LINE, '');
+  body.generationConfig = { ...config, imageConfig: { ...config.imageConfig, aspectRatio: nearest } };
+}
+
 export async function forward(input, init, getAuth, opts) {
   const req = new Request(input, init);
 
@@ -454,7 +516,11 @@ export async function forward(input, init, getAuth, opts) {
     return makeOpenAIError(400, 'Invalid request URL');
   }
 
-  if (reqUrl.search || reqUrl.hash) {
+  // AI Studio's image models are asked on Gemini's own API (opts.imageModel, see imageModelOf)
+  const gemini = opts.imageModel ? geminiTarget(reqUrl, c.baseURL) : null;
+  const geminiUrl = gemini?.url;
+
+  if ((reqUrl.search || reqUrl.hash) && !geminiUrl) {
     return makeOpenAIError(400, 'Query parameters and fragments are not allowed');
   }
 
@@ -462,13 +528,16 @@ export async function forward(input, init, getAuth, opts) {
   const modelsUrl = `${c.baseURL}/models`;
   const incomingUrl = `${reqUrl.origin}${reqUrl.pathname}`;
 
-  if (incomingUrl !== chatUrl && incomingUrl !== modelsUrl) {
+  if (incomingUrl !== chatUrl && incomingUrl !== modelsUrl && !geminiUrl) {
     return makeOpenAIError(404, 'Endpoint not found');
   }
 
   if (incomingUrl === chatUrl && req.method !== 'POST') {
     return makeOpenAIError(400, 'Method not allowed: /chat/completions requires POST');
   }
+  if (geminiUrl && req.method !== 'POST') {
+    return makeOpenAIError(400, 'Method not allowed: generateContent requires POST');
+  }
   if (incomingUrl === modelsUrl && req.method !== 'GET') {
     return makeOpenAIError(400, 'Method not allowed: /models requires GET');
   }
@@ -550,6 +619,47 @@ export async function forward(input, init, getAuth, opts) {
       body.model = twin;
       rawBody = JSON.stringify(body);
     }
+  } else if (geminiUrl) {
+    try {
+      rawBody = await req.text();
+    } catch {
+      return makeOpenAIError(400, 'Failed to read request body');
+    }
+
+    let body;
+    try {
+      body = JSON.parse(rawBody);
+    } catch {
+      return makeOpenAIError(400, 'Invalid JSON body');
+    }
+    if (!body || typeof body !== 'object' || Array.isArray(body)) {
+      return makeOpenAIError(400, 'Request body must be a JSON object');
+    }
+
+    if (!opts.allowTools && Array.isArray(body.tools) && body.tools.length > 0) {
+      return makeOpenAIError(400, `Tool calls are turned off for magpie-gemini-web. Turn them on with: magpie plugin options magpie-gemini-web '{"allowTools":true}'`);
+    }
+
+    // A text model is asked on chat completions, where allowImages holds. One the service's list
+    // can't tell of goes no further: an unreachable service is answered as one, for a managed one
+    // to be started again (forwardManagedStudio).
+    let aspects;
+    try {
+      aspects = await opts.imageModel(c, gemini.model);
+    } catch (err) {
+      if (err?.unreachable) {
+        return makeOpenAIError(502, 'Bad gateway: failed to reach backend service', { [UNREACHABLE_HEADER]: 'unreachable' });
+      }
+      if (err?.signIn === 'expired') {
+        return makeOpenAIError(401, 'Unauthorized: AI Studio refused the key');
+      }
+      return makeOpenAIError(503, `Can't tell whether ${gemini.model} is one of AI Studio's image models: ${err?.message || err}`);
+    }
+    if (!aspects) {
+      return makeOpenAIError(400, `${gemini.model} isn't one of AI Studio's image models: generateContent here is for those alone, and a text model is asked on /chat/completions`);
+    }
+    aspectRatio(body, aspects);
+    rawBody = JSON.stringify(body);
   }
 
   // requestTimeoutMs bounds each wait on the backend, for the response headers and then for each
@@ -561,7 +671,7 @@ export async function forward(input, init, getAuth, opts) {
   timer.start();
   try {
     // Bun's fetch drops a connection idle for 300 s; the timer sets the deadline instead.
-    upstreamRes = await fetch(incomingUrl, {
+    upstreamRes = await fetch(geminiUrl || incomingUrl, {
       method: req.method,
       headers,
       body: rawBody,
@@ -593,6 +703,13 @@ export async function forward(input, init, getAuth, opts) {
 
   // Gemini's citation markers come out of a chat reply, streamed or whole (see cite.mjs).
   let respBody = upstreamRes.body && timedBody(upstreamRes.body, timer);
+  if (geminiUrl && (upstreamRes.status === 400 || upstreamRes.status === 403) && respBody) {
+    const text = await new Response(respBody).text();
+    if (keyRefused(upstreamRes.status, text)) {
+      return makeOpenAIError(401, 'Unauthorized: AI Studio refused the key');
+    }
+    respBody = text;
+  }
   if (opts.stripCitations && incomingUrl === chatUrl && upstreamRes.ok && respBody) {
     const type = upstreamRes.headers.get('content-type') || '';
     if (type.includes('text/event-stream')) respBody = citeStream(respBody);

package/lib/studio-native.mjs

@@ -197,7 +197,8 @@ const ENV_KEYS = [
   'ROUTING_STRATEGY', 'UPSTREAM_CHANNELS', 'MODEL_MAPPING', 'MODEL_CHANNELS', 'TEMPORARY_CHAT', 'WAA_BACKEND',
   'MEDIA_OUTPUT', 'MEDIA_BASE_URL', 'AUTO_START', 'REQUEST_BODY_LOG', 'LOG_FILE', 'LOG_MAX_TOTAL_MB',
   'ADMIN_AUTH_ENABLED', 'ADMIN_USERNAME', 'ADMIN_PASSWORD', 'BUILD_NATIVE_NONSTREAM',
-  'NONSTREAM_KEEPALIVE', 'FAKE_STREAM', 'YOUTUBE_LINKS', 'FIRST_EVENT_HEDGE'
+  'NONSTREAM_KEEPALIVE', 'FAKE_STREAM', 'YOUTUBE_LINKS', 'SEARCH_MODEL_ALIASES', 'GOOGLE_SEARCH',
+  'FIRST_EVENT_HEDGE', 'CONTINUATION_REWRITE', 'CONTINUATION_PROMPT'
 ];
 
 // PROXY_ENV are the proxy variables the service would fall back to with no PROXY of its own.
@@ -216,7 +217,10 @@ const SETTING_DEFAULTS = {
   ROUTING_STRATEGY: 'fill-first',
   REQUEST_TIMEOUT: '30m',
   INIT_TIMEOUT: '2m',
-  NONSTREAM_KEEPALIVE: 'false'
+  NONSTREAM_KEEPALIVE: 'false',
+  // Upstream lists each chat model that can search Google again as <id>-search (0.2.18), which
+  // would list most of Magpie's AI Studio models twice.
+  SEARCH_MODEL_ALIASES: 'false'
 };
 
 // pluginEnv is the settings this plugin depends on to reach, trust and drive the service. The
@@ -235,7 +239,7 @@ function pluginEnv(dataDir, config) {
     ADMIN_USERNAME: config.adminUsername,
     ADMIN_PASSWORD: config.adminPassword,
     AUTO_START: 'true',
-    WAA_BACKEND: 'go',
+    WAA_BACKEND: 'spidermonkey',
     UPSTREAM_CHANNELS: 'playground',
     BUILD_NATIVE_NONSTREAM: 'false'
   };

package/lib/studio-release.json

@@ -1,7 +1,7 @@
 {
-  "version": "0.2.17-magpie.1",
+  "version": "0.2.18-magpie.1",
   "repository": "BUKOWSKIREAL/magpie-gemini-web",
-  "tag": "studio-v0.2.17-magpie.1",
+  "tag": "studio-v0.2.18-magpie.1",
   "goVersion": "1.27.1",
   "toolchains": {
     "zig": "0.16.0",
@@ -26,12 +26,38 @@
           "sha256": "fd5462b7f5d93b2ff981fcd3f9c7e427e47f3203c64ea91c27bcc444eebd74cd"
         }
       }
+    },
+    "spidermonkey": {
+      "release": "v152.0.4-aistudio2api.1",
+      "repository": "Mag1cFall/firefox",
+      "targets": {
+        "darwin-arm64": {
+          "asset": "spidermonkey-v152.0.4-aistudio2api.1-darwin-arm64.tar.gz",
+          "sha256": "19f690d52ce2cfe7dbaedcc9771976145fff0dbd81f24e89a2dd094a1424b673"
+        },
+        "darwin-x64": {
+          "asset": "spidermonkey-v152.0.4-aistudio2api.1-darwin-amd64.tar.gz",
+          "sha256": "8063d69f56711c72b1244c8415b6c5096aa64ae8b022f555722667531acfe659"
+        },
+        "linux-x64": {
+          "asset": "spidermonkey-v152.0.4-aistudio2api.1-linux-amd64.tar.gz",
+          "sha256": "d3ecebf1890355426ad261ab8723038849a524b348af53e1bb440ca53cc2cacb"
+        },
+        "linux-arm64": {
+          "asset": "spidermonkey-v152.0.4-aistudio2api.1-linux-arm64.tar.gz",
+          "sha256": "b3c9539b8d8378d99f86b267e0e3d007dd01ff80acebf4f52f3e1d6ac04d9d00"
+        },
+        "win32-x64": {
+          "asset": "spidermonkey-v152.0.4-aistudio2api.1-windows-amd64.tar.gz",
+          "sha256": "942a3b57b202f899d799cac678b7471d01d0b34714070f0810c18fca37ffd721"
+        }
+      }
     }
   },
   "upstream": {
-    "version": "0.2.17",
+    "version": "0.2.18",
     "repository": "https://github.com/Mag1cFall/AIStudio2API.git",
-    "commit": "bd6c40f5f8a3a680a19a1ebff67216298d8bae27",
+    "commit": "9b694a6b7c6439db1767a577994dfcc87a3cf588",
     "camoufox": "152.0.4-beta.29"
   },
   "patches": [
@@ -39,29 +65,29 @@
   ],
   "binaries": {
     "darwin-arm64": {
-      "asset": "aistudio2api-v0.2.17-magpie.1-darwin-arm64.tar.gz",
-      "sha256": "10a6f71fcd8313b4d3afc72797027454ff45ae545dfd2bbd96cc0b4b97004517",
-      "binarySha256": "5978c56cb705eb1b449e59b772655aac2b3aa933da82e71ce28e7d6f7029e8ef"
+      "asset": "aistudio2api-v0.2.18-magpie.1-darwin-arm64.tar.gz",
+      "sha256": "9f70596a5b95f4bcf5347a52b88ad41e26106cd6e2a79304183a73d58d8a7a29",
+      "binarySha256": "d41e9d4c950efb479ad19727bdf496f8de05c01451110fd9eb7425a9054f5c66"
     },
     "darwin-x64": {
-      "asset": "aistudio2api-v0.2.17-magpie.1-darwin-amd64.tar.gz",
-      "sha256": "44527571d9294db1451ebb215552a76f3836be9e3a1a5e5fd79bfc57ad6b9878",
-      "binarySha256": "f3b3d48094d1a7849c455b31487db5e4569de00124d092d1c639d63fb0162178"
+      "asset": "aistudio2api-v0.2.18-magpie.1-darwin-amd64.tar.gz",
+      "sha256": "b118733750a3f882fe13754b2079f9cc89b2645d3cd3bce4bab26aaee24b54e5",
+      "binarySha256": "6a1017195809a881614032be647faf25754ebfe060e3301424dcdacefba32469"
     },
     "linux-x64": {
-      "asset": "aistudio2api-v0.2.17-magpie.1-linux-amd64.tar.gz",
-      "sha256": "47bc3922c54031435fc35914cf382d20a892ca0a2f4432eb0904677a57b002c0",
-      "binarySha256": "385b21e2d5905acb062a355ebf15c2db17492212a2ab93ef14da2f6acece96a1"
+      "asset": "aistudio2api-v0.2.18-magpie.1-linux-amd64.tar.gz",
+      "sha256": "e6310fb89c34295d1a4c60e40b30d7a3073e9f5fc16343650f4021f396225922",
+      "binarySha256": "1803037342daada925486f5acd40bfc0bc06bda54b0f1f4459da79d1e917d283"
     },
     "linux-arm64": {
-      "asset": "aistudio2api-v0.2.17-magpie.1-linux-arm64.tar.gz",
-      "sha256": "689e7644c766a9da8d8a462752e2495bbc659484e65d280fcf7e6554c6ec17b7",
-      "binarySha256": "20971e5abe5eb27e7e91f1cc2b665c41cd07ad9e1e9a2aa2b8aa7f87a8f1ebe0"
+      "asset": "aistudio2api-v0.2.18-magpie.1-linux-arm64.tar.gz",
+      "sha256": "965336192889bcd2d9f6db1e5f9c035251ff64db86ff0e590d9ed89662867629",
+      "binarySha256": "81553da83a7322d608b2498e6c6a01b08fe963341d8655262ed2dd17ca7a83df"
     },
     "win32-x64": {
-      "asset": "aistudio2api-v0.2.17-magpie.1-windows-amd64.zip",
-      "sha256": "79f8372f81cbe93ad4e663e7a400989e9d55d57f25dd40ca47decfb838071980",
-      "binarySha256": "e05b28fee8a5130074e3e0c23514e3b6451ba1c938458ae63576ffc6d81746f5"
+      "asset": "aistudio2api-v0.2.18-magpie.1-windows-amd64.zip",
+      "sha256": "537884412868849665b22d5d9066101a94d389ad0f048555da8c8ea55c7240ba",
+      "binarySha256": "0024d8709eb97950ddb3ad6016612521a76c7aca553235db2dddb9183188806e"
     }
   }
 }

package/lib/studio.mjs

@@ -10,6 +10,19 @@ const STUDIO_EXCLUDE = /(?:image|nano-banana|tts|audio|live|transcribe|robotics|
 // Catalog capabilities of models made for images, speech or live sessions. Such a model can be
 // marked chat_model and named like a text model too (gemini-omni-*), so the name can't tell.
 const NON_TEXT_CAPS = ['image_route', 'speech_route', 'live_route', 'aspect_ratio', 'output_resolution', 'interactions_api', 'transcription_output'];
+// Of those, the ones an image model (image_route) has. Such a model is listed for Magpie's image
+// generation (one with any other is left out still): on Gemini's own API (@ai-sdk/google), as
+// Magpie draws only with a plugin's Gemini image model there, asking generateContent for images
+// (see forward). Magpie keeps it in its chat model lists too, if it is ticked there.
+const IMAGE_CAPS = new Set(['image_route', 'aspect_ratio', 'output_resolution']);
+// The aspect ratios of an image model whose catalog entry lists none (capability_options
+// .image_aspect_ratios), as the service takes them then (openAIImageAspectRatios).
+const DEFAULT_ASPECTS = ['1:1', '2:3', '3:2', '3:4', '4:3', '4:5', '5:4', '9:16', '16:9', '21:9'];
+const ASPECT = /^\d+(?:\.\d+)?:\d+(?:\.\d+)?$/;
+// The image models each backend's last list named (listStudioModels), with their aspect ratios,
+// for the requests on Gemini's API (imageModelOf); asked again once this old.
+const IMAGE_CATALOG_MS = 10 * 60 * 1000;
+const imageCatalogs = new Map();
 const CONTROL_CHARS = /[\x00-\x1f\x7f]/;
 
 // Magpie waits 10 minutes for a sign-in once authorize returns (signInTimeout), downloads and the
@@ -57,6 +70,7 @@ const KNOWN_STUDIO_NESTED = new Set([
   'baseURL',
   'allowTools',
   'allowImages',
+  'imageModels',
   'contextLimit',
   'outputLimit',
   'requestTimeoutMs',
@@ -78,7 +92,10 @@ export function studioSettings(options = {}) {
     allowTools = options.allowTools;
   }
 
-  let allowImages = false;
+  // On unless turned off: AI Studio's chat models read a chat's images (seen on AIStudio2API
+  // 0.2.17). Gemini Web keeps it off by default (settings), as gemini-3.6-flash there never
+  // answered a chat with an image, each of two times.
+  let allowImages = true;
   if (options.allowImages !== undefined) {
     if (typeof options.allowImages !== 'boolean') {
       throw new Error('Invalid option allowImages: must be a boolean');
@@ -102,6 +119,7 @@ export function studioSettings(options = {}) {
     modelTimeoutMs = options.modelTimeoutMs;
   }
 
+  let imageModels = true;
   let baseURL = STUDIO_BASE;
   let proxy;
   let explicitContextLimit = null;
@@ -140,6 +158,12 @@ export function studioSettings(options = {}) {
       }
       allowImages = s.allowImages;
     }
+    if (s.imageModels !== undefined) {
+      if (typeof s.imageModels !== 'boolean') {
+        throw new Error('Invalid option studio.imageModels: must be a boolean');
+      }
+      imageModels = s.imageModels;
+    }
     if (s.requestTimeoutMs !== undefined) {
       if (!Number.isInteger(s.requestTimeoutMs) || s.requestTimeoutMs <= 0) {
         throw new Error('Invalid option studio.requestTimeoutMs: must be a positive integer');
@@ -173,6 +197,7 @@ export function studioSettings(options = {}) {
     baseURL,
     allowTools,
     allowImages,
+    imageModels,
     requestTimeoutMs,
     modelTimeoutMs,
     proxy,
@@ -225,6 +250,7 @@ export async function listStudioModels(c, opts) {
 
   const result = Object.create(null);
   const seen = new Set();
+  const images = new Map();
   // A model no enabled account's subscription covers is listed without channels, and calls to it
   // get a 403. A backend that lists no channels at all is older than that rule: keep its models.
   const listsChannels = body.data.some(item => Array.isArray(item?.channels));
@@ -240,14 +266,17 @@ export async function listStudioModels(c, opts) {
     if (!id.startsWith('gemini-')) continue;
     // Build assistant models inject Google's coding-agent prompt and do not expose
     // ordinary function calling. Keep them out of this general-purpose provider.
-    if (STUDIO_EXCLUDE.test(id) || /-build$/i.test(id)) continue;
+    if (/-build$/i.test(id)) continue;
 
     const methods = Array.isArray(item.supported_generation_methods) ? item.supported_generation_methods : [];
     if (!methods.includes('generateContent')) continue;
 
     const caps = item.capabilities && typeof item.capabilities === 'object' ? item.capabilities : {};
     if (caps.chat_model !== true || caps.assistant_route === true) continue;
-    if (NON_TEXT_CAPS.some(cap => caps[cap] === true)) continue;
+    // An image model is named for images, so the name filter is for the others only.
+    const draws = caps.image_route === true;
+    if (draws ? !opts.imageModels : STUDIO_EXCLUDE.test(id)) continue;
+    if (NON_TEXT_CAPS.some(cap => caps[cap] === true && !(draws && IMAGE_CAPS.has(cap)))) continue;
     if (listsChannels && !(Array.isArray(item.channels) && item.channels.length > 0)) continue;
 
     if (seen.has(id)) continue;
@@ -271,7 +300,14 @@ export async function listStudioModels(c, opts) {
       ? item.thinking_levels.filter(level => ['minimal', 'low', 'medium', 'high'].includes(level))
       : ['minimal', 'low', 'medium', 'high'];
     const variants = caps.thinking_level === true ? Object.fromEntries(levels.map(level => [level, {}])) : {};
-    const image = Boolean(opts.allowImages && caps.media_resolution === true);
+    // An image model takes images to edit or draw from, which allowImages (images in a chat on
+    // chat completions) doesn't cover.
+    const image = draws || Boolean(opts.allowImages && caps.media_resolution === true);
+    if (draws) {
+      const listed = item.capability_options?.image_aspect_ratios;
+      const aspects = Array.isArray(listed) ? listed.filter(r => typeof r === 'string' && ASPECT.test(r)) : [];
+      images.set(id, aspects.length > 0 ? aspects : DEFAULT_ASPECTS);
+    }
 
     result[id] = {
       id,
@@ -280,7 +316,7 @@ export async function listStudioModels(c, opts) {
       api: {
         id,
         url: c.baseURL,
-        npm: '@ai-sdk/openai-compatible'
+        npm: draws ? '@ai-sdk/google' : '@ai-sdk/openai-compatible'
       },
       limit: {
         context,
@@ -296,7 +332,8 @@ export async function listStudioModels(c, opts) {
           image
         },
         output: {
-          text: true
+          text: true,
+          image: draws
         }
       },
       cost: {
@@ -318,9 +355,31 @@ export async function listStudioModels(c, opts) {
     throw new Error('No usable Gemini models found in AI Studio response');
   }
 
+  imageCatalogs.set(catalogKey(c), { images, at: Date.now() });
   return result;
 }
 
+function catalogKey(c) {
+  return `${c.baseURL}\n${c.key}`;
+}
+
+// imageModelOf is the aspect ratios of the image model id, which a request on Gemini's API names
+// (see forward), as the backend's list says, asking it again once its last is old: null for a
+// model that isn't one. When the list can't be had again, its last still holds; with none, what
+// the model is isn't known, and the list's error is thrown for forward to answer with.
+async function imageModelOf(c, opts, id) {
+  const key = catalogKey(c);
+  const cached = imageCatalogs.get(key);
+  if (!cached || Date.now() - cached.at > IMAGE_CATALOG_MS) {
+    try {
+      await listStudioModels(c, opts);
+    } catch (err) {
+      if (!cached) throw err;
+    }
+  }
+  return imageCatalogs.get(key).images.get(id) ?? null;
+}
+
 function sameBackend(c, local) {
   return c.key === local.apiKey && c.baseURL === local.baseURL;
 }
@@ -349,6 +408,13 @@ function staleManagedSignIn(auth, opts) {
 
 async function forwardManagedStudio(input, init, getAuth, opts) {
   const retryInput = input instanceof Request ? input.clone() : input;
+  // Gemini's API, for the image models alone (see forward)
+  const forwardOpts = {
+    ...opts,
+    nativeThinking: true,
+    stripCitations: false,
+    imageModel: opts.imageModels ? (c, id) => imageModelOf(c, opts, id) : undefined
+  };
 
   const auth = await getAuth();
   if (auth?.metadata?.managed === true && staleManagedSignIn(auth, opts)) {
@@ -356,7 +422,7 @@ async function forwardManagedStudio(input, init, getAuth, opts) {
   }
 
   const callerSignal = input instanceof Request ? input.signal : init?.signal;
-  const res = await forward(input, init, getAuth, { ...opts, nativeThinking: true, stripCitations: false });
+  const res = await forward(input, init, getAuth, forwardOpts);
   if (res.headers.get(UNREACHABLE_HEADER) !== 'unreachable') return res;
 
   if (callerSignal?.aborted) return res;
@@ -369,7 +435,7 @@ async function forwardManagedStudio(input, init, getAuth, opts) {
   }
 
   if (callerSignal?.aborted) return res;
-  return forward(retryInput, init, getAuth, { ...opts, nativeThinking: true, stripCitations: false });
+  return forward(retryInput, init, getAuth, forwardOpts);
 }
 
 // accountSignIn is the Magpie sign-in for one Google account of the local service: the service's
@@ -670,7 +736,7 @@ export const AIStudioPlugin = async (_input, options = {}) => {
       proxy = downloadProxy(studioDataDir(), opts.proxy);
     } catch {}
     const via = proxy ? `走代理 ${redactProxy(proxy)}` : '按 Magpie 的代理设置';
-    return `本地 AI Studio 服务还没启动：要先启动它，第一次使用或插件更新后还要先从 GitHub 下载（约 30 MB，${via}），可能要等几分钟。${SETUP_PROXY_HINT}\n`;
+    return `本地 AI Studio 服务还没启动：要先启动它，第一次使用或插件更新后还要先从 GitHub 下载（约 40 MB，${via}），可能要等几分钟。${SETUP_PROXY_HINT}\n`;
   }
 
   // addAccount signs a new Google account in through the service's own login window, setting the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magpie-gemini-web",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Gemini Web and Google AI Studio provider for Magpie, backed by gemini-web2api-go and AIStudio2API",
   "type": "module",
   "main": "./index.mjs",

package/scripts/studio-managed-smoke.mjs

@@ -39,7 +39,11 @@ try {
   assert.equal(migratedBody.response, 'old response');
   assert.equal(migratedBody.request_size, 100);
   assert.equal(migratedBody.response_size, 200);
-  assert.equal((await studioAdmin(local, 'GET', '/api/config')).first_event_hedge, 'auto');
+  const config = await studioAdmin(local, 'GET', '/api/config');
+  assert.equal(config.first_event_hedge, 'auto');
+  // Generation's WAA runs in the service itself, on SpiderMonkey, with no copies of the models
+  assert.equal(config.waa_backend, 'spidermonkey');
+  assert.equal(config.search_model_aliases, false);
   const pidBefore = fs.readFileSync(path.join(dataDir, 'backend.pid'), 'utf8');
   const status = await studioAdmin(local, 'GET', '/api/status');
   assert.equal(status.version, STUDIO_VERSION);
@@ -77,7 +81,7 @@ try {
   await ensureStudio({ dataDir, managementOnly: true });
   assert.deepEqual(await studioAdmin(local, 'GET', '/api/requests/legacy-smoke/body'), migratedBody);
   assert.deepEqual(await stopStudio({ dataDir }), { stopped: true });
-  console.log(`PASS ${key}: ${STUDIO_VERSION} (${source}), legacy body migration/restart, saved hedge setting, managed status, update HTTP 409, unchanged executable/PID, managed UI, clean stop`);
+  console.log(`PASS ${key}: ${STUDIO_VERSION} (${source}), legacy body migration/restart, saved hedge setting, SpiderMonkey WAA, managed status, update HTTP 409, unchanged executable/PID, managed UI, clean stop`);
 } finally {
   let stopped = !local;
   if (local) stopped = (await stopStudio({ dataDir }).catch(() => ({ stopped: false }))).stopped;

package/scripts/studio-release.mjs

@@ -38,10 +38,11 @@ const env = { ...process.env, CGO_ENABLED: '1', GOFLAGS: '', GOEXPERIMENT: '',
   GOTOOLCHAIN: `go${release.goVersion}`, GOAMD64: 'v1', GOARM64: 'v8.0' };
 for (const key of ['GOOS', 'GOARCH', 'CC', 'CXX', 'CGO_CFLAGS', 'CGO_CPPFLAGS', 'CGO_CXXFLAGS', 'CGO_LDFLAGS', 'MACOSX_DEPLOYMENT_TARGET']) delete env[key];
 const hash = file => crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
-// SQLite now needs C, so the C toolchain is part of the pin (lib/studio-release.json "toolchains").
-// Zig (Linux/musl) and llvm-mingw (Windows/UCRT) are cross compilers whose output does not depend on
-// the machine they run on, so any builder reproduces those archives. Apple's linker and SDK are only
-// on macOS and differ between Xcode releases, so macOS archives match only under the pinned Xcode.
+// SQLite needs C and SpiderMonkey C++, so the C/C++ toolchain is part of the pin (lib/studio-release.json
+// "toolchains"). Zig (Linux/musl) and llvm-mingw (Windows/UCRT) are cross compilers whose output does
+// not depend on the machine they run on, so any builder reproduces those archives. Apple's linker and
+// SDK are only on macOS and differ between Xcode releases, so macOS archives match only under the
+// pinned Xcode. SpiderMonkey's static libraries are upstream's prebuilt ones, pinned per target.
 const toolchains = release.toolchains;
 const zig = process.env.STUDIO_ZIG || 'zig';
 function pinned(what, actual, expected, hint) {
@@ -50,39 +51,87 @@ function pinned(what, actual, expected, hint) {
   if (strict) throw new Error(message);
   console.warn(`warning: ${message}`);
 }
-// llvmMingw returns the pinned llvm-mingw's x86_64 compiler, fetched once into studio-build/toolchains
-// and checked against its pinned SHA-256, unless STUDIO_MINGW_CC names one.
-function llvmMingw() {
-  if (process.env.STUDIO_MINGW_CC) return process.env.STUDIO_MINGW_CC;
-  const pin = toolchains.llvmMingw;
-  const host = process.platform === 'darwin' ? 'darwin' : `${process.platform}-${process.arch}`;
-  const archive = pin.hosts[host];
-  if (!archive) throw new Error(`No pinned llvm-mingw for ${host}: set STUDIO_MINGW_CC to llvm-mingw ${pin.version}'s x86_64-w64-mingw32-clang`);
+// fetchPinned returns studio-build/toolchains/<name>, where the archive at url is unpacked once after
+// its SHA-256 is checked against the pinned one. top is the folder the archive holds everything in,
+// or null for an archive that unpacks in place; prepare, if given, changes what was unpacked first.
+function fetchPinned(what, url, { asset, sha256 }, name, top, prepare) {
   const cacheDir = path.join(root, 'studio-build/toolchains');
-  const name = archive.asset.replace(/\.(tar\.xz|zip)$/, '');
   const home = path.join(cacheDir, name);
-  const cc = path.join(home, 'bin', `x86_64-w64-mingw32-clang${process.platform === 'win32' ? '.exe' : ''}`);
   const stamp = path.join(home, '.sha256');
-  if (fs.existsSync(cc) && fs.existsSync(stamp) && fs.readFileSync(stamp, 'utf8').trim() === archive.sha256) return cc;
+  if (fs.existsSync(stamp) && fs.readFileSync(stamp, 'utf8').trim() === sha256) return home;
   fs.rmSync(home, { recursive: true, force: true });
   fs.mkdirSync(cacheDir, { recursive: true });
   const staging = fs.mkdtempSync(path.join(cacheDir, '.fetch-'));
   try {
-    const file = path.join(staging, archive.asset);
-    const url = `https://github.com/mstorsjo/llvm-mingw/releases/download/${pin.version}/${archive.asset}`;
-    console.log(`Fetching pinned llvm-mingw: ${url}`);
+    const file = path.join(staging, asset);
+    console.log(`Fetching pinned ${what}: ${url}`);
     execFileSync('curl', ['--fail', '--location', '--silent', '--show-error', '--retry', '3', '--output', file, url], { stdio: 'inherit' });
-    const sha256 = hash(file);
-    if (sha256 !== archive.sha256) throw new Error(`${archive.asset} has SHA-256 ${sha256}, not the pinned ${archive.sha256}`);
+    const actual = hash(file);
+    if (actual !== sha256) throw new Error(`${asset} has SHA-256 ${actual}, not the pinned ${sha256}`);
+    const unpacked = path.join(staging, top ?? 'unpacked');
+    if (!top) fs.mkdirSync(unpacked);
     // Windows' own bsdtar reads zip; the GNU tar Git Bash puts ahead of it on PATH does not.
     const tar = process.platform === 'win32' ? path.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'tar.exe') : 'tar';
-    execFileSync(tar, ['-xf', file, '-C', staging], { stdio: 'inherit' });
-    fs.writeFileSync(path.join(staging, name, '.sha256'), `${archive.sha256}\n`);
-    fs.renameSync(path.join(staging, name), home);
+    execFileSync(tar, ['-xf', file, '-C', top ? staging : unpacked], { stdio: 'inherit' });
+    prepare?.(unpacked);
+    fs.writeFileSync(path.join(unpacked, '.sha256'), `${sha256}\n`);
+    fs.renameSync(unpacked, home);
   } finally {
     fs.rmSync(staging, { recursive: true, force: true });
   }
-  return cc;
+  return home;
+}
+// mingwHome returns the pinned llvm-mingw for a builder host, fetched into studio-build/toolchains.
+function mingwHome(host) {
+  const pin = toolchains.llvmMingw;
+  const archive = pin.hosts[host];
+  if (!archive) throw new Error(`No pinned llvm-mingw for ${host}: set STUDIO_MINGW_CC to llvm-mingw ${pin.version}'s x86_64-w64-mingw32-clang`);
+  const name = archive.asset.replace(/\.(tar\.xz|zip)$/, '');
+  return fetchPinned('llvm-mingw', `https://github.com/mstorsjo/llvm-mingw/releases/download/${pin.version}/${archive.asset}`,
+    archive, name, name);
+}
+// llvmMingw returns the pinned llvm-mingw's x86_64 C and C++ compilers, unless STUDIO_MINGW_CC names
+// a C compiler, whose C++ one is next to it. libs is where Windows' libraries are linked from first:
+// llvm-mingw's Linux and Windows archives have the same ones, byte for byte, but its macOS archive's
+// are built apart, and the C++ runtime among them puts its own build paths in the executable. So a
+// macOS builder links the Linux archive's, and makes the same executable as the others. Every host
+// names its folder all the same: cgo writes a line for each linker flag into the Go it generates,
+// so one flag more moves the line numbers the executable keeps.
+function llvmMingw() {
+  const exe = process.platform === 'win32' ? '.exe' : '';
+  const cxxOf = cc => cc.replace(/clang(\.exe)?$/i, 'clang++$1');
+  const libsOf = home => path.join(home, 'x86_64-w64-mingw32', 'lib');
+  const macOS = process.platform === 'darwin';
+  if (process.env.STUDIO_MINGW_CC) {
+    const cc = process.env.STUDIO_MINGW_CC;
+    return { cc, cxx: cxxOf(cc), libs: libsOf(macOS ? mingwHome('linux-x64') : path.resolve(cc, '..', '..')) };
+  }
+  const home = mingwHome(macOS ? 'darwin' : `${process.platform}-${process.arch}`);
+  const cc = path.join(home, 'bin', `x86_64-w64-mingw32-clang${exe}`);
+  return { cc, cxx: cxxOf(cc), libs: libsOf(macOS ? mingwHome('linux-x64') : home) };
+}
+// The Linux (musl) SpiderMonkey libraries keep mozglue's interposers for the environment's functions.
+// But for getenv, each calls the C library's own, found with dlsym(RTLD_NEXT), and a static executable
+// has none to find: setenv and the rest crash on purpose (MOZ_CRASH), as Go's os.Setenv does through
+// cgo. Without them, musl's own are linked; dynamic builds, which upstream tests, find those anyway.
+const ENV_INTERPOSERS = 'Unified_cpp_mozglue_interposers0.o';
+function dropEnvInterposers(dir) {
+  const archive = path.join(dir, 'lib', 'libjs_static.a');
+  const members = execFileSync(zig, ['ar', 't', archive], { encoding: 'utf8' }).split('\n');
+  if (!members.includes(ENV_INTERPOSERS)) {
+    throw new Error(`${archive} has no ${ENV_INTERPOSERS}: check how this SpiderMonkey reaches the environment`);
+  }
+  execFileSync(zig, ['ar', '--format=gnu', 'd', archive, ENV_INTERPOSERS], { stdio: 'inherit' });
+}
+// spidermonkey returns the folder with a target's pinned SpiderMonkey headers (include) and static
+// libraries (lib), the ones upstream builds its own releases with.
+function spidermonkey(key) {
+  const pin = toolchains.spidermonkey;
+  const archive = pin.targets[key];
+  if (!archive) throw new Error(`No pinned SpiderMonkey for ${key}`);
+  const linux = platforms[key][0] === 'linux';
+  return fetchPinned('SpiderMonkey', `https://github.com/${pin.repository}/releases/download/${pin.release}/${archive.asset}`,
+    archive, archive.asset.replace(/\.tar\.gz$/, linux ? '-without-env-interposers' : ''), null, linux ? dropEnvInterposers : null);
 }
 function xcode() {
   try {
@@ -92,11 +141,17 @@ function xcode() {
     return null; // Command-line tools alone have no xcodebuild.
   }
 }
-// cToolchain returns the C settings for a target and what they were made with. Only the targets
-// being built and pinned must use the pinned toolchain; the host's is also used for upstream tests.
+// cToolchain returns the C and C++ settings for a target and what they were made with. Only the
+// targets being built and pinned must use the pinned toolchain; the host's is also used for upstream
+// tests. SpiderMonkey's headers and libraries are found through CGO_CXXFLAGS and CGO_LDFLAGS, as
+// upstream's own build finds them (.github/actions/spidermonkey); its mozjs package names the libraries.
 function cToolchain(key, { pin = false } = {}) {
   const check = pin ? pinned : () => {};
   const [goos, goarch] = platforms[key];
+  const mozjs = spidermonkey(key);
+  // Quoted whole, as cgo splits these flags, so a folder with spaces stays one argument.
+  const include = `"-I${path.join(mozjs, 'include')}"`;
+  const lib = `"-L${path.join(mozjs, 'lib')}"`;
   if (goos === 'darwin') {
     if (process.platform !== 'darwin') throw new Error('Build macOS archives on macOS with Xcode');
     const expected = `${toolchains.xcode.version} (${toolchains.xcode.build})`;
@@ -105,24 +160,27 @@ function cToolchain(key, { pin = false } = {}) {
       `Select it with DEVELOPER_DIR=/Applications/Xcode_${toolchains.xcode.version}.app/Contents/Developer, or let CI make macOS pins (docs/studio-release.md).`);
     const compiler = { xcode: actual, sdk: execFileSync('xcrun', ['--show-sdk-version'], { encoding: 'utf8' }).trim(),
       clang: execFileSync('clang', ['--version'], { encoding: 'utf8' }).split('\n')[0] };
-    return { compiler, env: { CC: 'clang', MACOSX_DEPLOYMENT_TARGET: '13.0',
-      CGO_CFLAGS: '-O2 -g -mmacosx-version-min=13.0', CGO_LDFLAGS: '-O2 -g -mmacosx-version-min=13.0' } };
+    const flags = '-O2 -g -mmacosx-version-min=13.0';
+    return { compiler, env: { CC: 'clang', CXX: 'clang++', MACOSX_DEPLOYMENT_TARGET: '13.0',
+      CGO_CFLAGS: flags, CGO_CXXFLAGS: `${flags} ${include}`, CGO_LDFLAGS: `${flags} ${lib}` } };
   }
   if (goos === 'windows') {
-    const cc = llvmMingw();
+    const { cc, cxx, libs } = llvmMingw();
     const clang = execFileSync(cc, ['--version'], { encoding: 'utf8' }).split('\n')[0];
     const target = execFileSync(cc, ['-dumpmachine'], { encoding: 'utf8' }).trim();
     if (target !== 'x86_64-w64-windows-gnu') throw new Error(`Windows needs llvm-mingw's x86_64 clang, ${cc} targets ${target}`);
     check('Windows C compiler', clang, toolchains.llvmMingw.clang,
       `Unset STUDIO_MINGW_CC to use the pinned llvm-mingw ${toolchains.llvmMingw.version}.`);
     return { compiler: { llvmMingw: toolchains.llvmMingw.version, clang },
-      env: { CC: `"${cc}"`, CGO_CFLAGS: '-O2 -g', CGO_LDFLAGS: '-O2 -g' } };
+      env: { CC: `"${cc}"`, CXX: `"${cxx}"`, CGO_CFLAGS: '-O2 -g', CGO_CXXFLAGS: `-O2 -g ${include}`,
+        CGO_LDFLAGS: `-O2 -g "-L${libs}" ${lib}` } };
   }
   const version = execFileSync(zig, ['version'], { encoding: 'utf8' }).trim();
   check('Zig', version, toolchains.zig, 'Install it, or point STUDIO_ZIG at it.');
   const triple = `${goarch === 'amd64' ? 'x86_64' : 'aarch64'}-linux-musl`;
   return { compiler: { zig: version, target: triple },
-    env: { CC: `"${zig}" cc -target ${triple}`, CGO_CFLAGS: '-O2 -g', CGO_LDFLAGS: '-O2 -g' } };
+    env: { CC: `"${zig}" cc -target ${triple}`, CXX: `"${zig}" c++ -target ${triple}`,
+      CGO_CFLAGS: '-O2 -g', CGO_CXXFLAGS: `-O2 -g ${include}`, CGO_LDFLAGS: `-O2 -g ${lib}` } };
 }
 const go = (argv, extra = {}) => execFileSync('go', argv, { cwd: source, env: { ...env, ...extra }, stdio: 'inherit' });
 const npm = argv => execFileSync(process.platform === 'win32' ? 'npm.cmd' : 'npm', argv,