Latest grok2api code, keep old deps (fast build)

README.md

@@ -1,64 +1,609 @@
----
-title: Grok2API
-emoji: 🤖
-colorFrom: blue
-colorTo: red
-sdk: docker
-app_port: 7860
-pinned: false
-description: Grok2API - A FastAPI-based Grok gateway that converts Grok web capabilities to OpenAI-compatible API.
----
+<img alt="Grok2API" src="https://github.com/user-attachments/assets/037a0a6e-7986-41cc-b4af-04df612ee886" />
 
-# Grok2API on Hugging Face Spaces
+[![Python](https://img.shields.io/badge/python-3.13%2B-3776AB?logo=python&logoColor=white)](https://www.python.org/)
+[![FastAPI](https://img.shields.io/badge/FastAPI-0.119%2B-009688?logo=fastapi&logoColor=white)](https://fastapi.tiangolo.com/)
+[![Version](https://img.shields.io/badge/version-2.0.4.rc2-111827)](pyproject.toml)
+[![License](https://img.shields.io/badge/license-MIT-16a34a)](LICENSE)
+[![English](https://img.shields.io/badge/English-2563EB?logo=bookstack&logoColor=white)](docs/README.en.md)
+[![DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/chenyme/grok2api)
+[![项目文档](https://img.shields.io/badge/项目文档-0F766E?logo=readthedocs&logoColor=white)](https://blog.cheny.me/blog/posts/grok2api)
 
-A FastAPI-based Grok gateway that converts Grok web capabilities to OpenAI-compatible API.
 
-This space runs Grok2API with persistent storage using a Hugging Face Dataset for data persistence.
+> [!NOTE]
+> 本项目仅供学习与研究交流。请务必遵循 Grok 的使用条款及当地法律法规，不得用于非法用途！二开与 PR 请保留原作者与前端标识。
 
-## Features
+<br>
 
-- OpenAI compatible endpoints: `/v1/models`, `/v1/chat/completions`, `/v1/responses`, `/v1/messages`
-- Anthropic compatible endpoints: `/v1/messages`
-- Image generation, editing, and video generation capabilities
-- Admin dashboard and web UI
-- Multi-account pool with automatic maintenance
-- Persistent storage via HF Dataset mount
+Grok2API 是一个基于 **FastAPI** 构建的 Grok 网关，支持将 Grok Web 能力以 OpenAI 兼容 API 的方式转换。核心特性：
+- OpenAI 兼容接口：`/v1/models`、`/v1/chat/completions`、`/v1/responses`、`/v1/images/generations`、`/v1/images/edits`、`/v1/videos`、`/v1/videos/{video_id}`、`/v1/videos/{video_id}/content`
+- Anthropic 兼容接口：`/v1/messages`
+- 支持流式与非流式对话、显式思考输出、函数工具结构透传，以及统一的 token / usage 统计
+- 支持多账号池、层级选号、失败反馈、额度同步与自动维护
+- 支持本地缓存图片、视频与本地代理链接返回
+- 支持文生图、图像编辑、文生视频、图生视频
+- 内置 Admin 后台管理、Web Chat、Masonry 生图、ChatKit 语音页面
 
-## Configuration
+<br>
 
-The service uses:
-- Server port: 7860 (HF Spaces default)
-- Data directory: `/data` (mounted from HF Dataset)
-- Logs directory: `/data/logs`
+## 服务架构
 
-## Usage
+```mermaid
+flowchart LR
+    Client["Clients\nOpenAI SDK / curl / Browser"] --> API["FastAPI App"]
 
-Once the space is running, you can access the API at:
-- Base URL: `https://your-username-grok2api-hf-clean.hf.space`
-- API endpoints: `https://your-username-grok2api-hf-clean.hf.space/v1/*`
+    subgraph Products["Products"]
+        direction TB
+        OpenAI["OpenAI APIs\n/v1/*"]
+        Anthropic["Anthropic APIs\n/v1/messages"]
+        Web["Web Products\n/admin /webui/*"]
+    end
 
-Authentication:
-- Set `app.api_key` in the runtime config (`/data/config.toml`) for API key protection
-- Admin interface: `/admin/login` (default key: `grok2api`)
-- Web UI: `/webui/login` (if enabled)
+    subgraph Control["Control"]
+        direction TB
+        Models["Model Registry"]
+        Accounts["Account Services"]
+        Proxies["Proxy Services"]
+    end
 
-## Persistent Storage
+    subgraph Dataplane["Dataplane"]
+        direction TB
+        Reverse["Reverse Protocol + Transport"]
+        AccountDP["AccountDirectory"]
+        ProxyDP["Proxy Runtime"]
+    end
 
-This space uses a Hugging Face Dataset (`hermesinho/grok2api-data`) mounted at `/data` to persist:
-- Account information (SQLite database)
-- Configuration files
-- Cached media files
-- Logs
+    subgraph Platform["Platform"]
+        direction TB
+        Tokens["Token Estimation"]
+        Storage["Storage"]
+        Config["Config Snapshot"]
+        Auth["Auth"]
+        Log["Logging"]
+    end
 
-## Environment Variables
+    API --> OpenAI
+    API --> Anthropic
+    API --> Web
 
-Override default settings by editing `/data/config.toml` or setting environment variables:
+    OpenAI --> Models
+    OpenAI --> AccountDP
+    OpenAI --> ProxyDP
+    OpenAI --> Reverse
+    OpenAI --> Tokens
+    OpenAI --> Storage
 
-- `GROK_APP_API_KEY` - API key for `/v1/*` endpoints
-- `GROK_APP_APP_KEY` - Key for `/admin/*` endpoints (default: grok2api)
-- `GROK_LOG_LEVEL` - Logging level (default: INFO)
+    Anthropic --> Models
+    Anthropic --> AccountDP
+    Anthropic --> ProxyDP
+    Anthropic --> Reverse
+    Anthropic --> Tokens
 
-For more configuration options, see the [original documentation](https://github.com/chenyme/grok2api).
+    Web --> Accounts
+    Web --> Config
+    Web --> Auth
 
----Last updated: 2026-04-26T16:53:11Z
-# Test
+    Accounts --> AccountDP
+    Proxies --> ProxyDP
+    Models --> Reverse
+```
+
+<br>
+
+## 快速开始
+
+### 本地部署
+
+```bash
+git clone https://github.com/chenyme/grok2api
+cd grok2api
+cp .env.example .env
+uv sync
+uv run granian --interface asgi --host 0.0.0.0 --port 8000 --workers 1 app.main:app
+```
+
+### Docker Compose
+
+```bash
+git clone https://github.com/chenyme/grok2api
+cd grok2api
+cp .env.example .env
+docker compose up -d
+```
+
+### Vercel
+
+[![Deploy with Vercel](https://vercel.com/button)](https://vercel.com/new/clone?repository-url=https://github.com/chenyme/grok2api&env=LOG_LEVEL,LOG_FILE_ENABLED,DATA_DIR,LOG_DIR,ACCOUNT_STORAGE,ACCOUNT_REDIS_URL,ACCOUNT_MYSQL_URL,ACCOUNT_POSTGRESQL_URL)
+
+### Render
+
+[![Deploy to Render](https://render.com/images/deploy-to-render-button.svg)](https://render.com/deploy?repo=https://github.com/chenyme/grok2api)
+
+### 首次启动
+
+1. 修改 `app.app_key`
+2. 设置 `app.api_key`
+3. 设置 `app.app_url`（否则图片、视频的链接会 403 无权访问）
+
+<br>
+
+## WebUI
+
+### 页面入口
+
+| 页面 | 路径 |
+| :-- | :-- |
+| Admin 登录页 | `/admin/login` |
+| 账号管理 | `/admin/account` |
+| 配置管理 | `/admin/config` |
+| 缓存管理 | `/admin/cache` |
+| WebUI 登录页 | `/webui/login` |
+| Web Chat | `/webui/chat` |
+| Masonry | `/webui/masonry` |
+| ChatKit | `/webui/chatkit` |
+
+### 鉴权规则
+
+| 范围 | 配置项 | 规则 |
+| :-- | :-- | :-- |
+| `/v1/*` | `app.api_key` | 为空则不额外鉴权 |
+| `/admin/*` | `app.app_key` | 默认值 `grok2api` |
+| `/webui/*` | `app.webui_enabled`, `app.webui_key` | 默认关闭；`webui_key` 为空则不额外校验 |
+
+<br>
+
+## 配置体系
+
+### 配置分层
+
+| 位置 | 用途 | 生效时机 |
+| :-- | :-- | :-- |
+| `.env` | 启动前配置 | 服务启动时 |
+| `${DATA_DIR}/config.toml` | 运行时配置 | 保存后即时生效 |
+| `config.defaults.toml` | 默认模板 | 首次初始化时 |
+
+
+
+### 环境变量
+
+| 变量名 | 说明 | 默认值 |
+| :-- | :-- | :-- |
+| `TZ` | 时区 | `Asia/Shanghai` |
+| `LOG_LEVEL` | 日志级别 | `INFO` |
+| `LOG_FILE_ENABLED` | 写入本地文件日志 | `true` |
+| `ACCOUNT_SYNC_INTERVAL` | 账号目录增量同步间隔（秒） | `30` |
+| `ACCOUNT_SYNC_ACTIVE_INTERVAL` | 账号目录检测到变化后的活跃同步间隔（秒） | `3` |
+| `SERVER_HOST` | 服务监听地址 | `0.0.0.0` |
+| `SERVER_PORT` | 服务监听端口 | `8000` |
+| `SERVER_WORKERS` | Granian worker 数量 | `1` |
+| `HOST_PORT` | Docker Compose 宿主机映射端口 | `8000` |
+| `DATA_DIR` | 本地数据根目录（账号库、本地媒体文件、缓存索引统一位于此目录下） | `./data` |
+| `LOG_DIR` | 本地日志目录 | `./logs` |
+| `ACCOUNT_STORAGE` | 账号存储后端 | `local` |
+| `ACCOUNT_LOCAL_PATH` | `local` 模式账号 SQLite 路径 | `${DATA_DIR}/accounts.db` |
+| `ACCOUNT_REDIS_URL` | `redis` 模式 Redis DSN | `""` |
+| `ACCOUNT_MYSQL_URL` | `mysql` 模式 SQLAlchemy DSN | `""` |
+| `ACCOUNT_POSTGRESQL_URL` | `postgresql` 模式 SQLAlchemy DSN | `""` |
+| `ACCOUNT_SQL_POOL_SIZE` | SQL 连接池核心连接数 | `5` |
+| `ACCOUNT_SQL_MAX_OVERFLOW` | SQL 连接池最大溢出连接数 | `10` |
+| `ACCOUNT_SQL_POOL_TIMEOUT` | 等待连接池空闲连接的超时时间（秒） | `30` |
+| `ACCOUNT_SQL_POOL_RECYCLE` | 连接最大复用时间（秒），超时后自动重连 | `1800` |
+| `CONFIG_LOCAL_PATH` | `local` 模式运行时配置文件路径 | `${DATA_DIR}/config.toml` |
+
+运行时配置也支持 `GROK_` 前缀环境变量覆盖，例如 `GROK_APP_API_KEY` 会覆盖 `app.api_key`，`GROK_FEATURES_STREAM` 会覆盖 `features.stream`。
+
+### 系统配置项
+
+| 分组 | 关键项 |
+| :-- | :-- |
+| `app` | `app_key`, `app_url`, `api_key`, `webui_enabled`, `webui_key` |
+| `logging` | `file_level`, `max_files` |
+| `features` | `temporary`, `memory`, `stream`, `thinking`, `auto_chat_mode_fallback`, `thinking_summary`, `dynamic_statsig`, `enable_nsfw`, `show_search_sources`, `custom_instruction`, `image_format`, `imagine_public_image_proxy`, `video_format` |
+| `proxy.egress` | `mode`, `proxy_url`, `proxy_pool`, `resource_proxy_url`, `resource_proxy_pool`, `skip_ssl_verify` |
+| `proxy.clearance` | `mode`, `cf_cookies`, `user_agent`, `browser`, `flaresolverr_url`, `timeout_sec`, `refresh_interval` |
+| `retry` | `reset_session_status_codes`, `max_retries`, `on_codes` |
+| `account.refresh` | `basic_interval_sec`, `super_interval_sec`, `heavy_interval_sec`, `usage_concurrency`, `on_demand_min_interval_sec` |
+| `cache.local` | `image_max_mb`, `video_max_mb` |
+| `chat` | `timeout` |
+| `image` | `timeout`, `stream_timeout` |
+| `video` | `timeout` |
+| `voice` | `timeout` |
+| `asset` | `upload_timeout`, `download_timeout`, `list_timeout`, `delete_timeout` |
+| `nsfw` | `timeout` |
+| `batch` | `nsfw_concurrency`, `refresh_concurrency`, `asset_upload_concurrency`, `asset_list_concurrency`, `asset_delete_concurrency` |
+
+### 图片、视频格式
+
+| 配置项 | 可选值 |
+| :-- | :-- |
+| `features.image_format` | `grok_url`, `local_url`, `grok_md`, `local_md`, `base64` |
+| `features.imagine_public_image_proxy` | `true`, `false` |
+| `features.video_format` | `grok_url`, `local_url`, `grok_html`, `local_html` |
+
+<br>
+
+## 模型支持
+> 可通过 `GET /v1/models` 获取当前支持模型列表。
+
+### Chat
+
+| 模型名 | mode | tier |
+| :-- | :-- | :-- |
+| `grok-4.20-0309-non-reasoning` | `fast` | `basic` |
+| `grok-4.20-0309` | `auto` | `super` |
+| `grok-4.20-0309-reasoning` | `expert` | `super` |
+| `grok-4.20-0309-non-reasoning-super` | `fast` | `super` |
+| `grok-4.20-0309-super` | `auto` | `super` |
+| `grok-4.20-0309-reasoning-super` | `expert` | `super` |
+| `grok-4.20-0309-non-reasoning-heavy` | `fast` | `heavy` |
+| `grok-4.20-0309-heavy` | `auto` | `heavy` |
+| `grok-4.20-0309-reasoning-heavy` | `expert` | `heavy` |
+| `grok-4.20-multi-agent-0309` | `heavy` | `heavy` |
+| `grok-4.20-fast` | `fast` | `basic`，优先使用高等级账号池 |
+| `grok-4.20-auto` | `auto` | `super`，优先使用高等级账号池 |
+| `grok-4.20-expert` | `expert` | `super`，优先使用高等级账号池 |
+| `grok-4.20-heavy` | `heavy` | `heavy` |
+| `grok-4.3-beta` | `grok-420-computer-use-sa` | `super` |
+
+### Image
+
+| 模型名 | mode | tier |
+| :-- | :-- | :-- |
+| `grok-imagine-image-lite` | `fast` | `basic` |
+| `grok-imagine-image` | `auto` | `super` |
+| `grok-imagine-image-pro` | `auto` | `super` |
+
+### Image Edit
+
+| 模型名 | mode | tier |
+| :-- | :-- | :-- |
+| `grok-imagine-image-edit` | `auto` | `super` |
+
+### Video
+
+| 模型名 | mode | tier |
+| :-- | :-- | :-- |
+| `grok-imagine-video` | `auto` | `super` |
+
+<br>
+
+## API 一览
+
+| 接口 | 是否鉴权 | 说明 |
+| :-- | :-- | :-- |
+| `GET /v1/models` | 是 | 列出当前启用模型 |
+| `GET /v1/models/{model_id}` | 是 | 获取单个模型信息 |
+| `POST /v1/chat/completions` | 是 | 对话 / 图像 / 视频统一入口 |
+| `POST /v1/responses` | 是 | OpenAI Responses API 兼容子集 |
+| `POST /v1/messages` | 是 | Anthropic Messages API 兼容接口 |
+| `POST /v1/images/generations` | 是 | 独立图像生成接口 |
+| `POST /v1/images/edits` | 是 | 独立图像编辑接口 |
+| `POST /v1/videos` | 是 | 异步视频任务创建 |
+| `GET /v1/videos/{video_id}` | 是 | 查询视频任务 |
+| `GET /v1/videos/{video_id}/content` | 是 | 获取最终视频文件 |
+| `GET /v1/files/video?id=...` | 否 | 获取本地缓存视频 |
+| `GET /v1/files/image?id=...` | 否 | 获取本地缓存图片 |
+
+<br>
+
+## 接口示例
+
+> 以下示例默认使用 `http://localhost:8000` 地址。
+
+<details>
+<summary><code>GET /v1/models</code></summary>
+<br>
+
+```bash
+curl http://localhost:8000/v1/models \
+  -H "Authorization: Bearer $GROK2API_API_KEY"
+```
+
+<details>
+<summary>字段说明</summary>
+<br>
+
+| 字段 | 位置 | 说明 |
+| :-- | :-- | :-- |
+| `Authorization` | Header | 当 `app.api_key` 非空时必填，格式为 `Bearer <api_key>` |
+
+<br>
+</details>
+
+<br>
+</details>
+
+<details>
+<summary><code>POST /v1/chat/completions</code></summary>
+<br>
+
+对话：
+
+```bash
+curl http://localhost:8000/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $GROK2API_API_KEY" \
+  -d '{
+    "model": "grok-4.20-auto",
+    "stream": true,
+    "reasoning_effort": "high",
+    "messages": [
+      {"role":"user","content":"你好"}
+    ]
+  }'
+```
+
+图像：
+
+```bash
+curl http://localhost:8000/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $GROK2API_API_KEY" \
+  -d '{
+    "model": "grok-imagine-image",
+    "stream": true,
+    "messages": [
+      {"role":"user","content":"一只在太空漂浮的猫"}
+    ],
+    "image_config": {
+      "n": 2,
+      "size": "1024x1024",
+      "response_format": "url"
+    }
+  }'
+```
+
+视频：
+
+```bash
+curl http://localhost:8000/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $GROK2API_API_KEY" \
+  -d '{
+    "model": "grok-imagine-video",
+    "stream": true,
+    "messages": [
+      {"role":"user","content":"霓虹雨夜街头，电影感慢镜头追拍"}
+    ],
+    "video_config": {
+      "seconds": 10,
+      "size": "1792x1024",
+      "resolution_name": "720p",
+      "preset": "normal"
+    }
+  }'
+```
+
+<details>
+<summary>字段说明</summary>
+<br>
+
+| 字段 | 说明 |
+| :-- | :-- |
+| `messages` | 支持文本与多模态内容块 |
+| `stream` | 是否流式输出；不传时使用 `features.stream` 默认值 |
+| `reasoning_effort` | `none`, `minimal`, `low`, `medium`, `high`, `xhigh`；`none` 会关闭思考输出 |
+| `temperature` / `top_p` | 采样参数，默认 `0.8` / `0.95` |
+| `tools` | OpenAI function tools 结构 |
+| `tool_choice` | `auto`, `required` 或指定函数工具 |
+| `image_config` | 图像模型参数 |
+| \|_ `n` | `lite` 为 `1-4`，其他图���模型为 `1-10`，编辑模型为 `1-2` |
+| \|_ `size` | `1280x720`, `720x1280`, `1792x1024`, `1024x1792`, `1024x1024` |
+| \|_ `response_format` | `url`, `b64_json` |
+| `video_config` | 视频模型参数 |
+| \|_ `seconds` | `6`, `10`, `12`, `16`, `20` |
+| \|_ `size` | `720x1280`, `1280x720`, `1024x1024`, `1024x1792`, `1792x1024` |
+| \|_ `resolution_name` | `480p`, `720p` |
+| \|_ `preset` | `fun`, `normal`, `spicy`, `custom` |
+
+<br>
+</details>
+
+<br>
+</details>
+
+<details>
+<summary><code>POST /v1/responses</code></summary>
+<br>
+
+```bash
+curl http://localhost:8000/v1/responses \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $GROK2API_API_KEY" \
+  -d '{
+    "model": "grok-4.20-auto",
+    "input": "解释一下量子隧穿",
+    "instructions": "用简洁的中文回答",
+    "stream": true,
+    "reasoning": {
+      "effort": "high"
+    }
+  }'
+```
+
+<details>
+<summary>字段说明</summary>
+<br>
+
+| 字段 | 说明 |
+| :-- | :-- |
+| `model` | 模型 ID，需为已启用模型 |
+| `input` | 用户输入；支持字符串或 Responses API 风格的消息数组 |
+| `instructions` | 可选系统指令，会作为 system 消息注入 |
+| `stream` | 是否流式输出；不传时使用 `features.stream` 默认值 |
+| `reasoning` | 可选思考配置 |
+| \|_ `effort` | `none` 会关闭思考输出；其他值会开启思考输出 |
+| `temperature` / `top_p` | 采样参数，默认 `0.8` / `0.95` |
+| `tools` / `tool_choice` | 支持函数工具；Responses API 的扁平工具格式会自动转换 |
+
+<br>
+</details>
+
+<br>
+</details>
+
+<details>
+<summary><code>POST /v1/messages</code></summary>
+<br>
+
+```bash
+curl http://localhost:8000/v1/messages \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $GROK2API_API_KEY" \
+  -d '{
+    "model": "grok-4.20-auto",
+    "stream": true,
+    "thinking": {
+      "type": "enabled",
+      "budget_tokens": 1024
+    },
+    "messages": [
+      {
+        "role": "user",
+        "content": "用三句话解释量子隧穿"
+      }
+    ]
+  }'
+```
+
+<details>
+<summary>字段说明</summary>
+<br>
+
+| 字段 | 说明 |
+| :-- | :-- |
+| `model` | 模型 ID，需为已启用模型 |
+| `messages` | Anthropic Messages 格式消息，支持文本、图片、文档和工具结果块 |
+| `system` | 可选系统提示词，支持字符串或文本块数组 |
+| `stream` | 是否流式输出；不传时使用 `features.stream` 默认值 |
+| `thinking` | 可选思考配置 |
+| \|_ `type` | `disabled` 会关闭思考输出；其他配置会开启思考输出 |
+| `max_tokens` | 接收但当前会忽略，Grok 上游不暴露该参数 |
+| `tools` / `tool_choice` | 支持 Anthropic 工具格式，会转换为内部 function tools |
+
+<br>
+</details>
+
+<br>
+</details>
+
+<details>
+<summary><code>POST /v1/images/generations</code></summary>
+<br>
+
+```bash
+curl http://localhost:8000/v1/images/generations \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $GROK2API_API_KEY" \
+  -d '{
+    "model": "grok-imagine-image",
+    "prompt": "一只在太空漂浮的猫",
+    "n": 1,
+    "size": "1792x1024",
+    "response_format": "url"
+  }'
+```
+
+<details>
+<summary>字段说明</summary>
+<br>
+
+| 字段 | 说明 |
+| :-- | :-- |
+| `model` | 图像模型：`grok-imagine-image-lite`, `grok-imagine-image`, `grok-imagine-image-pro` |
+| `prompt` | 图片生成提示词 |
+| `n` | 生成数量；`lite` 为 `1-4`，其他图像模型为 `1-10` |
+| `size` | 支持 `1280x720`, `720x1280`, `1792x1024`, `1024x1792`, `1024x1024` |
+| `response_format` | `url` 或 `b64_json` |
+
+<br>
+</details>
+
+<br>
+</details>
+
+<details>
+<summary><code>POST /v1/images/edits</code></summary>
+<br>
+
+```bash
+curl http://localhost:8000/v1/images/edits \
+  -H "Authorization: Bearer $GROK2API_API_KEY" \
+  -F "model=grok-imagine-image-edit" \
+  -F "prompt=把这张图变清晰一些" \
+  -F "image[]=@/path/to/image.png" \
+  -F "n=1" \
+  -F "size=1024x1024" \
+  -F "response_format=url"
+```
+
+<details>
+<summary>字段说明</summary>
+<br>
+
+| 字段 | 说明 |
+| :-- | :-- |
+| `model` | 图像编辑模型，目前为 `grok-imagine-image-edit` |
+| `prompt` | 编辑指令 |
+| `image[]` | 参考图片，multipart 文件字段；最多使用 5 张 |
+| `n` | 生成数量，范围 `1-2` |
+| `size` | 当前仅支持 `1024x1024` |
+| `response_format` | `url` 或 `b64_json` |
+| `mask` | 暂不支持；传入会返回校验错误 |
+
+<br>
+</details>
+
+<br>
+</details>
+
+<details>
+<summary><code>POST /v1/videos</code></summary>
+<br>
+
+```bash
+curl http://localhost:8000/v1/videos \
+  -H "Authorization: Bearer $GROK2API_API_KEY" \
+  -F "model=grok-imagine-video" \
+  -F "prompt=霓虹雨夜街头，电影感慢镜头追拍" \
+  -F "seconds=10" \
+  -F "size=1792x1024" \
+  -F "resolution_name=720p" \
+  -F "preset=normal" \
+  -F "input_reference[]=@/path/to/reference.png"
+```
+
+```bash
+curl http://localhost:8000/v1/videos/<video_id> \
+  -H "Authorization: Bearer $GROK2API_API_KEY"
+
+curl -L http://localhost:8000/v1/videos/<video_id>/content \
+  -H "Authorization: Bearer $GROK2API_API_KEY" \
+  -o result.mp4
+```
+
+<details>
+<summary>字段说明</summary>
+<br>
+
+| 字段 | 说明 |
+| :-- | :-- |
+| `model` | 视频模型，目前为 `grok-imagine-video` |
+| `prompt` | 视频生成提示词 |
+| `seconds` | 视频长度：`6`, `10`, `12`, `16`, `20` |
+| `size` | 支持 `720x1280`, `1280x720`, `1024x1024`, `1024x1792`, `1792x1024` |
+| `resolution_name` | `480p` 或 `720p` |
+| `preset` | `fun`, `normal`, `spicy`, `custom` |
+| `input_reference[]` | 可选图生视频参考图，multipart 文件字段；最多使用前 7 张 |
+| `video_id` | `POST /v1/videos` 返回的视频任务 ID，用于查询任务或下载成片 |
+
+<br>
+</details>
+
+<br>
+</details>
+
+<br>
+
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=Chenyme/grok2api&type=Timeline)](https://star-history.com/#Chenyme/grok2api&Timeline)

app/control/account/quota_defaults.py

@@ -3,12 +3,12 @@
 Canonical quota totals per pool type (from upstream rate-limits API):
 
               auto    fast    expert    heavy    grok_4_3
-  basic         20      60       8        —         —        window: 72000 / 36000 s
+  basic          —      30       —        —         —        window: 86400 s
   super         50     140      50        —        50        window: 7200 s
   heavy        150     400     150       20       150        window: 7200 s
 
-Pool inference uses ``auto.total`` as the primary signal — the three values
-(20 / 50 / 150) are mutually exclusive across pool types.
+Pool inference uses ``auto.total`` as the primary signal for super/heavy
+accounts; basic accounts no longer expose auto/expert windows locally.
 """
 
 from typing import TYPE_CHECKING
@@ -40,10 +40,13 @@ def _w(remaining: int, total: int, window_seconds: int) -> QuotaWindow:
 # Per-pool default quota sets
 # ---------------------------------------------------------------------------
 
+BASIC_FAST_LIMIT = 30
+BASIC_FAST_WINDOW_SECONDS = 86_400
+
 BASIC_QUOTA_DEFAULTS = AccountQuotaSet(
-    auto=_w(20, 20, 72_000),  # 20  queries / 20 h
-    fast=_w(60, 60, 72_000),  # 60  queries / 20 h
-    expert=_w(8, 8, 36_000),  # 8   queries / 10 h
+    auto=_w(0, 0, 0),  # unsupported on basic accounts
+    fast=_w(BASIC_FAST_LIMIT, BASIC_FAST_LIMIT, BASIC_FAST_WINDOW_SECONDS),
+    expert=_w(0, 0, 0),  # unsupported on basic accounts
 )
 
 SUPER_QUOTA_DEFAULTS = AccountQuotaSet(
@@ -69,7 +72,7 @@ _POOL_DEFAULTS: dict[str, AccountQuotaSet] = {
 }
 
 _SUPPORTED_MODE_IDS_BY_POOL: dict[str, frozenset[int]] = {
-    "basic": frozenset((0, 1, 2)),
+    "basic": frozenset((1,)),
     "super": frozenset((0, 1, 2, 4)),
     "heavy": frozenset((0, 1, 2, 3, 4)),
 }
@@ -124,6 +127,38 @@ def default_quota_window(pool: str, mode_id: int) -> QuotaWindow | None:
     return default_quota_set(pool).get(mode_id)
 
 
+def normalize_quota_window(
+    pool: str, mode_id: int, window: QuotaWindow | None
+) -> QuotaWindow | None:
+    """Apply product-level quota policy for one pool/mode window."""
+    if window is None or not supports_mode(pool, mode_id):
+        return None
+    if pool == "basic" and mode_id == 1:
+        return QuotaWindow(
+            remaining=max(0, min(int(window.remaining), BASIC_FAST_LIMIT)),
+            total=BASIC_FAST_LIMIT,
+            window_seconds=BASIC_FAST_WINDOW_SECONDS,
+            reset_at=window.reset_at,
+            synced_at=window.synced_at,
+            source=window.source,
+        )
+    return window
+
+
+def normalize_quota_set(pool: str, quota_set: AccountQuotaSet) -> AccountQuotaSet:
+    """Return a quota set normalized to the supported modes for *pool*."""
+    defaults = default_quota_set(pool)
+
+    auto = normalize_quota_window(pool, 0, quota_set.auto) or defaults.auto
+    fast = normalize_quota_window(pool, 1, quota_set.fast) or defaults.fast
+    expert = normalize_quota_window(pool, 2, quota_set.expert) or defaults.expert
+
+    qs = AccountQuotaSet(auto=auto, fast=fast, expert=expert)
+    qs.heavy = normalize_quota_window(pool, 3, quota_set.heavy)
+    qs.grok_4_3 = normalize_quota_window(pool, 4, quota_set.grok_4_3)
+    return qs
+
+
 def infer_pool(windows: dict[int, QuotaWindow]) -> str:
     """Infer pool type from live quota windows returned by the rate-limits API.
 
@@ -143,6 +178,8 @@ __all__ = [
     "default_quota_set",
     "default_quota_window",
     "infer_pool",
+    "normalize_quota_set",
+    "normalize_quota_window",
     "supported_mode_ids",
     "supports_mode",
 ]

app/control/account/refresh.py

@@ -15,6 +15,7 @@ from .models import AccountRecord, QuotaWindow
 from .quota_defaults import (
     default_quota_window,
     infer_pool,
+    normalize_quota_window,
     supported_mode_ids,
     supports_mode,
 )
@@ -78,7 +79,7 @@ class AccountRefreshService:
         """Fetch quota windows for every mode supported by *pool*.
 
         Examples:
-          - basic -> auto / fast / expert
+          - basic -> fast
           - super -> auto / fast / expert / grok_4_3
           - heavy -> auto / fast / expert / heavy / grok_4_3
         """
@@ -258,7 +259,10 @@ class AccountRefreshService:
         for mode in ALL_MODES_FULL:
             mode_id = int(mode)
             if mode_id in windows:
-                patches[_MODE_KEYS[mode_id]] = windows[mode_id].to_dict()
+                window = normalize_quota_window(record.pool, mode_id, windows[mode_id])
+                if window is None:
+                    continue
+                patches[_MODE_KEYS[mode_id]] = window.to_dict()
                 refreshed = True
             elif apply_fallback:
                 existing = qs.get(mode_id)
@@ -448,7 +452,16 @@ class AccountRefreshService:
 
         quota_patch: dict[str, dict] = {}
         if window is not None:
-            quota_patch[mode_key] = window.to_dict()
+            normalized = normalize_quota_window(record.pool, mode_id, window)
+            if normalized is None:
+                logger.debug(
+                    "account single-mode quota patch skipped: token={}... pool={} mode_id={} reason=unsupported_mode",
+                    record.token[:10],
+                    record.pool,
+                    mode_id,
+                )
+                return
+            quota_patch[mode_key] = normalized.to_dict()
         else:
             existing = qs.get(mode_id)
             if existing is not None:

app/control/account/scheduler.py

@@ -3,7 +3,7 @@
 Runs one independent loop per pool type (basic / super / heavy), each with
 its own configurable interval read from:
 
-    account.refresh.basic_interval_sec  (default 36000 — 10 h)
+    account.refresh.basic_interval_sec  (default 86400 — 24 h)
     account.refresh.super_interval_sec  (default  7200 —  2 h)
     account.refresh.heavy_interval_sec  (default  7200 —  2 h)
 """
@@ -16,7 +16,7 @@ from .refresh import AccountRefreshService
 
 # Pool → (config key, built-in default seconds)
 _POOL_CONFIG: dict[str, tuple[str, int]] = {
-    "basic": ("account.refresh.basic_interval_sec", 36_000),
+    "basic": ("account.refresh.basic_interval_sec", 86_400),
     "super": ("account.refresh.super_interval_sec",  7_200),
     "heavy": ("account.refresh.heavy_interval_sec",  7_200),
 }

app/control/model/registry.py

@@ -12,10 +12,10 @@ from .spec import ModelSpec
 MODELS: tuple[ModelSpec, ...] = (
     # === Chat ==============================================================
 
-    # Basic+
+    # Basic fast; auto/expert require Super+
     ModelSpec("grok-4.20-0309-non-reasoning",           ModeId.FAST,     Tier.BASIC, Capability.CHAT,       True, "Grok 4.20 0309 Non-Reasoning"),
-    ModelSpec("grok-4.20-0309",                         ModeId.AUTO,     Tier.BASIC, Capability.CHAT,       True, "Grok 4.20 0309"),
-    ModelSpec("grok-4.20-0309-reasoning",               ModeId.EXPERT,   Tier.BASIC, Capability.CHAT,       True, "Grok 4.20 0309 Reasoning"),
+    ModelSpec("grok-4.20-0309",                         ModeId.AUTO,     Tier.SUPER, Capability.CHAT,       True, "Grok 4.20 0309"),
+    ModelSpec("grok-4.20-0309-reasoning",               ModeId.EXPERT,   Tier.SUPER, Capability.CHAT,       True, "Grok 4.20 0309 Reasoning"),
     # Super+
     ModelSpec("grok-4.20-0309-non-reasoning-super",     ModeId.FAST,     Tier.SUPER, Capability.CHAT,       True, "Grok 4.20 0309 Non-Reasoning Super"),
     ModelSpec("grok-4.20-0309-super",                   ModeId.AUTO,     Tier.SUPER, Capability.CHAT,       True, "Grok 4.20 0309 Super"),
@@ -28,8 +28,8 @@ MODELS: tuple[ModelSpec, ...] = (
 
     # --- 硬优先级反向选池 (heavy → super → basic) ---
     ModelSpec("grok-4.20-fast",                         ModeId.FAST,     Tier.BASIC, Capability.CHAT,       True, "Grok 4.20 Fast",          prefer_best=True),
-    ModelSpec("grok-4.20-auto",                         ModeId.AUTO,     Tier.BASIC, Capability.CHAT,       True, "Grok 4.20 Auto",          prefer_best=True),
-    ModelSpec("grok-4.20-expert",                       ModeId.EXPERT,   Tier.BASIC, Capability.CHAT,       True, "Grok 4.20 Expert",        prefer_best=True),
+    ModelSpec("grok-4.20-auto",                         ModeId.AUTO,     Tier.SUPER, Capability.CHAT,       True, "Grok 4.20 Auto",          prefer_best=True),
+    ModelSpec("grok-4.20-expert",                       ModeId.EXPERT,   Tier.SUPER, Capability.CHAT,       True, "Grok 4.20 Expert",        prefer_best=True),
     ModelSpec("grok-4.20-heavy",                        ModeId.HEAVY,    Tier.HEAVY, Capability.CHAT,       True, "Grok 4.20 Heavy",         prefer_best=True),
 
     # === grok-4.3 (grok-420-computer-use-sa) ==================================
@@ -38,7 +38,7 @@ MODELS: tuple[ModelSpec, ...] = (
 
     # === Image ==============================================================
 
-    # Basic+
+    # Basic fast
     ModelSpec("grok-imagine-image-lite",                ModeId.FAST,     Tier.BASIC, Capability.IMAGE,      True, "Grok Imagine Image Lite"),
     # Super+
     ModelSpec("grok-imagine-image",                     ModeId.AUTO,     Tier.SUPER, Capability.IMAGE,      True, "Grok Imagine Image"),

app/control/model/spec.py

@@ -74,12 +74,15 @@ class ModelSpec:
           HEAVY tier  → heavy only
 
         Reversed (prefer_best=True):
-          non-HEAVY   → try heavy first, then super, then basic
+          BASIC tier  → try heavy first, then super, then basic
+          SUPER tier  → try heavy first, then super
           HEAVY tier  → heavy only
         """
         if self.prefer_best:
             if self.tier == Tier.HEAVY:
                 return (2,)  # heavy only
+            if self.tier == Tier.SUPER:
+                return (2, 1)  # heavy, super
             return (2, 1, 0)  # heavy, super, basic
         if self.tier == Tier.BASIC:
             return (0, 1, 2)  # basic, super, heavy

app/dataplane/account/__init__.py

@@ -307,7 +307,7 @@ class AccountDirectory:
 
 
 _POOL_INTERVAL_CONFIG: dict[str, tuple[str, int]] = {
-    "basic": ("account.refresh.basic_interval_sec", 36_000),
+    "basic": ("account.refresh.basic_interval_sec", 86_400),
     "super": ("account.refresh.super_interval_sec", 7_200),
     "heavy": ("account.refresh.heavy_interval_sec", 7_200),
 }

app/dataplane/account/sync.py

@@ -8,6 +8,7 @@ Two modes:
 from app.platform.logging.logger import logger
 from app.platform.runtime.clock import ms_to_s
 from app.control.account.models import AccountRecord
+from app.control.account.quota_defaults import normalize_quota_set
 from app.control.account.repository import AccountRepository
 from app.control.account.state_machine import derive_status
 from ..shared.enums import POOL_STR_TO_ID, STATUS_STR_TO_ID, StatusId
@@ -16,7 +17,7 @@ from .table import AccountRuntimeTable, make_empty_table
 
 def _record_to_slot_args(record: AccountRecord) -> dict:
     """Extract columnar values from a control-plane AccountRecord."""
-    qs = record.quota_set()
+    qs = normalize_quota_set(record.pool, record.quota_set())
     status_id = STATUS_STR_TO_ID.get(str(derive_status(record)), int(StatusId.ACTIVE))
     pool_id = POOL_STR_TO_ID.get(record.pool, 0)
 

app/dataplane/reverse/protocol/xai_chat.py

@@ -6,6 +6,7 @@ from typing import Any
 
 import orjson
 
+from app.platform.errors import UpstreamError
 from app.platform.logging.logger import logger
 from app.platform.config.snapshot import get_config
 from app.control.model.enums import ModeId
@@ -113,6 +114,46 @@ def classify_line(line: str | bytes) -> tuple[str, str]:
     return "skip", ""
 
 
+def stream_error_from_payload(obj: dict[str, Any]) -> UpstreamError | None:
+    """Convert upstream in-band stream error payloads to retryable errors."""
+    error = obj.get("error")
+    if not isinstance(error, dict):
+        return None
+
+    raw_message = error.get("message") or error.get("error") or "Upstream stream error"
+    message = str(raw_message)
+    code = error.get("code")
+    text = message.lower()
+    status = 429 if code == 8 or "too many requests" in text or "rate limit" in text else 502
+
+    try:
+        body = orjson.dumps(obj).decode()
+    except (TypeError, ValueError):
+        body = str(obj)
+
+    return UpstreamError(
+        f"Upstream stream error: {message}",
+        status=status,
+        body=body[:400],
+    )
+
+
+def raise_for_stream_error(data: str | bytes | dict[str, Any]) -> None:
+    """Raise :class:`UpstreamError` for raw or decoded in-band stream errors."""
+    if isinstance(data, dict):
+        obj = data
+    else:
+        try:
+            obj = orjson.loads(data)
+        except (orjson.JSONDecodeError, ValueError, TypeError):
+            return
+    if not isinstance(obj, dict):
+        return
+    exc = stream_error_from_payload(obj)
+    if exc is not None:
+        raise exc
+
+
 # ---------------------------------------------------------------------------
 # FrameEvent — single output event from StreamAdapter.feed()
 # ---------------------------------------------------------------------------
@@ -259,6 +300,7 @@ class StreamAdapter:
             obj = orjson.loads(data)
         except (orjson.JSONDecodeError, ValueError, TypeError):
             return []
+        raise_for_stream_error(obj)
 
         result = obj.get("result")
         if not result:

app/dataplane/reverse/protocol/xai_image_edit.py

@@ -28,7 +28,6 @@ def build_image_edit_payload(
         "enableImageStreaming": True,
         "imageGenerationCount": IMAGE_EDIT_GENERATION_COUNT,
         "forceConcise": False,
-        "toolOverrides": {"imageGen": True},
         "enableSideBySide": True,
         "sendFinalMetadata": True,
         "isReasoning": False,

app/dataplane/reverse/protocol/xai_usage.py

@@ -25,9 +25,9 @@ _MODE_NAMES: dict[int, str] = {
 
 # Default window durations used as fallback when API call fails.
 _DEFAULT_WINDOW_SECS: dict[int, int] = {
-    0: 72_000,  # auto   — 20 h (basic) / 2 h (super/heavy, real value overrides)
-    1: 72_000,  # fast   — 20 h (basic)
-    2: 36_000,  # expert — 10 h (basic)
+    0: 7_200,  # auto   — 2 h  (super/heavy only)
+    1: 86_400,  # fast   — 24 h (basic; real value overrides for super/heavy)
+    2: 7_200,  # expert — 2 h  (super/heavy only)
     3: 7_200,  # heavy  — 2 h  (heavy-pool only)
     4: 7_200,  # grok_4_3 — 2 h  (super/heavy only)
 }
@@ -43,7 +43,9 @@ def _build_payload(mode_name: str) -> bytes:
 # ---------------------------------------------------------------------------
 
 
-def parse_rate_limits(body: dict) -> dict | None:
+def parse_rate_limits(
+    body: dict, *, default_window_seconds: int = 72_000
+) -> dict | None:
     """Parse flat rate-limits response.
 
     Expected format::
@@ -67,7 +69,7 @@ def parse_rate_limits(body: dict) -> dict | None:
     return {
         "remaining": int(remaining),
         "total": int(total) if total is not None else int(remaining),
-        "window_seconds": int(window_secs) if window_secs else 72_000,
+        "window_seconds": int(window_secs) if window_secs else default_window_seconds,
     }
 
 
@@ -144,7 +146,10 @@ async def _fetch_one(token: str, mode_id: int) -> object | None:
         )
         return None
 
-    data = parse_rate_limits(body)
+    data = parse_rate_limits(
+        body,
+        default_window_seconds=_DEFAULT_WINDOW_SECS.get(mode_id, 72_000),
+    )
     if data is None:
         logger.debug(
             "rate-limits response missing quota fields: token={}... mode={} body={}",

app/dataplane/reverse/transport/assets.py

@@ -7,8 +7,23 @@ give feedback, and return results to the caller.
 import asyncio
 from typing import Any, AsyncGenerator, Dict, Optional
 
-from app.platform.logging.logger import logger
+from app.control.proxy.models import ProxyFeedback, ProxyFeedbackKind, ProxyScope, RequestKind
+from app.dataplane.proxy import get_proxy_runtime
+from app.dataplane.reverse.protocol.xai_assets import (
+    ASSETS_LIST_URL,
+    asset_delete_url,
+    infer_content_type,
+    resolve_download_url,
+)
+from app.dataplane.reverse.transport._proxy_feedback import upstream_feedback
+from app.dataplane.reverse.transport.http import (
+    delete_json,
+    get_bytes_stream,
+    get_json,
+)
 from app.platform.config.snapshot import get_config
+from app.platform.errors import UpstreamError
+from app.platform.logging.logger import logger
 
 # Global semaphores — limit concurrent transport calls across all callers.
 # Lazily initialised so the event loop is guaranteed to be running on first use.
@@ -28,21 +43,6 @@ def _get_delete_sem() -> asyncio.Semaphore:
         n = max(1, int(get_config("batch.asset_delete_concurrency", 50)))
         _delete_sem = asyncio.Semaphore(n)
     return _delete_sem
-from app.platform.errors import UpstreamError
-from app.control.proxy.models import ProxyFeedback, ProxyFeedbackKind, ProxyScope, RequestKind
-from app.dataplane.reverse.transport._proxy_feedback import upstream_feedback
-from app.dataplane.proxy import get_proxy_runtime
-from app.dataplane.reverse.protocol.xai_assets import (
-    ASSETS_LIST_URL,
-    asset_delete_url,
-    infer_content_type,
-    resolve_download_url,
-)
-from app.dataplane.reverse.transport.http import (
-    delete_json,
-    get_bytes_stream,
-    get_json,
-)
 
 
 # ------------------------------------------------------------------
@@ -174,16 +174,24 @@ async def download_asset(
     url, origin, referer = resolve_download_url(file_path)
     content_type = infer_content_type(url)
 
+    if content_type and content_type.startswith("video/"):
+        accept = "video/mp4,video/*,*/*;q=0.8"
+    elif content_type and content_type.startswith("image/"):
+        accept = "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8"
+    else:
+        accept = "*/*"
+
     extra: Dict[str, str] = {
+        "Accept":                   accept,
         "Cache-Control":            "no-cache",
         "Pragma":                   "no-cache",
         "Priority":                 "u=0, i",
+        "Sec-Fetch-Dest":           "document",
         "Sec-Fetch-Mode":           "navigate",
+        "Sec-Fetch-Site":           "none",
         "Sec-Fetch-User":           "?1",
         "Upgrade-Insecure-Requests": "1",
     }
-    if content_type:
-        extra["Content-Type"] = content_type
 
     proxy = await get_proxy_runtime()
     lease = await proxy.acquire(scope=ProxyScope.ASSET, kind=RequestKind.HTTP)

app/dataplane/reverse/transport/http.py

@@ -248,6 +248,9 @@ async def get_bytes_stream(
     )
     if extra_headers:
         headers.update(extra_headers)
+    if headers.get("Sec-Fetch-Mode") == "navigate":
+        headers.pop("Content-Type", None)
+        headers.pop("Origin", None)
     kwargs = build_session_kwargs(lease=lease)
 
     session = ResettableSession(**kwargs)
@@ -259,7 +262,6 @@ async def get_bytes_stream(
             stream=True,
             allow_redirects=True,
         )
-
         if response.status_code != 200:
             try:
                 body = (response.content).decode("utf-8", "replace")[:400]

app/platform/startup/migration.py

@@ -31,6 +31,7 @@ from loguru import logger
 from app.platform.paths import data_path
 
 if TYPE_CHECKING:
+    from app.control.account.commands import AccountPatch
     from app.control.account.repository import AccountRepository
     from app.platform.config.backends.base import ConfigBackend
 
@@ -51,8 +52,10 @@ async def run_startup_migrations(
 ) -> None:
     """Run all first-boot migrations.  Safe to call on every startup."""
     await _migrate_config(config_backend)
+    await _migrate_basic_refresh_interval(config_backend)
     await _migrate_accounts(account_repo)
     await _backfill_grok_4_3_quota(account_repo)
+    await _normalize_basic_fast_only_quota(account_repo)
 
 
 # ---------------------------------------------------------------------------
@@ -91,6 +94,21 @@ async def _migrate_config(backend: "ConfigBackend") -> None:
     logger.debug("config: {} backend is empty, no local overrides to migrate", backend_name)
 
 
+async def _migrate_basic_refresh_interval(backend: "ConfigBackend") -> None:
+    data = await backend.load()
+    account = data.get("account", {})
+    refresh = account.get("refresh", {}) if isinstance(account, dict) else {}
+    value = refresh.get("basic_interval_sec") if isinstance(refresh, dict) else None
+    try:
+        old_default = int(value)
+    except (TypeError, ValueError):
+        return
+    if old_default != 36_000:
+        return
+    await backend.apply_patch({"account": {"refresh": {"basic_interval_sec": 86_400}}})
+    logger.info("config: updated basic refresh interval default from 36000s to 86400s")
+
+
 # ---------------------------------------------------------------------------
 # Account migration
 # ---------------------------------------------------------------------------
@@ -123,7 +141,7 @@ async def _migrate_accounts(target_repo: "AccountRepository") -> None:
 async def _copy_accounts(sqlite_path: Path, target: "AccountRepository") -> int:
     """Read all accounts from the local SQLite file and write to *target*."""
     from app.control.account.backends.local import LocalAccountRepository
-    from app.control.account.commands import AccountPatch, AccountUpsert, ListAccountsQuery
+    from app.control.account.commands import AccountUpsert, ListAccountsQuery
 
     source = LocalAccountRepository(sqlite_path)
     await source.initialize()
@@ -230,6 +248,48 @@ async def _backfill_grok_4_3_quota(repo: "AccountRepository") -> None:
     logger.info("account: backfilled quota_grok_4_3 for {} super/heavy accounts", total)
 
 
+async def _normalize_basic_fast_only_quota(repo: "AccountRepository") -> None:
+    from app.control.account.commands import AccountPatch, ListAccountsQuery
+    from app.control.account.quota_defaults import normalize_quota_set
+
+    patches: list[AccountPatch] = []
+    page = 1
+    while True:
+        result = await repo.list_accounts(
+            ListAccountsQuery(
+                page=page,
+                page_size=_BATCH,
+                pool="basic",
+                include_deleted=False,
+            )
+        )
+        for record in result.items:
+            normalized = normalize_quota_set("basic", record.quota_set())
+            if normalized.to_dict() == record.quota_set().to_dict():
+                continue
+            patches.append(
+                AccountPatch(
+                    token=record.token,
+                    quota_auto=normalized.auto.to_dict(),
+                    quota_fast=normalized.fast.to_dict(),
+                    quota_expert=normalized.expert.to_dict(),
+                )
+            )
+        if page >= result.total_pages:
+            break
+        page += 1
+
+    if not patches:
+        return
+
+    total = 0
+    for i in range(0, len(patches), _BATCH):
+        batch = patches[i : i + _BATCH]
+        res = await repo.patch_accounts(batch)
+        total += res.patched
+    logger.info("account: normalized {} basic accounts to fast-only quota", total)
+
+
 # ---------------------------------------------------------------------------
 # Helpers
 # ---------------------------------------------------------------------------

app/products/openai/chat.py

@@ -4,6 +4,7 @@ import asyncio
 import base64
 import re
 from typing import Any, AsyncGenerator
+from urllib.parse import urlparse
 
 import orjson
 
@@ -213,6 +214,14 @@ def _save_image(raw: bytes, mime: str, image_id: str) -> str:
     return save_local_image(raw, mime, image_id)
 
 
+def _is_imagine_public_url(url: str) -> bool:
+    try:
+        host = urlparse(url or "").hostname or ""
+    except Exception:
+        return False
+    return host.startswith("imagine-public")
+
+
 async def _resolve_image(token: str, url: str, image_id: str) -> str:
     """Return the image embed text for the response body based on image_format config.
 
@@ -226,10 +235,15 @@ async def _resolve_image(token: str, url: str, image_id: str) -> str:
     cfg = get_config()
     fmt = _normalize_image_format(cfg.get_str("features.image_format", "grok_url"))
 
+    proxy_imagine_public = (
+        _is_imagine_public_url(url)
+        and cfg.get_bool("features.imagine_public_image_proxy", False)
+    )
+
     # Formats that don't need downloading
-    if fmt == "grok_url":
+    if fmt == "grok_url" and not proxy_imagine_public:
         return url
-    if fmt == "grok_md":
+    if fmt == "grok_md" and not proxy_imagine_public:
         return f"![image]({url})"
 
     # Formats that require downloading
@@ -254,9 +268,9 @@ async def _resolve_image(token: str, url: str, image_id: str) -> str:
         else f"/v1/files/image?id={file_id}"
     )
 
-    if fmt == "local_url":
+    if fmt in {"grok_url", "local_url"}:
         return local_url
-    return f"![image]({local_url})"  # local_md
+    return f"![image]({local_url})"  # grok_md / local_md
 
 
 def _normalize_image_format(value: str | None) -> str:

app/products/openai/images.py

@@ -8,6 +8,7 @@ import re
 import time
 from dataclasses import dataclass
 from typing import Any, AsyncGenerator, Awaitable, Callable
+from urllib.parse import urlparse
 
 import orjson
 
@@ -25,6 +26,7 @@ from app.dataplane.reverse.protocol.xai_chat import (
     StreamAdapter,
     build_chat_payload,
     classify_line,
+    raise_for_stream_error,
 )
 from app.dataplane.reverse.protocol.xai_assets import infer_content_type, resolve_asset_reference, resolve_download_url
 from app.dataplane.reverse.protocol.xai_image_edit import (
@@ -50,7 +52,15 @@ from ._format import (
     make_stream_chunk,
     make_thinking_chunk,
 )
-from .chat import _quota_sync, _fail_sync, _feedback_kind
+from .chat import (
+    _configured_retry_codes,
+    _fail_sync,
+    _feedback_kind,
+    _log_task_exception,
+    _quota_sync,
+    _should_retry_upstream,
+)
+from app.products._account_selection import selection_max_retries
 
 _X_USER_ID_RE = re.compile(r"(?:^|;\s*)x-userid=([^;]+)")
 
@@ -98,6 +108,21 @@ def _progress_reason(label: str, progress: int, *, completed: int | None = None,
     return reason
 
 
+def _progress_reason_delta(
+    label: str,
+    progress: int,
+    *,
+    completed: int | None = None,
+    total: int | None = None,
+) -> str:
+    return _progress_reason(
+        label,
+        progress,
+        completed=completed,
+        total=total,
+    ) + "\n"
+
+
 def _append_reason_update(
     updates: list[str],
     label: str,
@@ -163,6 +188,14 @@ def _extract_image_file_id(url: str) -> str:
     return hashlib.sha1(url.encode("utf-8")).hexdigest()[:32]
 
 
+def _is_imagine_public_url(url: str) -> bool:
+    try:
+        host = urlparse(url or "").hostname or ""
+    except Exception:
+        return False
+    return host.startswith("imagine-public")
+
+
 def _save_image(raw: bytes, mime: str, file_id: str) -> str:
     return save_local_image(raw, mime, file_id)
 
@@ -188,6 +221,13 @@ async def _resolve_image_output(
     blob_b64: str | None = None,
 ) -> _ImageOutput:
     fmt = _normalize_response_format(response_format)
+    cfg = get_config()
+    if (
+        fmt == "url"
+        and _is_imagine_public_url(url)
+        and not cfg.get_bool("features.imagine_public_image_proxy", False)
+    ):
+        return _ImageOutput(api_value=url, markdown_value=f"![image]({url})")
     if fmt == "url" and not _app_url():
         return _ImageOutput(api_value=url, markdown_value=f"![image]({url})")
 
@@ -242,7 +282,7 @@ async def generate(
     """Generate images.
 
     Routes to the appropriate backend based on model:
-      grok-imagine-image-lite  → chat endpoint (no aspect-ratio control, all pools)
+      grok-imagine-image-lite  → chat endpoint (fast quota, no aspect-ratio control)
       grok-imagine-image       → WebSocket speed mode (super+)
       grok-imagine-image-pro   → WebSocket quality mode (super+)
 
@@ -315,7 +355,7 @@ async def generate(
                                 completed=len(completed_ids),
                                 total=n,
                             )
-                            chunk = make_thinking_chunk(response_id, model, reason)
+                            chunk = make_thinking_chunk(response_id, model, reason + "\n")
                             yield f"data: {orjson.dumps(chunk).decode()}\n\n"
                         continue
                     if not ev.get("is_final"):
@@ -327,7 +367,7 @@ async def generate(
                     if chat_format and aggregate > last_progress:
                         last_progress = aggregate
                         reason = _progress_reason("图片", aggregate, completed=len(completed_ids), total=n)
-                        chunk = make_thinking_chunk(response_id, model, reason)
+                        chunk = make_thinking_chunk(response_id, model, reason + "\n")
                         yield f"data: {orjson.dumps(chunk).decode()}\n\n"
                     image = await _resolve_image_output(
                         token=token,
@@ -456,8 +496,7 @@ async def _generate_lite(
 ) -> dict | AsyncGenerator[str, None]:
     """Generate images via the chat endpoint (Aurora model path).
 
-    Does not support aspect ratio or quality control.  All account pools
-    can serve this model.
+    Does not support aspect ratio or quality control.  It uses fast quota.
     """
     response_id = make_response_id()
     cfg         = get_config()
@@ -498,7 +537,12 @@ async def _generate_lite(
                     chunk = make_thinking_chunk(
                         response_id,
                         spec.model_name,
-                        _progress_reason("图片", aggregate, completed=completed, total=n),
+                        _progress_reason_delta(
+                            "图片",
+                            aggregate,
+                            completed=completed,
+                            total=n,
+                        ),
                     )
                     yield f"data: {orjson.dumps(chunk).decode()}\n\n"
 
@@ -560,10 +604,17 @@ async def _generate_lite(
 # Image editing
 # ---------------------------------------------------------------------------
 
-_EDIT_MAX_REFERENCES = 5
+_EDIT_MAX_REFERENCES = 7
 _EDIT_DEFAULT_SIZE = "1024x1024"
 _EDIT_MAX_N = 2
 _EDIT_MAX_ATTEMPTS = 2
+_EDIT_IMAGE_PLACEHOLDER_RE = re.compile(r"@IMAGE(\d+)\b", re.IGNORECASE)
+
+
+@dataclass(slots=True)
+class _EditReference:
+    file_id: str
+    content_url: str
 
 
 def _normalize_edit_inputs(image_inputs: list[str]) -> list[str]:
@@ -585,11 +636,16 @@ def _normalize_edit_size(size: str) -> str:
     return _EDIT_DEFAULT_SIZE
 
 
-async def _prepare_edit_reference(token: str, image_input: str, index: int) -> str:
+async def _prepare_edit_reference(
+    token: str, image_input: str, index: int
+) -> _EditReference:
     """Upload one edit reference and resolve it to the upstream content URL."""
     try:
         file_id, file_uri = await upload_from_input(token, image_input)
-        return resolve_uploaded_asset_reference(token, file_id, file_uri)
+        return _EditReference(
+            file_id=file_id,
+            content_url=resolve_uploaded_asset_reference(token, file_id, file_uri),
+        )
     except ValidationError as exc:
         raise ValidationError(exc.message, param=f"image.{index}") from exc
     except UpstreamError as exc:
@@ -602,9 +658,11 @@ async def _prepare_edit_reference(token: str, image_input: str, index: int) -> s
         raise UpstreamError(f"Image edit reference {index + 1} upload failed: {exc}") from exc
 
 
-async def _prepare_edit_references(token: str, image_inputs: list[str]) -> list[str]:
+async def _prepare_edit_references(
+    token: str, image_inputs: list[str]
+) -> list[_EditReference]:
     """Upload edit references concurrently and preserve caller order."""
-    results: list[str | None] = [None] * len(image_inputs)
+    results: list[_EditReference | None] = [None] * len(image_inputs)
 
     async def _runner(index: int, image_input: str) -> None:
         results[index] = await _prepare_edit_reference(token, image_input, index)
@@ -616,6 +674,20 @@ async def _prepare_edit_references(token: str, image_inputs: list[str]) -> list[
     return [result for result in results if result is not None]
 
 
+def _replace_edit_image_placeholders(
+    prompt: str, references: list[_EditReference]
+) -> str:
+    """Replace @IMAGE1-style placeholders with uploaded asset IDs."""
+
+    def _replace(match: re.Match[str]) -> str:
+        image_number = int(match.group(1))
+        if image_number < 1 or image_number > len(references):
+            return match.group(0)
+        return f"@{references[image_number - 1].file_id}"
+
+    return _EDIT_IMAGE_PLACEHOLDER_RE.sub(_replace, prompt)
+
+
 def _extract_edit_prompt_and_inputs(messages: list[dict]) -> tuple[str, list[str]]:
     """Extract the final prompt and ordered image references from messages."""
     prompt = ""
@@ -748,6 +820,7 @@ async def _collect_edit_final_urls(
             obj = orjson.loads(data)
         except Exception:
             continue
+        raise_for_stream_error(obj)
         stream = extract_streaming_response(obj)
         if stream and progress_cb is not None:
             index = _parse_image_index(stream.get("imageIndex"))
@@ -910,59 +983,96 @@ async def _run_lite_request(
     if _acct_dir is None:
         raise RateLimitError("Account directory not initialised")
 
-    acct = await _acct_dir.reserve(
-        pool_candidates = spec.pool_candidates(),
-        mode_id         = int(spec.mode_id),
-        now_s_override  = now_s(),
-    )
-    if acct is None:
-        raise RateLimitError("No available accounts for image generation")
+    max_retries = selection_max_retries()
+    retry_codes = _configured_retry_codes(get_config())
+    excluded: list[str] = []
 
-    token   = acct.token
-    adapter = StreamAdapter()
-    success = False
-    fail_exc: BaseException | None = None
-    try:
-        async for line in _stream_lite_generate(
-            token,
-            prompt,
-            spec.mode_id,
-            timeout_s=timeout_s,
-        ):
-            ev_type, data = classify_line(line)
-            if ev_type == "done":
-                break
-            if ev_type != "data" or not data:
-                continue
-            for ev in adapter.feed(data):
-                if ev.kind == "image_progress":
-                    if progress_cb is not None:
-                        try:
-                            await progress_cb(_clamp_progress(int(ev.content or "0")))
-                        except ValueError:
-                            pass
-                if ev.kind == "image" and ev.content:
-                    if progress_cb is not None:
-                        await progress_cb(100)
-                    image = await _resolve_image_output(
-                        token=token,
-                        url=ev.content,
-                        response_format=response_format,
-                    )
-                    success = True
-                    return image
-        raise UpstreamError("Image generation returned no images")
-    except BaseException as exc:
-        fail_exc = exc
-        raise
-    finally:
-        await _acct_dir.release(acct)
-        kind = FeedbackKind.SUCCESS if success else _feedback_kind(fail_exc) if fail_exc else FeedbackKind.SERVER_ERROR
-        await _acct_dir.feedback(token, kind, int(spec.mode_id))
-        if success:
-            asyncio.create_task(_quota_sync(token, int(spec.mode_id)))
-        else:
-            asyncio.create_task(_fail_sync(token, int(spec.mode_id), fail_exc))
+    for attempt in range(max_retries + 1):
+        acct = await _acct_dir.reserve(
+            pool_candidates=spec.pool_candidates(),
+            mode_id=int(spec.mode_id),
+            now_s_override=now_s(),
+            exclude_tokens=excluded or None,
+        )
+        if acct is None:
+            raise RateLimitError("No available accounts for image generation")
+
+        token = acct.token
+        adapter = StreamAdapter()
+        success = False
+        retry = False
+        fail_exc: BaseException | None = None
+
+        try:
+            async for line in _stream_lite_generate(
+                token,
+                prompt,
+                spec.mode_id,
+                timeout_s=timeout_s,
+            ):
+                ev_type, data = classify_line(line)
+                if ev_type == "done":
+                    break
+                if ev_type != "data" or not data:
+                    continue
+                for ev in adapter.feed(data):
+                    if ev.kind == "image_progress":
+                        if progress_cb is not None:
+                            try:
+                                await progress_cb(_clamp_progress(int(ev.content or "0")))
+                            except ValueError:
+                                pass
+                    if ev.kind == "image" and ev.content:
+                        if progress_cb is not None:
+                            await progress_cb(100)
+                        image = await _resolve_image_output(
+                            token=token,
+                            url=ev.content,
+                            response_format=response_format,
+                        )
+                        success = True
+                        return image
+            raise UpstreamError("Image generation returned no images")
+        except UpstreamError as exc:
+            fail_exc = exc
+            if _should_retry_upstream(exc, retry_codes) and attempt < max_retries:
+                retry = True
+                logger.warning(
+                    "lite image retry scheduled: attempt={}/{} status={} token={}...",
+                    attempt + 1,
+                    max_retries,
+                    exc.status,
+                    token[:8],
+                )
+            else:
+                raise
+        except BaseException as exc:
+            fail_exc = exc
+            raise
+        finally:
+            await _acct_dir.release(acct)
+            kind = (
+                FeedbackKind.SUCCESS
+                if success
+                else _feedback_kind(fail_exc)
+                if fail_exc
+                else FeedbackKind.SERVER_ERROR
+            )
+            await _acct_dir.feedback(token, kind, int(spec.mode_id))
+            if success:
+                asyncio.create_task(
+                    _quota_sync(token, int(spec.mode_id))
+                ).add_done_callback(_log_task_exception)
+            else:
+                asyncio.create_task(
+                    _fail_sync(token, int(spec.mode_id), fail_exc)
+                ).add_done_callback(_log_task_exception)
+
+        if retry:
+            excluded.append(token)
+            continue
+
+    raise RateLimitError("No available accounts for image generation")
 
 
 async def _run_lite_batch(
@@ -1026,16 +1136,19 @@ async def edit(
 
     token       = acct.token
     response_id = make_response_id()
+    edit_prompt = prompt
 
     try:
-        image_references = await _prepare_edit_references(token, image_inputs)
-        if not image_references:
+        edit_references = await _prepare_edit_references(token, image_inputs)
+        if not edit_references:
             raise UpstreamError("All image uploads failed; cannot proceed with image edit")
+        edit_prompt = _replace_edit_image_placeholders(prompt, edit_references)
+        image_references = [ref.content_url for ref in edit_references]
 
         post = await create_media_post(
             token,
             media_type=IMAGE_POST_MEDIA_TYPE,
-            prompt=prompt,
+            prompt=edit_prompt,
         )
         post_data = post.get("post")
         if not isinstance(post_data, dict):
@@ -1043,6 +1156,9 @@ async def edit(
         parent_post_id = str(post_data.get("id") or "").strip()
         if not parent_post_id:
             raise UpstreamError("Image edit create-post returned no post id")
+        post_prompt = post_data.get("originalPrompt") or post_data.get("prompt")
+        if isinstance(post_prompt, str) and post_prompt.strip():
+            edit_prompt = post_prompt.strip()
     except Exception:
         await _acct_dir.release(acct)
         raise
@@ -1065,7 +1181,7 @@ async def edit(
                 task = asyncio.create_task(
                     _collect_edit_images(
                         token=token,
-                        prompt=prompt,
+                        prompt=edit_prompt,
                         image_references=image_references,
                         parent_post_id=parent_post_id,
                         requested_n=n,
@@ -1084,7 +1200,12 @@ async def edit(
                         chunk = make_thinking_chunk(
                             response_id,
                             model,
-                            _progress_reason("图片", aggregate, completed=completed, total=n),
+                            _progress_reason_delta(
+                                "图片",
+                                aggregate,
+                                completed=completed,
+                                total=n,
+                            ),
                         )
                         yield f"data: {orjson.dumps(chunk).decode()}\n\n"
                 images = await task
@@ -1129,7 +1250,7 @@ async def edit(
 
         images = await _collect_edit_images(
             token=token,
-            prompt=prompt,
+            prompt=edit_prompt,
             image_references=image_references,
             parent_post_id=parent_post_id,
             requested_n=n,

app/products/openai/router.py

@@ -16,6 +16,7 @@ from app.platform.logging.logger import logger
 from app.platform.storage import image_files_dir, video_files_dir
 from app.control.model import registry as model_registry
 from app.control.model.spec import ModelSpec
+from app.control.account.quota_defaults import supports_mode
 from .schemas import (
     ChatCompletionRequest,
     ImageGenerationRequest,
@@ -48,8 +49,11 @@ async def _available_pools(request: Request) -> frozenset[str]:
 def _model_available_for_pools(spec: ModelSpec, pools: frozenset[str]) -> bool:
     if not spec.enabled:
         return False
-    candidates = {_POOL_ID_TO_NAME[pool_id] for pool_id in spec.pool_candidates()}
-    return bool(candidates & pools)
+    for pool_id in spec.pool_candidates():
+        pool = _POOL_ID_TO_NAME[pool_id]
+        if pool in pools and supports_mode(pool, int(spec.mode_id)):
+            return True
+    return False
 
 
 # ---------------------------------------------------------------------------
@@ -478,7 +482,7 @@ async def videos_create(
     if input_reference:
         references_payload = [
             {"image_url": await _upload_to_data_uri(f, param="input_reference")}
-            for f in input_reference[:5]
+            for f in input_reference[:7]
         ]
 
     result = await create_video(

app/products/openai/video.py

@@ -38,7 +38,7 @@ from app.dataplane.reverse.protocol.xai_assets import (
     resolve_asset_reference,
     resolve_download_url,
 )
-from app.dataplane.reverse.protocol.xai_chat import classify_line
+from app.dataplane.reverse.protocol.xai_chat import classify_line, raise_for_stream_error
 from app.dataplane.reverse.runtime.endpoint_table import CHAT
 from app.dataplane.reverse.transport.asset_upload import (
     resolve_uploaded_asset_reference,
@@ -56,7 +56,7 @@ from .chat import _fail_sync, _quota_sync, _feedback_kind
 
 _IMAGE_MEDIA_TYPE = "MEDIA_POST_TYPE_IMAGE"
 _VIDEO_MEDIA_TYPE = "MEDIA_POST_TYPE_VIDEO"
-_VIDEO_MODEL_NAME = "grok-3"
+_VIDEO_MODEL_NAME = "imagine-video-gen"
 _VIDEO_QUALITY = "standard"
 _VIDEO_OBJECT = "video"
 _VIDEO_JOB_TTL_S = 3600
@@ -143,6 +143,10 @@ def _progress_reason(progress: int) -> str:
     return f"视频正在生成 {max(0, min(100, int(progress)))}%"
 
 
+def _progress_reason_delta(progress: int) -> str:
+    return _progress_reason(progress) + "\n"
+
+
 def _coerce_seconds(value: str | int | None) -> int:
     if value is None:
         return 6
@@ -230,7 +234,6 @@ def _video_create_payload(
         "temporary": True,
         "modelName": _VIDEO_MODEL_NAME,
         "message": _build_message(prompt, preset),
-        "toolOverrides": {"videoGen": True},
         "enableSideBySide": True,
         "responseMetadata": {
             "experiments": [],
@@ -262,7 +265,6 @@ def _video_extend_payload(
         "temporary": True,
         "modelName": _VIDEO_MODEL_NAME,
         "message": _build_message(prompt, preset),
-        "toolOverrides": {"videoGen": True},
         "enableSideBySide": True,
         "responseMetadata": {
             "experiments": [],
@@ -434,16 +436,45 @@ async def _prepare_video_references(
     input_references: list[dict[str, Any]],
 ) -> list[_VideoReference]:
     """Upload multiple video references concurrently and preserve order."""
-    results: list[_VideoReference | None] = [None] * len(input_references)
+    tasks = [
+        _prepare_video_reference(token, ref)
+        for ref in input_references
+    ]
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+    failures: list[tuple[int, BaseException]] = [
+        (index, result)
+        for index, result in enumerate(results)
+        if isinstance(result, BaseException)
+    ]
+    if failures:
+        index, exc = failures[0]
+        message = f"Video input reference {index + 1} failed: {_exception_message(exc)}"
+        if len(failures) > 1:
+            message += f" ({len(failures)} references failed)"
+        if isinstance(exc, ValidationError):
+            raise ValidationError(message, param=exc.param) from exc
+        if isinstance(exc, UpstreamError):
+            raise UpstreamError(
+                message,
+                status=exc.status,
+                body=exc.details.get("body", ""),
+            ) from exc
+        raise UpstreamError(message) from exc
 
-    async def _runner(index: int, ref: dict[str, Any]) -> None:
-        results[index] = await _prepare_video_reference(token, ref)
+    return [r for r in results if isinstance(r, _VideoReference)]
 
-    async with asyncio.TaskGroup() as tg:
-        for index, ref in enumerate(input_references):
-            tg.create_task(_runner(index, ref), name=f"video-ref-{index}")
 
-    return [r for r in results if r is not None]
+def _exception_message(exc: BaseException) -> str:
+    if isinstance(exc, BaseExceptionGroup):
+        messages = [
+            _exception_message(child)
+            for child in exc.exceptions
+            if not isinstance(child, asyncio.CancelledError)
+        ]
+        return "; ".join(message for message in messages if message) or str(exc)
+    if isinstance(exc, AppError):
+        return exc.message
+    return str(exc)
 
 
 async def _collect_video_segment(
@@ -458,6 +489,7 @@ async def _collect_video_segment(
     final_asset_id = ""
     final_thumbnail = ""
     video_post_id = ""
+    stream_data_items: list[str] = []
 
     async for line in _stream_video_request(
         token,
@@ -470,10 +502,12 @@ async def _collect_video_segment(
             break
         if event_type != "data" or not data:
             continue
+        stream_data_items.append(data)
         try:
             obj = orjson.loads(data)
         except Exception:
             continue
+        raise_for_stream_error(obj)
 
         stream = _extract_streaming_video_response(obj)
         if stream:
@@ -511,10 +545,14 @@ async def _collect_video_segment(
 
     if not final_url and final_asset_id:
         raise UpstreamError(
-            "Video segment returned only assetId without a resolvable URL"
+            "Video segment returned only assetId without a resolvable URL",
+            body="\n".join(stream_data_items),
         )
     if not final_url:
-        raise UpstreamError("Video generation returned no final video URL")
+        raise UpstreamError(
+            "Video generation returned no final video URL",
+            body="\n".join(stream_data_items),
+        )
 
     return _VideoArtifact(
         video_url=final_url,
@@ -534,7 +572,12 @@ async def _download_video_bytes(token: str, url: str) -> tuple[bytes, str]:
         raise
     except Exception as exc:
         raise UpstreamError(f"Video download failed: {exc}") from exc
-    return b"".join(chunks), (content_type or "video/mp4")
+    raw = b"".join(chunks)
+    if not raw:
+        raise UpstreamError("Video download returned empty content", status=502)
+    if raw.lstrip()[:1] in {b"<", b"{"}:
+        raise UpstreamError("Video download returned non-video content", status=502)
+    return raw, (content_type or "video/mp4")
 
 
 def _save_video_bytes(raw: bytes, file_id: str) -> Path:
@@ -578,7 +621,7 @@ async def _resolve_video_output(*, token: str, url: str, file_id: str) -> str:
         raw, _mime = await _download_video_bytes(token, url)
         await asyncio.to_thread(_save_video_bytes, raw, file_id)
     except Exception as exc:
-        logger.warning("video download failed: fallback_to=upstream_url error={}", exc)
+        logger.debug("video download fallback_to=upstream_url error={}", exc)
         return url if fmt == "local_url" else _render_video_html(url)
 
     local_url = _local_video_url(file_id)
@@ -867,7 +910,7 @@ async def _run_video_job(
         logger.exception("video job failed: job_id={} error={}", job.id, exc)
         async with _VIDEO_JOBS_LOCK:
             job.status = "failed"
-            job.error = _job_error_payload(str(exc))
+            job.error = _job_error_payload(_exception_message(exc))
 
 
 async def create_video(
@@ -993,7 +1036,7 @@ def _extract_video_prompt_and_reference(
 
     input_references: list[dict[str, Any]] | None = None
     if reference_urls:
-        input_references = [{"image_url": url} for url in reference_urls[:5]]
+        input_references = [{"image_url": url} for url in reference_urls[:7]]
     return prompt, input_references
 
 
@@ -1061,7 +1104,7 @@ async def completions(
                 if progress > last_progress:
                     last_progress = progress
                     chunk = make_thinking_chunk(
-                        response_id, model, _progress_reason(progress)
+                        response_id, model, _progress_reason_delta(progress)
                     )
                     yield f"data: {orjson.dumps(chunk).decode()}\n\n"
 

app/products/web/admin/tokens.py

@@ -87,6 +87,11 @@ class ToggleTokenDisabledRequest(BaseModel):
     disabled: bool
 
 
+class ToggleTokensDisabledRequest(BaseModel):
+    tokens: list[str]
+    disabled: bool
+
+
 class TokenImportItem(BaseModel):
     token: str
     tags: list[str] = []
@@ -358,6 +363,69 @@ async def toggle_token_disabled(
     return _json({"status": "success", "token": token, "disabled": False})
 
 
+@router.post("/tokens/disabled/batch")
+async def toggle_tokens_disabled(
+    req: ToggleTokensDisabledRequest,
+    repo: "AccountRepository" = Depends(get_repo),
+):
+    cleaned: list[str] = []
+    seen: set[str] = set()
+    for raw in req.tokens:
+        token = _sanitize(raw)
+        if token and token not in seen:
+            seen.add(token)
+            cleaned.append(token)
+    if not cleaned:
+        raise ValidationError("No valid tokens provided", param="tokens")
+
+    records = await repo.get_accounts(cleaned)
+    if not records:
+        raise AppError(
+            "No matching accounts found",
+            kind=ErrorKind.VALIDATION,
+            code="account_not_found",
+            status=404,
+        )
+
+    ts = now_ms()
+    patches: list[AccountPatch] = []
+    for record in records:
+        if req.disabled:
+            patches.append(AccountPatch(
+                token=record.token,
+                status=AccountStatus.DISABLED,
+                state_reason="operator_disabled",
+                ext_merge={
+                    **record.ext,
+                    "disabled_at": ts,
+                    "disabled_reason": "operator_disabled",
+                },
+            ))
+        else:
+            patches.append(AccountPatch(
+                token=record.token,
+                status=AccountStatus.ACTIVE,
+                clear_failures=True,
+            ))
+
+    result = await repo.patch_accounts(patches)
+    logger.info(
+        "admin tokens disabled batch updated: disabled={} requested_count={} patched_count={}",
+        req.disabled,
+        len(cleaned),
+        result.patched,
+    )
+    return _json({
+        "status": "success",
+        "disabled": req.disabled,
+        "summary": {
+            "total": len(cleaned),
+            "ok": result.patched,
+            "fail": max(0, len(cleaned) - result.patched),
+        },
+    })
+
+
 @router.put("/tokens/pool")
 async def replace_pool(
     req: ReplacePoolRequest,

app/products/web/webui/voice.py

@@ -4,7 +4,6 @@ from fastapi import APIRouter, Depends
 from pydantic import BaseModel
 
 from app.platform.errors import AppError, RateLimitError, UpstreamError
-from app.platform.logging.logger import logger
 from app.platform.runtime.clock import now_s
 from app.platform.auth.middleware import verify_webui_key
 
@@ -32,11 +31,15 @@ async def voice_token(request: VoiceTokenRequest):
     if _acct_dir is None:
         raise RateLimitError("Account directory not initialised")
 
-    # Voice uses super/basic pools → try super first, then basic, then heavy.
+    # Voice uses auto mode, which is available on super/heavy pools only.
     from app.control.model.enums import ModeId
 
     ts = now_s()
-    acct = await _acct_dir.reserve(pool_candidates=(1, 0, 2), mode_id=int(ModeId.AUTO), now_s_override=ts)
+    acct = await _acct_dir.reserve(
+        pool_candidates=(1, 2),
+        mode_id=int(ModeId.AUTO),
+        now_s_override=ts,
+    )
     if acct is None:
         raise RateLimitError("No available tokens for voice mode")
 

app/statics/admin/account.html

@@ -939,6 +939,12 @@
       <button type="button" onclick="batchRefreshSel()" id="btn-refresh" class="toolbar-icon-btn" style="display:none">
         <svg viewBox="0 0 24 24" stroke-width="1.8"><path d="M20 11a8 8 0 0 0-14.6-4.6"/><path d="M4 4v5h5"/><path d="M4 13a8 8 0 0 0 14.6 4.6"/><path d="M20 20v-5h-5"/></svg>
       </button>
+      <button type="button" onclick="batchDisableSel()" id="btn-disable" class="toolbar-icon-btn" style="display:none">
+        <svg viewBox="0 0 24 24" stroke-width="1.8"><circle cx="12" cy="12" r="8"/><path d="M8.5 8.5 15.5 15.5"/></svg>
+      </button>
+      <button type="button" onclick="batchRestoreSel()" id="btn-restore" class="toolbar-icon-btn" style="display:none">
+        <svg viewBox="0 0 24 24" stroke-width="1.8"><path d="M3 12a9 9 0 1 0 3-6.708"/><path d="M3 4v5h5"/></svg>
+      </button>
       <button type="button" onclick="batchDeleteSel()" id="btn-delete" class="toolbar-icon-btn toolbar-icon-btn-danger" style="display:none">
         <svg viewBox="0 0 24 24" stroke-width="1.8"><path d="M5 7h14"/><path d="M9 7V4h6v3"/><path d="M8 10v7"/><path d="M12 10v7"/><path d="M16 10v7"/><path d="M7 7l1 13h8l1-13"/></svg>
       </button>
@@ -1119,6 +1125,8 @@ function applyAccountI18n() {
     ['btn-export', 'account.export', '导出数据'],
     ['btn-nsfw', 'account.batchNsfw', '开启 NSFW'],
     ['btn-refresh', 'account.batchRefresh', '刷新选中'],
+    ['btn-disable', 'account.batchDisable', '禁用选中'],
+    ['btn-restore', 'account.batchRestore', '恢复选中'],
     ['btn-delete', 'account.batchDelete', '删除选中'],
     ['btn-batch-cancel', 'account.cancel', '取消'],
   ];
@@ -1580,7 +1588,7 @@ function toggleRow(el) {
 }
 function updateBatchBtns() {
   const show = sel.size > 0;
-  ['btn-nsfw','btn-refresh','btn-delete'].forEach(id =>
+  ['btn-nsfw','btn-refresh','btn-disable','btn-restore','btn-delete'].forEach(id =>
     document.getElementById(id).style.display = show ? '' : 'none');
 }
 
@@ -1811,7 +1819,7 @@ let _batchEs     = null;
 
 async function _runBatch(endpoint, tokens, label, onDone) {
   const btnCancel = document.getElementById('btn-batch-cancel');
-  ['btn-nsfw','btn-refresh','btn-delete'].forEach(id =>
+  ['btn-nsfw','btn-refresh','btn-disable','btn-restore','btn-delete'].forEach(id =>
     document.getElementById(id).style.display = 'none');
   btnCancel.style.display = '';
 
@@ -1930,6 +1938,45 @@ async function setDisabled(token, disabled) {
 function disableOne(token) { setDisabled(token, true); }
 function restoreOne(token) { setDisabled(token, false); }
 
+function batchSetDisabled(disabled) {
+  if (!sel.size) return;
+  const tokens = [...sel];
+  const n = tokens.length;
+  const title = disabled
+    ? tr('account.batchDisableConfirmTitle', null, '批量禁用账号')
+    : tr('account.batchRestoreConfirmTitle', null, '批量恢复账号');
+  const body = disabled
+    ? tr('account.batchDisableConfirmBody', { n }, `确认禁用选中的 <b>${n}</b> 个账户？<br><small style="color:var(--fg-muted)">禁用后这些账号不会参与请求分配，但可随时恢复。</small>`)
+    : tr('account.batchRestoreConfirmBody', { n }, `确认恢复选中的 <b>${n}</b> 个账户？<br><small style="color:var(--fg-muted)">恢复后这些账号将重新参与请求分配。</small>`);
+
+  openConfirm(title, body, async () => {
+    try {
+      showToast(
+        disabled
+          ? tr('account.disablingMany', { n }, `正在禁用 ${n} 个账户…`)
+          : tr('account.restoringMany', { n }, `正在恢复 ${n} 个账户…`),
+        'info',
+      );
+      const d = await _api('POST', '/tokens/disabled/batch', { tokens, disabled });
+      const ok = d.summary?.ok ?? 0;
+      const fail = d.summary?.fail ?? 0;
+      showToast(
+        disabled
+          ? tr('account.disableManyDone', { ok, fail }, `禁用完成：成功 ${ok} 个，失败 ${fail} 个`)
+          : tr('account.restoreManyDone', { ok, fail }, `恢复完成：成功 ${ok} 个，失败 ${fail} 个`),
+        fail > 0 ? 'error' : 'success',
+      );
+      sel.clear();
+      await load();
+    } catch (e) {
+      showToast(`${tr('account.operationFailed', null, '操作失败')}: ${e.message}`, 'error');
+    }
+  });
+}
+
+function batchDisableSel() { batchSetDisabled(true); }
+function batchRestoreSel() { batchSetDisabled(false); }
+
 async function batchRefreshSel() {
   if (!sel.size) return;
   await _runBatch('/batch/refresh', [...sel],

app/statics/admin/config.html

@@ -467,9 +467,17 @@ const SCHEMA_DEF = [
               { value: 'local_md', label: 'Markdown（本地代理）', labelKey: 'config.schema.options.imageFormat.localMarkdown', disabledWhen: 'no_app_url', disabledTip: '请先填写 APP 访问地址', disabledTipKey: 'config.disabledTip.appUrlRequired' },
               { value: 'base64', label: 'Base64（内嵌）', labelKey: 'config.schema.options.imageFormat.base64' },
             ],
-            desc: 'grok_url / grok_md 直接返回 Grok CDN 地址，客户端需具备 CDN 访问能力；local_* 模式会先下载到服务端，再通过本地 URL 代理分发；base64 会以内嵌 Data URI 返回。',
+            desc: 'grok_url / grok_md 默认直接返回 Grok CDN 地址；local_* 模式会先下载到服务端，再通过本地 URL 代理分发；base64 会以内嵌 Data URI 返回。开启 Imagine Public 图片代理后，WebSocket 返回的 imagine-public 图片也会本地代理。',
             descKey: 'config.schema.fields.imageFormat.desc',
           },
+          {
+            key: 'imagine_public_image_proxy',
+            label: 'Imagine Public 图片代理',
+            labelKey: 'config.schema.fields.imaginePublicImageProxy.label',
+            type: 'bool',
+            desc: '开启后将 WebSocket 返回的 imagine-public 图片下载到服务端，再通过本地 URL 代理分发；关闭时保持公开图片直返。',
+            descKey: 'config.schema.fields.imaginePublicImageProxy.desc',
+          },
           {
             key: 'video_format',
             label: '视频返回格式',
@@ -496,7 +504,7 @@ const SCHEMA_DEF = [
         section: 'account.refresh',
         fields: [
           { key: 'enabled', label: '启用配额刷新', labelKey: 'config.schema.fields.refreshEnabled.label', type: 'bool', desc: '开启后自动进入配额刷新模式，关闭后自动进入自动重试模式。', descKey: 'config.schema.fields.refreshEnabled.desc', help: '开启：配额刷新模式，scheduler 周期同步真实配额，选号按评分。\n关闭：自动重试模式，不主动探测 upstream，选号随机，出错自动换号重试最多 5 次。\n建议：万级以上账号关闭，避免主动探测触发 upstream 429。', helpKey: 'config.schema.fields.refreshEnabled.help' },
-          { key: 'basic_interval_sec', label: 'Basic 周期（秒）', labelKey: 'config.schema.fields.basicInterval.label', type: 'number', desc: 'basic 号池共用周期：quota 模式下用于后台刷新，random 模式下用于 429 冷却。默认 36000s。', descKey: 'config.schema.fields.basicInterval.desc' },
+          { key: 'basic_interval_sec', label: 'Basic 周期（秒）', labelKey: 'config.schema.fields.basicInterval.label', type: 'number', desc: 'basic 号池共用周期：quota 模式下用于后台刷新，random 模式下用于 429 冷却。默认 86400s。', descKey: 'config.schema.fields.basicInterval.desc' },
           { key: 'super_interval_sec', label: 'Super 周期（秒）', labelKey: 'config.schema.fields.superInterval.label', type: 'number', desc: 'super 号池共用周期：quota 模式下用于后台刷新，random 模式下用于 429 冷却。默认 7200s。', descKey: 'config.schema.fields.superInterval.desc' },
           { key: 'heavy_interval_sec', label: 'Heavy 周期（秒）', labelKey: 'config.schema.fields.heavyInterval.label', type: 'number', desc: 'heavy 号池共用周期：quota 模式下用于后台刷新，random 模式下用于 429 冷却。默认 7200s。', descKey: 'config.schema.fields.heavyInterval.desc' },
           { key: 'on_demand_min_interval_sec', label: '按需刷新间隔（秒）', labelKey: 'config.schema.fields.onDemandMinInterval.label', type: 'number', desc: '请求链路触发刷新（例如收到 429）时的节流间隔。N 秒内重复触发只执行一次，避免批量打爆配额接口。', descKey: 'config.schema.fields.onDemandMinInterval.desc' },

app/statics/css/app.css

@@ -561,6 +561,11 @@ button{cursor:pointer}
 .msg-card-assistant video{
   display:block;width:min(100%,400px);max-height:300px;border-radius:16px;background:#111
 }
+.msg-media-error{
+  box-sizing:border-box;width:max-content;max-width:100%;margin-top:8px;padding:9px 11px;border-radius:10px;
+  background:#fff7ed;border:1px solid #fed7aa;color:#9a3412;font-size:12px;line-height:1.5;
+  white-space:nowrap
+}
 .msg-card-assistant > *:first-child{margin-top:0}
 .msg-card-assistant > *:last-child{margin-bottom:0}
 .msg-card-assistant p,
@@ -688,6 +693,8 @@ button{cursor:pointer}
   color:#201d19;
   font-size:12px;
   letter-spacing:-.01em;
+  text-align:right;
+  text-align-last:right;
   appearance:none;
   background-image:none;
 }

app/statics/i18n/de.json

@@ -64,6 +64,8 @@
         "imageRequired": "Für die Bildbearbeitung ist mindestens ein Referenzbild erforderlich",
         "imageOnly": "Die Bildbearbeitung unterstützt nur Bild-Uploads",
         "videoImageOnly": "Die Videogenerierung unterstützt nur Bild-Uploads als Referenz",
+        "imageProxyRequired": "Bild konnte nicht geladen werden. Konfigurieren Sie die APP-Basis-URL und ändern Sie das Bildausgabeformat in local_url, local_md oder base64.",
+        "videoProxyRequired": "Das Laden des Videos ergab 403. Öffnen Sie die Admin-Seite, konfigurieren Sie die APP-Basis-URL und ändern Sie das Videoausgabeformat in den lokalen Proxy-Modus (local_url oder local_html). Versuchen Sie es dann erneut.",
         "requestFailed": "Anfrage fehlgeschlagen",
         "initFailed": "Initialisierung der Chat-Seite fehlgeschlagen"
       }
@@ -182,6 +184,8 @@
     "batchNsfw": "NSFW aktivieren",
     "batchNsfwDisable": "NSFW deaktivieren",
     "batchRefresh": "Auswahl aktualisieren",
+    "batchDisable": "Auswahl deaktivieren",
+    "batchRestore": "Auswahl wiederherstellen",
     "batchDelete": "Auswahl löschen",
     "colToken": "Token",
     "colType": "Kontotyp",
@@ -264,6 +268,14 @@
     "restoreConfirmBody": "{token} wiederherstellen?<br><small style=\"color:var(--fg-muted)\">Das Konto nimmt danach wieder an der Anfrageverteilung teil.</small>",
     "restoringOne": "Konto wird wiederhergestellt…",
     "restoreDone": "Konto wiederhergestellt",
+    "batchDisableConfirmTitle": "Konten deaktivieren",
+    "batchDisableConfirmBody": "Die ausgewählten <b>{n}</b> Konten deaktivieren?<br><small style=\"color:var(--fg-muted)\">Deaktivierte Konten werden nicht für Anfragen verwendet und können später wiederhergestellt werden.</small>",
+    "disablingMany": "{n} Konten werden deaktiviert…",
+    "disableManyDone": "Deaktivierung abgeschlossen: {ok} erfolgreich, {fail} fehlgeschlagen",
+    "batchRestoreConfirmTitle": "Konten wiederherstellen",
+    "batchRestoreConfirmBody": "Die ausgewählten <b>{n}</b> Konten wiederherstellen?<br><small style=\"color:var(--fg-muted)\">Wiederhergestellte Konten werden erneut für Anfragen verwendet.</small>",
+    "restoringMany": "{n} Konten werden wiederhergestellt…",
+    "restoreManyDone": "Wiederherstellung abgeschlossen: {ok} erfolgreich, {fail} fehlgeschlagen",
     "nsfwConfirmTitle": "NSFW aktivieren",
     "nsfwConfirmBody": "NSFW für <b>{n}</b> ausgewählte Konten aktivieren?",
     "nsfwEnablingOne": "NSFW wird aktiviert…",
@@ -383,11 +395,12 @@
         "enableNsfw": { "label": "NSFW-Erzeugung zulassen" },
         "showSearchSources": { "label": "Quellen an Inhalt anhängen", "desc": "Suchquellen werden immer im Feld search_sources ausgegeben. Diese Option steuert, ob zusätzlich ein ## Sources-Abschnitt an den Inhalt angehängt wird (für Abwärtskompatibilität mit textbasierten Clients)." },
         "customInstruction": { "label": "Globale Zusatzanweisung" },
-        "imageFormat": { "label": "Bildausgabeformat" },
+        "imageFormat": { "label": "Bildausgabeformat", "desc": "grok_url und grok_md geben die native Grok-CDN-Adresse standardmäßig direkt zurück. local_* Modi laden Assets zuerst auf den Server herunter und stellen sie über den lokalen Proxy bereit. base64 gibt eine eingebettete Data URI zurück. Wenn der Imagine-Public-Bildproxy aktiviert ist, werden vom WebSocket zurückgegebene imagine-public-Bilder ebenfalls lokal proxied." },
+        "imaginePublicImageProxy": { "label": "Imagine-Public-Bildproxy", "desc": "Wenn aktiviert, werden vom WebSocket zurückgegebene imagine-public-Bilder auf den Server heruntergeladen und über den lokalen Proxy ausgeliefert. Wenn deaktiviert, werden öffentliche Bilder direkt zurückgegeben." },
         "videoFormat": { "label": "Videoausgabeformat" },
         "refreshEnabled": { "label": "Quotenaktualisierung aktivieren", "desc": "Wenn aktiviert, wechselt das System automatisch in den Quotenaktualisierungsmodus. Wenn deaktiviert, wechselt es automatisch in den Auto-Retry-Modus.", "help": "Ein: Quotenaktualisierung. Der Scheduler synchronisiert regelmäßig echte Quoten, die Auswahl erfolgt nach Bewertung.\nAus: Auto-Retry-Modus. Keine aktive upstream-Abfrage, zufällige Auswahl und automatischer Kontowechsel bei Fehlern mit bis zu 5 Wiederholungen.\nEmpfehlung: Bei mehr als 10.000 Konten ausschalten, um upstream 429 durch aktive Abfragen zu vermeiden." },
         "maxInflight": { "label": "Max. laufende Anfragen pro Konto", "desc": "Maximale Anzahl gleichzeitig laufender Anfragen pro Konto. Konten am Limit werden von der Auswahl übersprungen (für beide Modi gemeinsam)." },
-        "basicInterval": { "label": "Basic-Zyklus (s)", "desc": "Gemeinsamer Zyklus für den Basic-Pool: wird im Quota-Modus für den Hintergrund-Refresh und im Random-Modus für die 429-Abkühlung verwendet. Standardwert: 36000s." },
+        "basicInterval": { "label": "Basic-Zyklus (s)", "desc": "Gemeinsamer Zyklus für den Basic-Pool: wird im Quota-Modus für den Hintergrund-Refresh und im Random-Modus für die 429-Abkühlung verwendet. Standardwert: 86400s." },
         "superInterval": { "label": "Super-Zyklus (s)", "desc": "Gemeinsamer Zyklus für den Super-Pool: wird im Quota-Modus für den Hintergrund-Refresh und im Random-Modus für die 429-Abkühlung verwendet. Standardwert: 7200s." },
         "heavyInterval": { "label": "Heavy-Zyklus (s)", "desc": "Gemeinsamer Zyklus für den Heavy-Pool: wird im Quota-Modus für den Hintergrund-Refresh und im Random-Modus für die 429-Abkühlung verwendet. Standardwert: 7200s." },
         "usageConcurrency": { "label": "Aktualisierungs-Konkurrenz", "desc": "Maximale Anzahl paralleler usage-Aufrufe während der Quotenaktualisierung." },

app/statics/i18n/en.json

@@ -83,6 +83,8 @@
         "imageRequired": "Image edit requires at least one reference image",
         "imageOnly": "Image edit only supports image uploads",
         "videoImageOnly": "Video generation only supports image reference uploads",
+        "imageProxyRequired": "Image failed to load. Set APP Base URL and change image output format to local_url, local_md, or base64.",
+        "videoProxyRequired": "Video loading returned 403. Go to the admin page, set the APP Base URL, then change the video output format to local proxy mode (local_url or local_html) and retry.",
         "requestFailed": "Request failed",
         "initFailed": "Chat page initialization failed"
       }
@@ -183,6 +185,8 @@
     "batchNsfw": "Enable NSFW",
     "batchNsfwDisable": "Disable NSFW",
     "batchRefresh": "Refresh Selected",
+    "batchDisable": "Disable Selected",
+    "batchRestore": "Restore Selected",
     "batchDelete": "Delete Selected",
     "colToken": "Token",
     "colType": "Account Type",
@@ -265,6 +269,14 @@
     "restoreConfirmBody": "Restore {token}?<br><small style=\"color:var(--fg-muted)\">The account will be returned to request allocation.</small>",
     "restoringOne": "Restoring account…",
     "restoreDone": "Account restored",
+    "batchDisableConfirmTitle": "Disable Accounts",
+    "batchDisableConfirmBody": "Disable the selected <b>{n}</b> accounts?<br><small style=\"color:var(--fg-muted)\">Disabled accounts are removed from request allocation and can be restored later.</small>",
+    "disablingMany": "Disabling {n} accounts…",
+    "disableManyDone": "Disable completed: {ok} succeeded, {fail} failed",
+    "batchRestoreConfirmTitle": "Restore Accounts",
+    "batchRestoreConfirmBody": "Restore the selected <b>{n}</b> accounts?<br><small style=\"color:var(--fg-muted)\">Restored accounts will be returned to request allocation.</small>",
+    "restoringMany": "Restoring {n} accounts…",
+    "restoreManyDone": "Restore completed: {ok} succeeded, {fail} failed",
     "nsfwConfirmTitle": "Enable NSFW",
     "nsfwConfirmBody": "Enable NSFW for <b>{n}</b> selected accounts?",
     "nsfwEnablingOne": "Enabling NSFW…",
@@ -431,7 +443,11 @@
         },
         "imageFormat": {
           "label": "Image Output Format",
-          "desc": "grok_url and grok_md return the native Grok CDN address directly. local_* modes download assets to the server first and re-expose them through the local proxy. base64 returns an inline Data URI."
+          "desc": "grok_url and grok_md return the native Grok CDN address directly by default. local_* modes download assets to the server first and re-expose them through the local proxy. base64 returns an inline Data URI. When Imagine Public Image Proxy is enabled, imagine-public images returned by the WebSocket are also proxied locally."
+        },
+        "imaginePublicImageProxy": {
+          "label": "Imagine Public Image Proxy",
+          "desc": "When enabled, imagine-public images returned by the WebSocket are downloaded to the server and delivered through the local proxy. When disabled, public images are returned directly."
         },
         "videoFormat": {
           "label": "Video Output Format",
@@ -448,7 +464,7 @@
         },
         "basicInterval": {
           "label": "Basic Cycle (s)",
-          "desc": "Shared cycle for the basic pool: used for background refresh in quota mode and for 429 cooldown in random mode. Default 36000s."
+          "desc": "Shared cycle for the basic pool: used for background refresh in quota mode and for 429 cooldown in random mode. Default 86400s."
         },
         "superInterval": {
           "label": "Super Cycle (s)",

app/statics/i18n/es.json

@@ -64,6 +64,8 @@
         "imageRequired": "La edición de imagen requiere al menos una imagen de referencia",
         "imageOnly": "La edición de imagen solo admite cargas de imágenes",
         "videoImageOnly": "La generación de vídeo solo admite imágenes como referencia",
+        "imageProxyRequired": "No se pudo cargar la imagen. Configure la URL base de APP y cambie el formato de salida de imagen a local_url, local_md o base64.",
+        "videoProxyRequired": "La carga del vídeo devolvió 403. Vaya a la página de administración, configure la URL base de APP y cambie el formato de salida de vídeo al modo de proxy local (local_url o local_html). Después, inténtelo de nuevo.",
         "requestFailed": "La solicitud falló",
         "initFailed": "La inicialización de la página de chat falló"
       }
@@ -182,6 +184,8 @@
     "batchNsfw": "Activar NSFW",
     "batchNsfwDisable": "Desactivar NSFW",
     "batchRefresh": "Actualizar selección",
+    "batchDisable": "Desactivar selección",
+    "batchRestore": "Restaurar selección",
     "batchDelete": "Eliminar selección",
     "colToken": "Token",
     "colType": "Tipo de cuenta",
@@ -264,6 +268,14 @@
     "restoreConfirmBody": "¿Restaurar {token}?<br><small style=\"color:var(--fg-muted)\">La cuenta volverá a participar en la asignación de solicitudes.</small>",
     "restoringOne": "Restaurando cuenta…",
     "restoreDone": "Cuenta restaurada",
+    "batchDisableConfirmTitle": "Desactivar cuentas",
+    "batchDisableConfirmBody": "¿Desactivar las <b>{n}</b> cuentas seleccionadas?<br><small style=\"color:var(--fg-muted)\">Las cuentas desactivadas no participarán en la asignación de solicitudes y podrán restaurarse más tarde.</small>",
+    "disablingMany": "Desactivando {n} cuentas…",
+    "disableManyDone": "Desactivación completada: {ok} correctas, {fail} fallidas",
+    "batchRestoreConfirmTitle": "Restaurar cuentas",
+    "batchRestoreConfirmBody": "¿Restaurar las <b>{n}</b> cuentas seleccionadas?<br><small style=\"color:var(--fg-muted)\">Las cuentas restauradas volverán a participar en la asignación de solicitudes.</small>",
+    "restoringMany": "Restaurando {n} cuentas…",
+    "restoreManyDone": "Restauración completada: {ok} correctas, {fail} fallidas",
     "nsfwConfirmTitle": "Activar NSFW",
     "nsfwConfirmBody": "¿Activar NSFW para <b>{n}</b> cuentas seleccionadas?",
     "nsfwEnablingOne": "Activando NSFW…",
@@ -383,11 +395,12 @@
         "enableNsfw": { "label": "Permitir generación NSFW" },
         "showSearchSources": { "label": "Agregar fuentes al contenido", "desc": "Las fuentes de búsqueda siempre se incluyen en el campo search_sources. Esta opción controla si también se agrega una sección ## Sources al contenido (para compatibilidad con clientes que analizan texto)." },
         "customInstruction": { "label": "Instrucción suplementaria global" },
-        "imageFormat": { "label": "Formato de salida de imagen" },
+        "imageFormat": { "label": "Formato de salida de imagen", "desc": "grok_url y grok_md devuelven directamente la dirección nativa del CDN de Grok de forma predeterminada. Los modos local_* descargan primero los recursos en el servidor y los vuelven a exponer mediante el proxy local. base64 devuelve un Data URI integrado. Cuando el proxy de imágenes Imagine Public está activado, las imágenes imagine-public devueltas por WebSocket también se sirven mediante el proxy local." },
+        "imaginePublicImageProxy": { "label": "Proxy de imágenes Imagine Public", "desc": "Cuando está activado, las imágenes imagine-public devueltas por WebSocket se descargan en el servidor y se entregan mediante el proxy local. Cuando está desactivado, las imágenes públicas se devuelven directamente." },
         "videoFormat": { "label": "Formato de salida de video" },
         "refreshEnabled": { "label": "Activar actualización de cuota", "desc": "Al activarlo, el sistema cambia automáticamente al modo de actualización de cuota. Al desactivarlo, cambia automáticamente al modo de reintento automático.", "help": "Activado: modo de actualización de cuota. El scheduler sincroniza periódicamente la cuota real y la selección usa puntuación.\nDesactivado: modo de reintento automático. No comprueba upstream activamente, usa selección aleatoria y cambia de cuenta al fallar hasta 5 reintentos.\nRecomendación: desactívalo con más de 10.000 cuentas para evitar provocar 429 de upstream con comprobaciones activas." },
         "maxInflight": { "label": "Máximo en curso por cuenta", "desc": "Máximo de solicitudes simultáneas en curso por cuenta. Las cuentas en ese límite se omiten en la selección (compartido por ambos modos)." },
-        "basicInterval": { "label": "Ciclo Basic (s)", "desc": "Ciclo compartido del pool Basic: se usa para la actualización en segundo plano en modo quota y para el enfriamiento tras 429 en modo random. Valor por defecto: 36000s." },
+        "basicInterval": { "label": "Ciclo Basic (s)", "desc": "Ciclo compartido del pool Basic: se usa para la actualización en segundo plano en modo quota y para el enfriamiento tras 429 en modo random. Valor por defecto: 86400s." },
         "superInterval": { "label": "Ciclo Super (s)", "desc": "Ciclo compartido del pool Super: se usa para la actualización en segundo plano en modo quota y para el enfriamiento tras 429 en modo random. Valor por defecto: 7200s." },
         "heavyInterval": { "label": "Ciclo Heavy (s)", "desc": "Ciclo compartido del pool Heavy: se usa para la actualización en segundo plano en modo quota y para el enfriamiento tras 429 en modo random. Valor por defecto: 7200s." },
         "usageConcurrency": { "label": "Concurrencia de actualización", "desc": "Número máximo de llamadas usage paralelas permitidas durante la actualización de cuota." },

app/statics/i18n/fr.json

@@ -64,6 +64,8 @@
         "imageRequired": "L’édition d’image nécessite au moins une image de référence",
         "imageOnly": "L’édition d’image ne prend en charge que les téléversements d’images",
         "videoImageOnly": "La génération vidéo n’accepte que les images comme référence",
+        "imageProxyRequired": "Échec du chargement de l’image. Configurez l’URL de base APP et changez le format de sortie image en local_url, local_md ou base64.",
+        "videoProxyRequired": "Le chargement de la vidéo a renvoyé 403. Accédez à la page d’administration, configurez l’URL de base APP, puis passez le format de sortie vidéo en mode proxy local (local_url ou local_html) et réessayez.",
         "requestFailed": "Échec de la requête",
         "initFailed": "Échec de l’initialisation de la page de chat"
       }
@@ -182,6 +184,8 @@
     "batchNsfw": "Activer NSFW",
     "batchNsfwDisable": "Désactiver NSFW",
     "batchRefresh": "Actualiser la sélection",
+    "batchDisable": "Désactiver la sélection",
+    "batchRestore": "Restaurer la sélection",
     "batchDelete": "Supprimer la sélection",
     "colToken": "Token",
     "colType": "Type de compte",
@@ -264,6 +268,14 @@
     "restoreConfirmBody": "Restaurer {token} ?<br><small style=\"color:var(--fg-muted)\">Le compte reprendra la participation à l’allocation des requêtes.</small>",
     "restoringOne": "Restauration du compte…",
     "restoreDone": "Compte restauré",
+    "batchDisableConfirmTitle": "Désactiver les comptes",
+    "batchDisableConfirmBody": "Désactiver les <b>{n}</b> comptes sélectionnés ?<br><small style=\"color:var(--fg-muted)\">Les comptes désactivés ne participeront plus à l’allocation des requêtes et pourront être restaurés plus tard.</small>",
+    "disablingMany": "Désactivation de {n} comptes…",
+    "disableManyDone": "Désactivation terminée : {ok} réussies, {fail} échouées",
+    "batchRestoreConfirmTitle": "Restaurer les comptes",
+    "batchRestoreConfirmBody": "Restaurer les <b>{n}</b> comptes sélectionnés ?<br><small style=\"color:var(--fg-muted)\">Les comptes restaurés participeront de nouveau à l’allocation des requêtes.</small>",
+    "restoringMany": "Restauration de {n} comptes…",
+    "restoreManyDone": "Restauration terminée : {ok} réussies, {fail} échouées",
     "nsfwConfirmTitle": "Activer NSFW",
     "nsfwConfirmBody": "Activer NSFW pour <b>{n}</b> comptes sélectionnés ?",
     "nsfwEnablingOne": "Activation de NSFW…",
@@ -383,11 +395,12 @@
         "enableNsfw": { "label": "Autoriser la génération NSFW" },
         "showSearchSources": { "label": "Ajouter les sources au contenu", "desc": "Les sources de recherche sont toujours présentes dans le champ search_sources. Cette option contrôle si une section ## Sources est également ajoutée au contenu (pour la compatibilité avec les clients analysant le texte)." },
         "customInstruction": { "label": "Instruction globale supplémentaire" },
-        "imageFormat": { "label": "Format de sortie image" },
+        "imageFormat": { "label": "Format de sortie image", "desc": "grok_url et grok_md renvoient directement l’adresse CDN native de Grok par défaut. Les modes local_* téléchargent d’abord les ressources sur le serveur puis les redistribuent via le proxy local. base64 renvoie une Data URI intégrée. Lorsque le proxy d’images Imagine Public est activé, les images imagine-public renvoyées par le WebSocket sont également servies via le proxy local." },
+        "imaginePublicImageProxy": { "label": "Proxy d’images Imagine Public", "desc": "Lorsque cette option est activée, les images imagine-public renvoyées par le WebSocket sont téléchargées sur le serveur puis distribuées via le proxy local. Lorsqu’elle est désactivée, les images publiques sont renvoyées directement." },
         "videoFormat": { "label": "Format de sortie vidéo" },
         "refreshEnabled": { "label": "Activer l’actualisation du quota", "desc": "Lorsqu’il est activé, le système passe automatiquement en mode d’actualisation du quota. Lorsqu’il est désactivé, il passe automatiquement en mode de relance automatique.", "help": "Activé : mode d’actualisation du quota. Le scheduler synchronise périodiquement le quota réel et la sélection utilise un score.\nDésactivé : mode de relance automatique. Aucune sonde upstream active, sélection aléatoire et changement automatique de compte en cas d’erreur jusqu’à 5 relances.\nRecommandation : désactivez-le au-delà de 10 000 comptes pour éviter de déclencher des 429 upstream par les sondes actives." },
         "maxInflight": { "label": "Maximum en cours par compte", "desc": "Nombre maximal de requêtes simultanées par compte. Les comptes à cette limite sont ignorés par la sélection (partagé par les deux modes)." },
-        "basicInterval": { "label": "Cycle Basic (s)", "desc": "Cycle partagé du pool Basic : utilisé pour l’actualisation en arrière-plan en mode quota et pour le refroidissement après 429 en mode random. Valeur par défaut : 36000s." },
+        "basicInterval": { "label": "Cycle Basic (s)", "desc": "Cycle partagé du pool Basic : utilisé pour l’actualisation en arrière-plan en mode quota et pour le refroidissement après 429 en mode random. Valeur par défaut : 86400s." },
         "superInterval": { "label": "Cycle Super (s)", "desc": "Cycle partagé du pool Super : utilisé pour l’actualisation en arrière-plan en mode quota et pour le refroidissement après 429 en mode random. Valeur par défaut : 7200s." },
         "heavyInterval": { "label": "Cycle Heavy (s)", "desc": "Cycle partagé du pool Heavy : utilisé pour l’actualisation en arrière-plan en mode quota et pour le refroidissement après 429 en mode random. Valeur par défaut : 7200s." },
         "usageConcurrency": { "label": "Concurrence d’actualisation", "desc": "Nombre maximal d’appels usage parallèles autorisés pendant l’actualisation du quota." },

app/statics/i18n/ja.json

@@ -64,6 +64,8 @@
         "imageRequired": "画像編集には少なくとも 1 枚の参照画像が必要です",
         "imageOnly": "画像編集では画像ファイルのみアップロードできます",
         "videoImageOnly": "動画生成では参照として画像のみアップロードできます",
+        "imageProxyRequired": "画像を読み込めませんでした。APP ベース URL を設定し、画像の返却形式を local_url、local_md、または base64 に変更してください。",
+        "videoProxyRequired": "動画の読み込みで 403 が返されました。管理ページで APP ベース URL を設定し、動画の返却形式をローカルプロキシモード（local_url または local_html）に変更してから再試行してください。",
         "requestFailed": "リクエストに失敗しました",
         "initFailed": "チャットページの初期化に失敗しました"
       }
@@ -182,6 +184,8 @@
     "batchNsfw": "NSFW を有効化",
     "batchNsfwDisable": "NSFW を無効化",
     "batchRefresh": "選択項目を更新",
+    "batchDisable": "選択項目を無効化",
+    "batchRestore": "選択項目を復元",
     "batchDelete": "選択項目を削除",
     "colToken": "トークン",
     "colType": "アカウント種別",
@@ -264,6 +268,14 @@
     "restoreConfirmBody": "{token} を復元しますか？<br><small style=\"color:var(--fg-muted)\">復元後、このアカウントは再びリクエスト割り当てに参加します。</small>",
     "restoringOne": "アカウントを復元しています…",
     "restoreDone": "アカウントを復元しました",
+    "batchDisableConfirmTitle": "アカウントを一括無効化",
+    "batchDisableConfirmBody": "選択した <b>{n}</b> 件のアカウントを無効化しますか？<br><small style=\"color:var(--fg-muted)\">無効化されたアカウントはリクエスト割り当てに参加せず、後で復元できます。</small>",
+    "disablingMany": "{n} 件のアカウントを無効化しています…",
+    "disableManyDone": "無効化完了: 成功 {ok} 件、失敗 {fail} 件",
+    "batchRestoreConfirmTitle": "アカウントを一括復元",
+    "batchRestoreConfirmBody": "選択した <b>{n}</b> 件のアカウントを復元しますか？<br><small style=\"color:var(--fg-muted)\">復元後、これらのアカウントは再びリクエスト割り当てに参加します。</small>",
+    "restoringMany": "{n} 件のアカウントを復元しています…",
+    "restoreManyDone": "復元完了: 成功 {ok} 件、失敗 {fail} 件",
     "nsfwConfirmTitle": "NSFW を有効化",
     "nsfwConfirmBody": "選択した <b>{n}</b> 件のアカウントで NSFW を有効にしますか？",
     "nsfwEnablingOne": "NSFW を有効化しています…",
@@ -383,11 +395,12 @@
         "enableNsfw": { "label": "NSFW 生成を許可" },
         "showSearchSources": { "label": "コンテンツにソースを追加", "desc": "検索ソースは常に search_sources フィールドに出力されます。このオプションは、テキスト解析クライアントとの互換性のために ## Sources セクションをコンテンツに追加するかどうかを制御します。" },
         "customInstruction": { "label": "グローバル補助指示" },
-        "imageFormat": { "label": "画像出力形式" },
+        "imageFormat": { "label": "画像出力形式", "desc": "grok_url と grok_md は既定では Grok CDN のネイティブ URL を直接返します。local_* モードでは、先にサーバーへダウンロードしてからローカルプロキシ経由で再配信します。base64 は埋め込み Data URI を返します。Imagine Public 画像プロキシを有効にすると、WebSocket が返す imagine-public 画像もローカルプロキシ経由になります。" },
+        "imaginePublicImageProxy": { "label": "Imagine Public 画像プロキシ", "desc": "有効にすると、WebSocket が返す imagine-public 画像をサーバーにダウンロードし、ローカルプロキシ経由で配信します。無効の場合、公開画像はそのまま返します。" },
         "videoFormat": { "label": "動画出力形式" },
         "refreshEnabled": { "label": "クォータ更新を有効化", "desc": "オンにすると自動的にクォータ更新モードへ切り替わり、オフにすると自動的に自動再試行モードへ切り替わります。", "help": "オン：クォータ更新モード。scheduler が実クォータを定期同期し、スコアでアカウントを選択します。\nオフ：自動再試行モード。upstream を能動的に確認せず、ランダム選択し、エラー時は最大 5 回まで別アカウントへ自動切替します。\n推奨：1 万件以上のアカウントではオフにして、能動確認による upstream 429 を避けてください。" },
         "maxInflight": { "label": "アカウントごとの同時実行上限", "desc": "1 アカウント��同時に処理中にできるリクエスト数の上限です。上限に達したアカウントは選択時にスキップされます（両モード共通）。" },
-        "basicInterval": { "label": "Basic 周期（秒）", "desc": "Basic プールの共通周期です。quota モードではバックグラウンド更新に、random モードでは 429 クールダウンに使われます。既定値は 36000s です。" },
+        "basicInterval": { "label": "Basic 周期（秒）", "desc": "Basic プールの共通周期です。quota モードではバックグラウンド更新に、random モードでは 429 クールダウンに使われます。既定値は 86400s です。" },
         "superInterval": { "label": "Super 周期（秒）", "desc": "Super プールの共通周期です。quota モードではバックグラウンド更新に、random モードでは 429 クールダウンに使われます。既定値は 7200s です。" },
         "heavyInterval": { "label": "Heavy 周期（秒）", "desc": "Heavy プールの共通周期です。quota モードではバックグラウンド更新に、random モードでは 429 クールダウンに使われます。既定値は 7200s です。" },
         "usageConcurrency": { "label": "更新並列数", "desc": "クォータ更新中に許可する usage 呼び出しの最大並列数です。" },

app/statics/i18n/zh.json

@@ -83,6 +83,8 @@
         "imageRequired": "图像编辑至少需要上传一张参考图",
         "imageOnly": "图像编辑只支持上传图片",
         "videoImageOnly": "视频生成只支持上传图片作为参考图",
+        "imageProxyRequired": "图片加载失败。请先设置 APP 访问地址，并将图片返回格式改为 local_url、local_md 或 base64。",
+        "videoProxyRequired": "视频加载 403，请前往管理页面设置 APP 访问地址后，将频返回格式改为本地代理（ local_url 或 local_html）模式后重试。",
         "requestFailed": "请求失败",
         "initFailed": "聊天页面初始化失败"
       }
@@ -183,6 +185,8 @@
     "batchNsfw": "开启 NSFW",
     "batchNsfwDisable": "关闭 NSFW",
     "batchRefresh": "刷新选中",
+    "batchDisable": "禁用选中",
+    "batchRestore": "恢复选中",
     "batchDelete": "删除选中",
     "colToken": "Token",
     "colType": "账户类型",
@@ -265,6 +269,14 @@
     "restoreConfirmBody": "确认恢复 {token}？<br><small style=\"color:var(--fg-muted)\">恢复后该账号将重新参与请求分配。</small>",
     "restoringOne": "正在恢复账号…",
     "restoreDone": "账号已恢复",
+    "batchDisableConfirmTitle": "批量禁用账号",
+    "batchDisableConfirmBody": "确认禁用选中的 <b>{n}</b> 个账户？<br><small style=\"color:var(--fg-muted)\">禁用后这些账号不会参与请求分配，但可随时恢复。</small>",
+    "disablingMany": "正在禁用 {n} 个账户…",
+    "disableManyDone": "禁用完成：成功 {ok} 个，失败 {fail} 个",
+    "batchRestoreConfirmTitle": "批量恢复账号",
+    "batchRestoreConfirmBody": "确认恢复选中的 <b>{n}</b> 个账户？<br><small style=\"color:var(--fg-muted)\">恢复后这些账号将重新参与请求分配。</small>",
+    "restoringMany": "正在恢复 {n} 个账户…",
+    "restoreManyDone": "恢复完成：成功 {ok} 个，失败 {fail} 个",
     "nsfwConfirmTitle": "启用 NSFW",
     "nsfwConfirmBody": "确认为选中的 <b>{n}</b> 个账户启用 NSFW？",
     "nsfwEnablingOne": "正在启用 NSFW…",
@@ -431,7 +443,11 @@
         },
         "imageFormat": {
           "label": "图片返回格式",
-          "desc": "grok_url / grok_md 直接返回 Grok CDN 地址，客户端需具备 CDN 访问能力；local_* 模式会先下载到服务端，再通过本地 URL 代理分发；base64 会以内嵌 Data URI 返回。"
+          "desc": "grok_url / grok_md 默认直接返回 Grok CDN 地址；local_* 模式会先下载到服务端，再通过本地 URL 代理分发；base64 会以内嵌 Data URI 返回。开启 Imagine Public 图片代理后，WebSocket 返回的 imagine-public 图片也会本地代理。"
+        },
+        "imaginePublicImageProxy": {
+          "label": "Imagine Public 图片代理",
+          "desc": "开启后将 WebSocket 返回的 imagine-public 图片下载到服务端，再通过本地 URL 代理分发；关闭时保持公开图片直返。"
         },
         "videoFormat": {
           "label": "视频返回格式",
@@ -448,7 +464,7 @@
         },
         "basicInterval": {
           "label": "Basic 周期（秒）",
-          "desc": "basic 号池共用周期：quota 模式下用于后台刷新，random 模式下用于 429 冷却。默认 36000s。"
+          "desc": "basic 号池共用周期：quota 模式下用于后台刷新，random 模式下用于 429 冷却。默认 86400s。"
         },
         "superInterval": {
           "label": "Super 周期（秒）",

app/statics/js/webui/chat.js

@@ -2,7 +2,7 @@
   const VERIFY_ENDPOINT = '/webui/api/verify';
   const MODELS_ENDPOINT = '/webui/api/models';
   const CHAT_ENDPOINT = '/webui/api/chat/completions';
-  const PREFERRED_MODEL = 'grok-4.20-0309';
+  const PREFERRED_MODEL = 'grok-4.20-0309-non-reasoning';
   const STORE_KEY = 'grok2api_webui_chat_sessions_v1';
   const SIDEBAR_STORE_KEY = 'grok2api_webui_sidebar_collapsed_v1';
 
@@ -316,6 +316,64 @@
     });
   }
 
+  function isNativeGrokMediaUrl(value) {
+    try {
+      const url = new URL(value, window.location.origin);
+      return /(^|\.)grok\.com$/i.test(url.hostname);
+    } catch {
+      return false;
+    }
+  }
+
+  function showMediaProxyHint(media, type) {
+    if (!media || media.nextElementSibling?.classList?.contains('msg-media-error')) return;
+    const hint = document.createElement('div');
+    hint.className = 'msg-media-error';
+    if (type === 'image') {
+      hint.textContent = text(
+        'webui.chat.errors.imageProxyRequired',
+        'Image failed to load. Set APP Base URL and change image output format to local_url, local_md, or base64.'
+      );
+    } else {
+      hint.textContent = text(
+        'webui.chat.errors.videoProxyRequired',
+        'Video loading returned 403. Go to the admin page, set the APP Base URL, then change the video output format to local proxy mode (local_url or local_html) and retry.'
+      );
+    }
+    media.insertAdjacentElement('afterend', hint);
+  }
+
+  function clearMediaProxyHint(media) {
+    const hint = media && media.nextElementSibling;
+    if (hint?.classList?.contains('msg-media-error')) hint.remove();
+  }
+
+  function enhanceMediaElements(card) {
+    card.querySelectorAll('video').forEach((video) => {
+      if (video.dataset.proxyHintBound === '1') return;
+      video.dataset.proxyHintBound = '1';
+      const onVideoError = () => showMediaProxyHint(video, 'video');
+      video.addEventListener('error', onVideoError);
+      video.querySelectorAll('source').forEach((source) => {
+        source.addEventListener('error', onVideoError);
+      });
+      video.addEventListener('loadedmetadata', () => clearMediaProxyHint(video));
+      if (video.error) showMediaProxyHint(video, 'video');
+    });
+
+    card.querySelectorAll('img').forEach((img) => {
+      if (img.dataset.proxyHintBound === '1') return;
+      img.dataset.proxyHintBound = '1';
+      img.addEventListener('error', () => {
+        if (isNativeGrokMediaUrl(img.currentSrc || img.src)) showMediaProxyHint(img, 'image');
+      });
+      img.addEventListener('load', () => clearMediaProxyHint(img));
+      if (img.complete && img.naturalWidth === 0 && isNativeGrokMediaUrl(img.currentSrc || img.src)) {
+        showMediaProxyHint(img, 'image');
+      }
+    });
+  }
+
   function extractTextContent(content) {
     if (typeof content === 'string') return content;
     if (!Array.isArray(content)) return '';
@@ -461,6 +519,7 @@
           )).join(''));
         }
         card.innerHTML = parts.join('') || '<p></p>';
+        enhanceMediaElements(card);
         return;
       }
 
@@ -501,6 +560,7 @@
 
     if (role === 'assistant') {
       card.innerHTML = renderRichMarkdown(content);
+      enhanceMediaElements(card);
       return;
     }
     card.textContent = content;

config.defaults.toml

@@ -51,6 +51,8 @@ custom_instruction = ""
 #   local_md  — Markdown 内嵌本地代理 URL
 #   base64    — Markdown 内嵌 Base64 Data URI
 image_format = "grok_url"
+# Imagine WebSocket 返回的 imagine-public 图片默认直返；开启后下载到本地并返回本地代理 URL
+imagine_public_image_proxy = false
 
 # 视频返回格式
 #   grok_url  — 直接返回 Grok CDN URL
@@ -113,7 +115,7 @@ on_codes = "429,401,503"
 [account.refresh]
 # 总开关：true=配额刷新模式（主动探测，选号评分）；false=自动重试模式（随机选号，零探测）
 enabled = true
-basic_interval_sec = 36000   # basic 号池周期（秒）：quota 模式用于后台刷新，random 模式用于 429 冷却；默认 36000s
+basic_interval_sec = 86400   # basic 号池周期（秒）：quota 模式用于后台刷新，random 模式用于 429 冷却；默认 86400s
 super_interval_sec = 7200    # super 号池周期（秒）：quota 模式用于后台刷新，random 模式用于 429 冷却；默认 7200s
 heavy_interval_sec = 7200    # heavy 号池周期（秒）：quota 模式用于后台刷新，random 模式用于 429 冷却；默认 7200s
 usage_concurrency = 50