feat: 大规模性能优化与功能增强

### 新增功能

1. 自定义思考预算：支持 reasoning_effort 参数 (low:1024/medium:16000/high:32000) 和 thinking_budget 参数 (1024-32000)

2. 适配 DeepSeek 思考格式：reasoning_content 字段单独输出，避免思维链混在 content 中

3. 资格校验自动回退：无资格时自动生成随机 ProjectId，避免添加 Token 失败

4. 真 System 消息支持：开头连续多条 system 与 SystemInstruction 合并

5. 三种轮询策略：round_robin / quota_exhausted / request_count

6. 心跳机制：SSE 心跳防止 Cloudflare 等 CDN 超时断连

7. 模型缓存：自动缓存模型列表和额度，减少 API 请求频率

### 前端优化

- 重构 Web 管理界面，优化 PC 体验

- 隐私模式：默认隐藏敏感信息（Token、ProjectId 等）

- 新增设置项：思考预算、图片地址、轮询策略、内存阈值、心跳间隔、字体大小

- 采用 MiSans + Ubuntu Mono 字体，增强可读性

### 性能优化

- 内存占用：从 100MB+ 降至 50MB+，进程数从 8+ 减少为 2 个

- 对象池复用：减少 50%+ 临时对象创建，降低 GC 频率

- 预编译常量：正则表达式、格式字符串等预编译

- LineBuffer 优化：高效流式行分割

- 自动内存清理：堆内存超阈值时自动触发 GC

### Bug 修复

- Token 刷新失败时返回 400 而非 401，避免触发 JWT 登出

- 修复流式响应内存泄漏问题

.env.example

@@ -5,6 +5,6 @@ ADMIN_PASSWORD=admin123
 JWT_SECRET=your-jwt-secret-key-change-this-in-production
 
 # 可选配置
-# PROXY=http://127.0.0.1:7897
+# PROXY=http://127.0.0.1:7890
 SYSTEM_INSTRUCTION=你是聊天机器人，名字叫萌萌，如同名字这般，你的性格是软软糯糯萌萌哒的，专门为用户提供聊天和情绪价值，协助进行小说创作或者角色扮演
 # IMAGE_BASE_URL=http://your-domain.com

API.md

@@ -12,6 +12,18 @@ Authorization: Bearer YOUR_API_KEY
 
 默认服务地址：`http://localhost:8045`
 
+## 目录
+
+- [获取模型列表](#获取模型列表)
+- [聊天补全](#聊天补全)
+- [工具调用](#工具调用function-calling)
+- [图片输入](#图片输入多模态)
+- [图片生成](#图片生成)
+- [思维链模型](#思维链模型)
+- [SD WebUI 兼容 API](#sd-webui-兼容-api)
+- [管理 API](#管理-api)
+- [使用示例](#使用示例)
+
 ## 获取模型列表
 
 ```bash
@@ -19,6 +31,8 @@ curl http://localhost:8045/v1/models \
   -H "Authorization: Bearer sk-text"
 ```
 
+**说明**：模型列表会缓存 1 小时（可通过 `config.json` 的 `cache.modelListTTL` 配置），减少 API 请求。
+
 ## 聊天补全
 
 ### 流式响应
@@ -108,19 +122,35 @@ curl http://localhost:8045/v1/chat/completions \
 
 ## 图片生成
 
-支持使用 大/小香蕉 模型生成图片，生成的图片会以 Markdown 格式返回：
+支持使用 `gemini-3-pro-image` 模型生成图片，生成的图片会以 Markdown 格式返回：
 
 ```bash
 curl http://localhost:8045/v1/chat/completions \
   -H "Content-Type: application/json" \
   -H "Authorization: Bearer sk-text" \
   -d '{
-    "model": "gemimi-3.0-pro-image",
+    "model": "gemini-3-pro-image",
     "messages": [{"role": "user", "content": "画一只可爱的猫"}],
     "stream": false
   }'
 ```
 
+**响应示例**：
+```json
+{
+  "choices": [{
+    "message": {
+      "role": "assistant",
+      "content": "![image](http://localhost:8045/images/abc123.png)"
+    }
+  }]
+}
+```
+
+**注意**：
+- 生成的图片会保存到 `public/images/` 目录
+- 需要配置 `IMAGE_BASE_URL` 环境变量以返回正确的图片 URL
+
 ## 请求参数说明
 
 | 参数 | 类型 | 必填 | 说明 |
@@ -129,9 +159,11 @@ curl http://localhost:8045/v1/chat/completions \
 | `messages` | array | ✅ | 对话消息列表 |
 | `stream` | boolean | ❌ | 是否流式响应，默认 false |
 | `temperature` | number | ❌ | 温度参数，默认 1 |
-| `top_p` | number | ❌ | Top P 参数，默认 0.85 |
+| `top_p` | number | ❌ | Top P 参数，默认 1 |
 | `top_k` | number | ❌ | Top K 参数，默认 50 |
-| `max_tokens` | number | ❌ | 最大 token 数，默认 8096 |
+| `max_tokens` | number | ❌ | 最大 token 数，默认 32000 |
+| `thinking_budget` | number | ❌ | 思考预算（仅对思考模型生效），范围 1024-32000，默认 16000 |
+| `reasoning_effort` | string | ❌ | 思维链强度（OpenAI 格式），可选值：`low`(1024)、`medium`(16000)、`high`(32000) |
 | `tools` | array | ❌ | 工具列表（Function Calling） |
 
 ## 响应格式
@@ -194,6 +226,227 @@ API 返回标准的 HTTP 状态码：
 }
 ```
 
+## 思维链模型
+
+对于支持思维链的模型（如 `gemini-2.5-pro`、`claude-opus-4-5-thinking` 等），可以通过以下参数控制推理深度：
+
+### 使用 reasoning_effort（OpenAI 兼容格式）
+
+```bash
+curl http://localhost:8045/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer sk-text" \
+  -d '{
+    "model": "gemini-2.5-pro",
+    "messages": [{"role": "user", "content": "解释量子纠缠"}],
+    "stream": true,
+    "reasoning_effort": "high"
+  }'
+```
+
+| reasoning_effort | thinking_budget | 说明 |
+|-----------------|-----------------|------|
+| `low` | 1024 | 快速响应，适合简单问题 |
+| `medium` | 16000 | 平衡模式（默认） |
+| `high` | 32000 | 深度思考，适合复杂推理 |
+
+### 使用 thinking_budget（直接数值）
+
+```bash
+curl http://localhost:8045/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer sk-text" \
+  -d '{
+    "model": "gemini-2.5-pro",
+    "messages": [{"role": "user", "content": "证明勾股定理"}],
+    "stream": true,
+    "thinking_budget": 24000
+  }'
+```
+
+### 思维链响应格式
+
+思维链内容通过 `reasoning_content` 字段输出（兼容 DeepSeek 格式）：
+
+**非流式响应**：
+```json
+{
+  "choices": [{
+    "message": {
+      "role": "assistant",
+      "reasoning_content": "让我思考一下这个问题...",
+      "content": "量子纠缠是..."
+    }
+  }]
+}
+```
+
+**流式响应**：
+```
+data: {"choices":[{"delta":{"reasoning_content":"让我"}}]}
+data: {"choices":[{"delta":{"reasoning_content":"思考..."}}]}
+data: {"choices":[{"delta":{"content":"量子纠缠是..."}}]}
+```
+
+### 支持思维链的模型
+
+- `gemini-2.5-pro`
+- `gemini-2.5-flash-thinking`
+- `gemini-3-pro-high`
+- `gemini-3-pro-low`
+- `claude-opus-4-5-thinking`
+- `claude-sonnet-4-5-thinking`
+- `rev19-uic3-1p`
+- `gpt-oss-120b-medium`
+
+## SD WebUI 兼容 API
+
+本服务提供与 Stable Diffusion WebUI 兼容的 API 接口，可用于与支持 SD WebUI API 的客户端集成。
+
+### 文本生成图片
+
+```bash
+curl http://localhost:8045/sdapi/v1/txt2img \
+  -H "Content-Type: application/json" \
+  -d '{
+    "prompt": "a cute cat, high quality, detailed",
+    "negative_prompt": "",
+    "steps": 20,
+    "width": 512,
+    "height": 512
+  }'
+```
+
+### 图片生成图片
+
+```bash
+curl http://localhost:8045/sdapi/v1/img2img \
+  -H "Content-Type: application/json" \
+  -d '{
+    "prompt": "enhance this image, high quality",
+    "init_images": ["BASE64_ENCODED_IMAGE"],
+    "steps": 20
+  }'
+```
+
+### 其他 SD API 端点
+
+| 端点 | 说明 |
+|------|------|
+| `GET /sdapi/v1/sd-models` | 获取可用的图片生成模型 |
+| `GET /sdapi/v1/options` | 获取当前选项 |
+| `GET /sdapi/v1/samplers` | 获取可用的采样器 |
+| `GET /sdapi/v1/upscalers` | 获取可用的放大器 |
+| `GET /sdapi/v1/progress` | 获取生成进度 |
+
+## 管理 API
+
+管理 API 需要 JWT 认证，先通过登录接口获取 token。
+
+### 登录
+
+```bash
+curl http://localhost:8045/admin/login \
+  -H "Content-Type: application/json" \
+  -d '{
+    "username": "admin",
+    "password": "admin123"
+  }'
+```
+
+### Token 管理
+
+```bash
+# 获取 Token 列表
+curl http://localhost:8045/admin/tokens \
+  -H "Authorization: Bearer JWT_TOKEN"
+
+# 添加 Token
+curl http://localhost:8045/admin/tokens \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer JWT_TOKEN" \
+  -d '{
+    "access_token": "ya29.xxx",
+    "refresh_token": "1//xxx",
+    "expires_in": 3599
+  }'
+
+# 删除 Token
+curl -X DELETE http://localhost:8045/admin/tokens/REFRESH_TOKEN \
+  -H "Authorization: Bearer JWT_TOKEN"
+```
+
+### 查看模型额度
+
+```bash
+# 获取指定 Token 的模型额度
+curl http://localhost:8045/admin/tokens/REFRESH_TOKEN/quotas \
+  -H "Authorization: Bearer JWT_TOKEN"
+
+# 强制刷新额度数据
+curl "http://localhost:8045/admin/tokens/REFRESH_TOKEN/quotas?refresh=true" \
+  -H "Authorization: Bearer JWT_TOKEN"
+```
+
+**响应示例**：
+```json
+{
+  "success": true,
+  "data": {
+    "lastUpdated": 1702700000000,
+    "models": {
+      "gemini-2.5-pro": {
+        "remaining": 0.85,
+        "resetTime": "12-16 20:00",
+        "resetTimeRaw": "2024-12-16T12:00:00Z"
+      }
+    }
+  }
+}
+```
+
+### 轮询策略配置
+
+```bash
+# 获取当前轮询配置
+curl http://localhost:8045/admin/rotation \
+  -H "Authorization: Bearer JWT_TOKEN"
+
+# 更新轮询策略
+curl -X PUT http://localhost:8045/admin/rotation \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer JWT_TOKEN" \
+  -d '{
+    "strategy": "request_count",
+    "requestCount": 20
+  }'
+```
+
+**可用策略**：
+- `round_robin`：每次请求切换 Token
+- `quota_exhausted`：额度耗尽才切换
+- `request_count`：自定义请求次数后切换
+
+### 配置管理
+
+```bash
+# 获取配置
+curl http://localhost:8045/admin/config \
+  -H "Authorization: Bearer JWT_TOKEN"
+
+# 更新配置
+curl -X PUT http://localhost:8045/admin/config \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer JWT_TOKEN" \
+  -d '{
+    "json": {
+      "defaults": {
+        "temperature": 0.7
+      }
+    }
+  }'
+```
+
 ## 使用示例
 
 ### Python
@@ -237,8 +490,11 @@ for await (const chunk of stream) {
 
 ## 注意事项
 
-1. 所有请求必须携带有效的 API Key
-2. 图片输入需要使用 Base64 编码
-3. 流式响应使用 Server-Sent Events (SSE) 格式
-4. 工具调用需要模型支持 Function Calling
-5. 图片生成仅支持特定模型（大/小香蕉）
+1. 所有 `/v1/*` 请求必须携带有效的 API Key
+2. 管理 API (`/admin/*`) 需要 JWT 认证
+3. 图片输入需要使用 Base64 编码
+4. 流式响应使用 Server-Sent Events (SSE) 格式，包含心跳机制防止超时
+5. 工具调用需要模型支持 Function Calling
+6. 图片生成仅支持 `gemini-3-pro-image` 模型
+7. 模型列表会缓存 1 小时，可通过配置调整
+8. 思维链内容通过 `reasoning_content` 字段输出（兼容 DeepSeek 格式）

README.md

@@ -7,13 +7,22 @@
 - ✅ OpenAI API 兼容格式
 - ✅ 流式和非流式响应
 - ✅ 工具调用（Function Calling）支持
-- ✅ 多账号自动轮换
+- ✅ 多账号自动轮换（支持多种轮询策略）
 - ✅ Token 自动刷新
 - ✅ API Key 认证
-- ✅ 思维链（Thinking）输出
+- ✅ 思维链（Thinking）输出，兼容 OpenAI reasoning_effort 参数和 DeepSeek reasoning_content 格式
 - ✅ 图片输入支持（Base64 编码）
-- ✅ 图片生成支持（大/小香蕉 模型）
+- ✅ 图片生成支持（gemini-3-pro-image 模型）
 - ✅ Pro 账号随机 ProjectId 支持
+- ✅ 模型额度查看（实时显示剩余额度和重置时间）
+- ✅ SD WebUI API 兼容（支持 txt2img/img2img）
+- ✅ 心跳机制（防止 Cloudflare 超时断连）
+- ✅ 模型列表缓存（减少 API 请求）
+- ✅ 资格校验自动回退（无资格时自动生成随机 ProjectId）
+- ✅ 真 System 消息合并（开头连续多条 system 与 SystemInstruction 合并）
+- ✅ 隐私模式（自动隐藏敏感信息）
+- ✅ 内存优化（从 8+ 进程减少为 2 个进程，内存占用从 100MB+ 降为 50MB+）
+- ✅ 对象池复用（减少 50%+ 临时对象创建，降低 GC 频率）
 
 ## 环境要求
 
@@ -45,7 +54,7 @@ ADMIN_PASSWORD=admin123
 JWT_SECRET=your-jwt-secret-key-change-this-in-production
 
 # 可选配置
-# PROXY=http://127.0.0.1:7897
+# PROXY=http://127.0.0.1:7890
 # SYSTEM_INSTRUCTION=你是聊天机器人
 # IMAGE_BASE_URL=http://your-domain.com
 ```
@@ -246,17 +255,38 @@ ghcr.io/liuw1535/antigravity2api-nodejs
    - 使用「删除」按钮移除无效 Token
    - 点击「刷新」按钮更新列表
 
-4. **修改配置**
+4. **隐私模式**
+   - 默认开启，自动隐藏 Token、Project ID 等敏感信息
+   - 点击「显示敏感信息」切换显示/隐藏状态
+   - 支持逐个查看或批量显示
+
+5. **配置轮询策略**
+   - 支持三种轮询策略：
+     - `round_robin`：均衡负载，每次请求切换 Token
+     - `quota_exhausted`：额度耗尽才切换
+     - `request_count`：自定义请求次数后切换
+   - 可在「设置」页面配置
+
+6. **修改配置**
    - 切换到「设置」标签页
    - 修改需要调整的配置项
    - 点击「保存配置」按钮应用更改
    - 注意：端口和监听地址修改需要重启服务
+   - 支持的设置项：
+     - 编辑 Token 信息（Access Token、Refresh Token）
+     - 思考预算（1024-32000）
+     - 图片访问地址
+     - 轮询策略
+     - 内存阈值
+     - 心跳间隔
+     - 字体大小
 
 ### 界面预览
 
 - **Token 管理页面**：卡片式展示所有 Token，支持快速操作
 - **设置页面**：分类展示所有配置项，支持在线编辑
 - **响应式设计**：支持桌面和移动设备访问
+- **字体优化**：采用 MiSans + Ubuntu Mono 字体，增强可读性
 
 ## API 使用
 
@@ -314,21 +344,40 @@ curl http://localhost:8045/v1/chat/completions \
   "server": {
     "port": 8045,              // 服务端口
     "host": "0.0.0.0",         // 监听地址
-    "maxRequestSize": "500mb"  // 最大请求体大小
+    "maxRequestSize": "500mb", // 最大请求体大小
+    "heartbeatInterval": 15000,// 心跳间隔（毫秒），防止 Cloudflare 超时
+    "memoryThreshold": 100     // 内存阈值（MB），超过时触发 GC
+  },
+  "rotation": {
+    "strategy": "round_robin", // 轮询策略：round_robin/quota_exhausted/request_count
+    "requestCount": 50         // request_count 策略下每个 Token 的请求次数
   },
   "defaults": {
     "temperature": 1,          // 默认温度参数
-    "topP": 0.85,              // 默认 top_p
+    "topP": 1,                 // 默认 top_p
     "topK": 50,                // 默认 top_k
-    "maxTokens": 8096          // 默认最大 token 数
+    "maxTokens": 32000,        // 默认最大 token 数
+    "thinkingBudget": 16000    // 默认思考预算（仅对思考模型生效，范围 1024-32000）
+  },
+  "cache": {
+    "modelListTTL": 3600000    // 模型列表缓存时间（毫秒），默认 1 小时
   },
   "other": {
-    "timeout": 180000,         // 请求超时时间（毫秒）
-    "skipProjectIdFetch": true // 跳过 ProjectId 获取，直接随机生成
+    "timeout": 300000,         // 请求超时时间（毫秒）
+    "skipProjectIdFetch": false,// 跳过 ProjectId 获取，直接随机生成（仅 Pro 账号有效）
+    "useNativeAxios": false    // 使用原生 axios 而非 AntigravityRequester
   }
 }
 ```
 
+### 轮询策略说明
+
+| 策略 | 说明 |
+|------|------|
+| `round_robin` | 均衡负载：每次请求后切换到下一个 Token |
+| `quota_exhausted` | 额度耗尽才切换：持续使用当前 Token 直到额度用完 |
+| `request_count` | 自定义次数：每个 Token 使用指定次数后切换 |
+
 ### 2. .env（敏感配置）
 
 环境变量配置文件，包含敏感信息和可选配置：
@@ -339,7 +388,8 @@ curl http://localhost:8045/v1/chat/completions \
 | `ADMIN_USERNAME` | 管理员用户名 | ✅ |
 | `ADMIN_PASSWORD` | 管理员密码 | ✅ |
 | `JWT_SECRET` | JWT 密钥 | ✅ |
-| `PROXY` | 代理地址（如：http://127.0.0.1:7897） | ❌ |
+| `PROXY` | 代理地址（如：http://127.0.0.1:7890），也支持系统代理环境变量 
+|`HTTP_PROXY`/`HTTPS_PROXY` | ❌ |
 | `SYSTEM_INSTRUCTION` | 系统提示词 | ❌ |
 | `IMAGE_BASE_URL` | 图片服务基础 URL | ❌ |
 
@@ -363,41 +413,56 @@ npm run login
 ```
 .
 ├── data/
-│   └── accounts.json       # Token 存储（自动生成）
+│   ├── accounts.json       # Token 存储（自动生成）
+│   └── quotas.json         # 额度缓存（自动生成）
 ├── public/
 │   ├── index.html          # Web 管理界面
 │   ├── app.js              # 前端逻辑
-│   └── style.css           # 界面样式
+│   ├── style.css           # 界面样式
+│   └── images/             # 生成的图片存储目录
 ├── scripts/
 │   ├── oauth-server.js     # OAuth 登录服务
 │   └── refresh-tokens.js   # Token 刷新脚本
 ├── src/
 │   ├── api/
-│   │   └── client.js       # API 调用逻辑
+│   │   └── client.js       # API 调用逻辑（含模型列表缓存）
 │   ├── auth/
 │   │   ├── jwt.js          # JWT 认证
-│   │   └── token_manager.js # Token 管理
+│   │   ├── token_manager.js # Token 管理（含轮询策略）
+│   │   └── quota_manager.js # 额度缓存管理
 │   ├── routes/
-│   │   └── admin.js        # 管理接口路由
+│   │   ├── admin.js        # 管理接口路由
+│   │   └── sd.js           # SD WebUI 兼容接口
 │   ├── bin/
 │   │   ├── antigravity_requester_android_arm64   # Android ARM64 TLS 请求器
 │   │   ├── antigravity_requester_linux_amd64     # Linux AMD64 TLS 请求器
 │   │   └── antigravity_requester_windows_amd64.exe # Windows AMD64 TLS 请求器
 │   ├── config/
-│   │   └── config.js       # 配置加载
+│   │   ├── config.js       # 配置加载
+│   │   └── init-env.js     # 环境变量初始化
+│   ├── constants/
+│   │   └── oauth.js        # OAuth 常量
 │   ├── server/
-│   │   └── index.js        # 主服务器
+│   │   └── index.js        # 主服务器（含内存管理和心跳）
 │   ├── utils/
+│   │   ├── configReloader.js # 配置热重载
+│   │   ├── deepMerge.js    # 深度合并工具
+│   │   ├── envParser.js    # 环境变量解析
 │   │   ├── idGenerator.js  # ID 生成器
+│   │   ├── imageStorage.js # 图片存储
 │   │   ├── logger.js       # 日志模块
 │   │   └── utils.js        # 工具函数
 │   └── AntigravityRequester.js # TLS 指纹请求器封装
 ├── test/
 │   ├── test-request.js     # 请求测试
+│   ├── test-image-generation.js # 图片生成测试
+│   ├── test-token-rotation.js # Token 轮换测试
 │   └── test-transform.js   # 转换测试
 ├── .env                    # 环境变量配置（敏感信息）
 ├── .env.example            # 环境变量配置示例
 ├── config.json             # 基础配置文件
+├── Dockerfile              # Docker 构建文件
+├── docker-compose.yml      # Docker Compose 配置
 └── package.json            # 项目配置
 ```
 
@@ -420,6 +485,138 @@ npm run login
 
 注意：此功能仅适用于 Pro 订阅账号。官方已修复免费账号使用随机 ProjectId 的漏洞。
 
+## 资格校验自动回退
+
+当 OAuth 登录或添加 Token 时，系统会自动检测账号的订阅资格：
+
+1. **有资格的账号**：正常使用 API 返回的 ProjectId
+2. **无资格的账号**：自动生成随机 ProjectId，避免添加失败
+
+这一机制确保了：
+- 无论账号是否有 Pro 订阅，都能成功添加 Token
+- 自动降级处理，无需手动干预
+- 不会因为资格校验失败而阻止登录流程
+
+## 真 System 消息合并
+
+本服务支持将开头连续的多条 system 消息与全局 SystemInstruction 合并：
+
+```
+请求消息：
+[system] 你是助手
+[system] 请使用中文回答
+[user] 你好
+
+合并后：
+SystemInstruction = 全局配置的系统提示词 + "\n\n" + "你是助手\n\n请使用中文回答"
+messages = [{role: user, content: 你好}]
+```
+
+这一设计：
+- 兼容 OpenAI 的多 system 消息格式
+- 充分利用 Antigravity 的 SystemInstruction 功能
+- 确保系统提示词的完整性和优先级
+
+## 思考预算（Thinking Budget）
+
+对于支持思考能力的模型（如 gemini-2.0-flash-thinking-exp），可以通过以下方式控制思考深度：
+
+### 方式一：使用 reasoning_effort 参数（OpenAI 兼容）
+
+```json
+{
+  "model": "gemini-2.0-flash-thinking-exp",
+  "reasoning_effort": "high",
+  "messages": [...]
+}
+```
+
+| 值 | 思考 Token ��算 |
+|---|----------------|
+| `low` | 1024 |
+| `medium` | 16000 |
+| `high` | 32000 |
+
+### 方式二：使用 thinking_budget 参数（精确控制）
+
+```json
+{
+  "model": "gemini-2.0-flash-thinking-exp",
+  "thinking_budget": 24000,
+  "messages": [...]
+}
+```
+
+- 范围：1024 - 32000
+- 优先级：`thinking_budget` > `reasoning_effort` > 配置文件默认值
+
+### DeepSeek 思考格式兼容
+
+本服务自动适配 DeepSeek 的 `reasoning_content` 格式，将思维链内容单独输出，避免与正常内容混淆：
+
+```json
+{
+  "choices": [{
+    "message": {
+      "content": "最终答案",
+      "reasoning_content": "这是思考过程..."
+    }
+  }]
+}
+```
+
+## 内存优化
+
+本服务经过深度内存优化：
+
+### 优化效果
+
+| 指标 | 优化前 | 优化后 |
+|------|--------|--------|
+| 进程数 | 8+ | 2 |
+| 内存占用 | 100MB+ | 50MB+ |
+| GC 频率 | 高 | 低 |
+
+### 优化手段
+
+1. **对象池复用**：流式响应对象通过对象池复用，减少 50%+ 临时对象创建
+2. **预编译常量**：正则表达式、格式字符串等预编译，避免重复创建
+3. **LineBuffer 优化**：高效的流式行分割，避免频繁字符串操作
+4. **自动内存清理**：堆内存超过阈值（默认 100MB）时自动触发 GC
+5. **进程精简**：移除不必要的子进程，统一在主进程处理
+
+### 配置
+
+```json
+{
+  "server": {
+    "memoryThreshold": 100
+  }
+}
+```
+
+- `memoryThreshold`：触发 GC 的堆内存阈值（MB）
+
+## 心跳机制
+
+为防止 Cloudflare 等 CDN 因长时间无响应而断开连接，本服务实现了 SSE 心跳机制：
+
+- 在流式响应期间，定期发送心跳包（`: heartbeat\n\n`）
+- 默认间隔 15 秒，可配置
+- 心跳包符合 SSE 规范，客户端会自动忽略
+
+### 配置
+
+```json
+{
+  "server": {
+    "heartbeatInterval": 15000
+  }
+}
+```
+
+- `heartbeatInterval`：心跳间隔（毫秒），设为 0 禁用心跳
+
 ## 注意事项
 
 1. 首次使用需要复制 `.env.example` 为 `.env` 并配置

config.json

@@ -2,7 +2,13 @@
   "server": {
     "port": 8045,
     "host": "0.0.0.0",
-    "maxRequestSize": "500mb"
+    "maxRequestSize": "500mb",
+    "heartbeatInterval": 15000,
+    "memoryThreshold": 25
+  },
+  "rotation": {
+    "strategy": "round_robin",
+    "requestCount": 50
   },
   "api": {
     "url": "https://daily-cloudcode-pa.sandbox.googleapis.com/v1internal:streamGenerateContent?alt=sse",
@@ -13,12 +19,16 @@
   },
   "defaults": {
     "temperature": 1,
-    "topP": 0.85,
+    "topP": 1,
     "topK": 50,
-    "maxTokens": 8096
+    "maxTokens": 32000,
+    "thinkingBudget": 16000
+  },
+  "cache": {
+    "modelListTTL": 3600000
   },
   "other": {
-    "timeout": 180000,
+    "timeout": 300000,
     "skipProjectIdFetch": false,
     "useNativeAxios": false
   }

package.json

@@ -5,10 +5,11 @@
   "type": "module",
   "main": "src/server/index.js",
   "scripts": {
-    "start": "node src/server/index.js",
+    "start": "node --expose-gc src/server/index.js",
+    "start:no-gc": "node src/server/index.js",
     "login": "node scripts/oauth-server.js",
     "refresh": "node scripts/refresh-tokens.js",
-    "dev": "node --watch src/server/index.js"
+    "dev": "node --expose-gc --watch src/server/index.js"
   },
   "keywords": [
     "antigravity",

public/app.js

@@ -1,5 +1,80 @@
 let authToken = localStorage.getItem('authToken');
 let oauthPort = null;
+
+// 字体大小设置
+function initFontSize() {
+    const savedSize = localStorage.getItem('fontSize') || '18';
+    document.documentElement.style.setProperty('--font-size-base', savedSize + 'px');
+    updateFontSizeInputs(savedSize);
+}
+
+function changeFontSize(size) {
+    // 限制范围
+    size = Math.max(10, Math.min(24, parseInt(size) || 14));
+    document.documentElement.style.setProperty('--font-size-base', size + 'px');
+    localStorage.setItem('fontSize', size);
+    updateFontSizeInputs(size);
+}
+
+function updateFontSizeInputs(size) {
+    const rangeInput = document.getElementById('fontSizeRange');
+    const numberInput = document.getElementById('fontSizeInput');
+    if (rangeInput) rangeInput.value = size;
+    if (numberInput) numberInput.value = size;
+}
+
+// 页面加载时初始化字体大小
+initFontSize();
+
+// 敏感信息隐藏功能 - 默认隐藏
+// localStorage 存储的是字符串 'true' 或 'false'
+// 如果没有存储过，默认为隐藏状态
+let sensitiveInfoHidden = localStorage.getItem('sensitiveInfoHidden') !== 'false';
+
+function initSensitiveInfo() {
+    updateSensitiveInfoDisplay();
+    updateSensitiveBtn();
+}
+
+function toggleSensitiveInfo() {
+    sensitiveInfoHidden = !sensitiveInfoHidden;
+    localStorage.setItem('sensitiveInfoHidden', sensitiveInfoHidden);
+    updateSensitiveInfoDisplay();
+    updateSensitiveBtn();
+}
+
+function updateSensitiveBtn() {
+    const btn = document.getElementById('toggleSensitiveBtn');
+    if (btn) {
+        if (sensitiveInfoHidden) {
+            btn.innerHTML = '🙈 隐藏';
+            btn.title = '点击显示敏感信息';
+            btn.classList.remove('btn-info');
+            btn.classList.add('btn-secondary');
+        } else {
+            btn.innerHTML = '👁️ 显示';
+            btn.title = '点击隐藏敏感信息';
+            btn.classList.remove('btn-secondary');
+            btn.classList.add('btn-info');
+        }
+    }
+}
+
+function updateSensitiveInfoDisplay() {
+    document.querySelectorAll('.sensitive-info').forEach(el => {
+        if (sensitiveInfoHidden) {
+            el.dataset.original = el.textContent;
+            el.textContent = '••••••';
+            el.classList.add('blurred');
+        } else if (el.dataset.original) {
+            el.textContent = el.dataset.original;
+            el.classList.remove('blurred');
+        }
+    });
+}
+
+// 页面加载时初始化敏感信息状态
+initSensitiveInfo();
 const CLIENT_ID = '1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com';
 const SCOPES = [
     'https://www.googleapis.com/auth/cloud-platform',
@@ -102,9 +177,10 @@ document.getElementById('login').addEventListener('submit', async (e) => {
         if (data.success) {
             authToken = data.token;
             localStorage.setItem('authToken', authToken);
-            showToast('登录成功，欢迎回来！', 'success');
+            showToast('登录成功', 'success');
             showMainContent();
             loadTokens();
+            loadConfig();
         } else {
             showToast(data.message || '用户名或密码错误', 'error');
         }
@@ -118,7 +194,7 @@ document.getElementById('login').addEventListener('submit', async (e) => {
 });
 
 function showOAuthModal() {
-    showToast('点击后请在新窗口完成授权', 'info', '提示');
+    showToast('点击后请在新窗口完成授权', 'info');
     const modal = document.createElement('div');
     modal.className = 'modal form-modal';
     modal.innerHTML = `
@@ -130,9 +206,9 @@ function showOAuthModal() {
                 <p>2️⃣ 完成授权后，复制浏览器地址栏的完整URL</p>
                 <p>3️⃣ 粘贴URL到下方输入框并提交</p>
             </div>
-            <div style="display: flex; gap: 8px; margin-bottom: 16px;">
+            <div style="display: flex; gap: 8px; margin-bottom: 12px;">
                 <button type="button" onclick="openOAuthWindow()" class="btn btn-success" style="flex: 1;">🔐 打开授权页面</button>
-                <button type="button" onclick="copyOAuthUrl()" class="btn btn-info" style="width: 44px; padding: 0; font-size: 18px;" title="复制授权链接">📋</button>
+                <button type="button" onclick="copyOAuthUrl()" class="btn btn-info" style="flex: 1;">📋 复制授权链接</button>
             </div>
             <input type="text" id="modalCallbackUrl" placeholder="粘贴完整的回调URL (http://localhost:xxxxx/oauth-callback?code=...)">
             <div class="modal-actions">
@@ -156,7 +232,7 @@ function showManualModal() {
                 <input type="text" id="modalRefreshToken" placeholder="Refresh Token (必填)">
                 <input type="number" id="modalExpiresIn" placeholder="过期时间(秒)" value="3599">
             </div>
-            <p style="font-size: 0.85rem; color: var(--text-light); margin-bottom: 16px;">💡 提示：过期时间默认3599秒(约1小时)</p>
+            <p style="font-size: 0.8rem; color: var(--text-light); margin-bottom: 12px;">💡 过期时间默认3599秒(约1小时)</p>
             <div class="modal-actions">
                 <button class="btn btn-secondary" onclick="this.closest('.modal').remove()">取消</button>
                 <button class="btn btn-success" onclick="addTokenFromModal()">✅ 添加</button>
@@ -183,9 +259,9 @@ function openOAuthWindow() {
 function copyOAuthUrl() {
     const url = getOAuthUrl();
     navigator.clipboard.writeText(url).then(() => {
-        showToast('授权链接已复制到剪贴板', 'success');
+        showToast('授权链接已复制', 'success');
     }).catch(() => {
-        showToast('复制失败，请手动复制', 'error');
+        showToast('复制失败', 'error');
     });
 }
 
@@ -206,7 +282,7 @@ async function processOAuthCallbackModal() {
         
         if (!code) {
             hideLoading();
-            showToast('URL中未找到授权码，请检查URL是否完整', 'error');
+            showToast('URL中未找到授权码', 'error');
             return;
         }
         
@@ -235,14 +311,14 @@ async function processOAuthCallbackModal() {
             hideLoading();
             if (addResult.success) {
                 modal.remove();
-                showToast('Token添加成功！', 'success');
+                showToast('Token添加成功', 'success');
                 loadTokens();
             } else {
-                showToast('Token添加失败: ' + addResult.message, 'error');
+                showToast('添加失败: ' + addResult.message, 'error');
             }
         } else {
             hideLoading();
-            showToast('Token交换失败: ' + result.message, 'error');
+            showToast('交换失败: ' + result.message, 'error');
         }
     } catch (error) {
         hideLoading();
@@ -276,7 +352,7 @@ async function addTokenFromModal() {
         hideLoading();
         if (data.success) {
             modal.remove();
-            showToast('Token添加成功！', 'success');
+            showToast('Token添加成功', 'success');
             loadTokens();
         } else {
             showToast(data.message || '添加失败', 'error');
@@ -296,11 +372,12 @@ function switchTab(tab) {
     document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
     event.target.classList.add('active');
     
+    document.getElementById('tokensPage').classList.add('hidden');
+    document.getElementById('settingsPage').classList.add('hidden');
+    
     if (tab === 'tokens') {
         document.getElementById('tokensPage').classList.remove('hidden');
-        document.getElementById('settingsPage').classList.add('hidden');
     } else if (tab === 'settings') {
-        document.getElementById('tokensPage').classList.add('hidden');
         document.getElementById('settingsPage').classList.remove('hidden');
         loadConfig();
     }
@@ -339,6 +416,9 @@ async function loadTokens() {
 }
 
 function renderTokens(tokens) {
+    // 缓存tokens用于额度弹窗
+    cachedTokens = tokens;
+    
     document.getElementById('totalTokens').textContent = tokens.length;
     document.getElementById('enabledTokens').textContent = tokens.filter(t => t.enable).length;
     document.getElementById('disabledTokens').textContent = tokens.filter(t => !t.enable).length;
@@ -349,47 +429,430 @@ function renderTokens(tokens) {
             <div class="empty-state">
                 <div class="empty-state-icon">📦</div>
                 <div class="empty-state-text">暂无Token</div>
-                <div class="empty-state-hint">点击上方按钮添加您的第一个Token</div>
+                <div class="empty-state-hint">点击上方OAuth按钮添加Token</div>
             </div>
         `;
         return;
     }
     
-    tokenList.innerHTML = tokens.map(token => `
-        <div class="token-card">
+    tokenList.innerHTML = tokens.map(token => {
+        const expireTime = new Date(token.timestamp + token.expires_in * 1000);
+        const isExpired = expireTime < new Date();
+        const expireStr = expireTime.toLocaleString('zh-CN', {month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit'});
+        const cardId = token.refresh_token.substring(0, 8);
+        
+        return `
+        <div class="token-card ${!token.enable ? 'disabled' : ''} ${isExpired ? 'expired' : ''}">
             <div class="token-header">
                 <span class="status ${token.enable ? 'enabled' : 'disabled'}">
                     ${token.enable ? '✅ 启用' : '❌ 禁用'}
                 </span>
-                <span class="token-id">#${token.refresh_token.substring(0, 8)}</span>
+                <div class="token-header-right">
+                    <button class="btn-icon" onclick="showTokenDetail('${token.refresh_token}')" title="编辑全部">✏️</button>
+                    <span class="token-id">#${token.refresh_token.substring(0, 6)}</span>
+                </div>
             </div>
             <div class="token-info">
                 <div class="info-row">
-                    <span class="info-label">🎫 Access</span>
-                    <span class="info-value">${token.access_token_suffix}</span>
+                    <span class="info-label">🎫</span>
+                    <span class="info-value sensitive-info" title="${token.access_token_suffix}">${token.access_token_suffix}</span>
                 </div>
-                <div class="info-row">
-                    <span class="info-label">📦 Project</span>
-                    <span class="info-value">${token.projectId || 'N/A'}</span>
+                <div class="info-row editable" onclick="editField(event, '${token.refresh_token}', 'projectId', '${(token.projectId || '').replace(/'/g, "\\'")}')" title="点击编辑">
+                    <span class="info-label">📦</span>
+                    <span class="info-value sensitive-info">${token.projectId || '点击设置'}</span>
+                    <span class="info-edit-icon">✏️</span>
                 </div>
-                <div class="info-row">
-                    <span class="info-label">📧 邮箱</span>
-                    <span class="info-value">${token.email || 'N/A'}</span>
+                <div class="info-row editable" onclick="editField(event, '${token.refresh_token}', 'email', '${(token.email || '').replace(/'/g, "\\'")}')" title="点击编辑">
+                    <span class="info-label">📧</span>
+                    <span class="info-value sensitive-info">${token.email || '点击设置'}</span>
+                    <span class="info-edit-icon">✏️</span>
                 </div>
-                <div class="info-row">
-                    <span class="info-label">⏰ 过期</span>
-                    <span class="info-value">${new Date(token.timestamp + token.expires_in * 1000).toLocaleString('zh-CN', {month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit'})}</span>
+                <div class="info-row ${isExpired ? 'expired-text' : ''}">
+                    <span class="info-label">⏰</span>
+                    <span class="info-value">${expireStr}${isExpired ? ' (已过期)' : ''}</span>
                 </div>
             </div>
+            <!-- 内嵌额度显示 -->
+            <div class="token-quota-inline" id="quota-inline-${cardId}">
+                <div class="quota-inline-header" onclick="toggleQuotaExpand('${cardId}', '${token.refresh_token}')">
+                    <span class="quota-inline-summary" id="quota-summary-${cardId}">📊 加载中...</span>
+                    <span class="quota-inline-toggle" id="quota-toggle-${cardId}">▼</span>
+                </div>
+                <div class="quota-inline-detail hidden" id="quota-detail-${cardId}"></div>
+            </div>
             <div class="token-actions">
-                <button class="btn btn-info" onclick="showQuotaModal('${token.refresh_token}')">📊 查看额度</button>
-                <button class="btn ${token.enable ? 'btn-warning' : 'btn-success'}" onclick="toggleToken('${token.refresh_token}', ${!token.enable})">
+                <button class="btn btn-info btn-xs" onclick="showQuotaModal('${token.refresh_token}')" title="查看额度">📊 详情</button>
+                <button class="btn ${token.enable ? 'btn-warning' : 'btn-success'} btn-xs" onclick="toggleToken('${token.refresh_token}', ${!token.enable})" title="${token.enable ? '禁用' : '启用'}">
                     ${token.enable ? '⏸️ 禁用' : '▶️ 启用'}
                 </button>
-                <button class="btn btn-danger" onclick="deleteToken('${token.refresh_token}')">🗑️ 删除</button>
+                <button class="btn btn-danger btn-xs" onclick="deleteToken('${token.refresh_token}')" title="删除">🗑️ 删除</button>
+            </div>
+        </div>
+    `}).join('');
+    
+    // 自动加载所有token的额度摘要
+    tokens.forEach(token => {
+        loadTokenQuotaSummary(token.refresh_token);
+    });
+    
+    // 应用敏感信息隐藏状态
+    updateSensitiveInfoDisplay();
+}
+
+// 加载token额度摘要（只显示最低额度的模型）
+async function loadTokenQuotaSummary(refreshToken) {
+    const cardId = refreshToken.substring(0, 8);
+    const summaryEl = document.getElementById(`quota-summary-${cardId}`);
+    if (!summaryEl) return;
+    
+    // 先检查缓存
+    const cached = quotaCache.get(refreshToken);
+    if (cached) {
+        renderQuotaSummary(summaryEl, cached);
+        return;
+    }
+    
+    try {
+        const response = await authFetch(`/admin/tokens/${encodeURIComponent(refreshToken)}/quotas`, {
+            headers: { 'Authorization': `Bearer ${authToken}` }
+        });
+        const data = await response.json();
+        
+        if (data.success && data.data && data.data.models) {
+            // 缓存数据
+            quotaCache.set(refreshToken, data.data);
+            renderQuotaSummary(summaryEl, data.data);
+        } else {
+            const errMsg = data.message || '未知错误';
+            summaryEl.innerHTML = `<span class="quota-summary-error">📊 ${errMsg}</span>`;
+        }
+    } catch (error) {
+        if (error.message !== 'Unauthorized') {
+            console.error('加载额度摘要失败:', error);
+            summaryEl.innerHTML = `<span class="quota-summary-error">📊 加载失败</span>`;
+        }
+    }
+}
+
+// 渲染额度摘要
+function renderQuotaSummary(summaryEl, quotaData) {
+    const models = quotaData.models;
+    const modelEntries = Object.entries(models);
+    
+    if (modelEntries.length === 0) {
+        summaryEl.textContent = '📊 暂无额度';
+        return;
+    }
+    
+    // 找到额度最低的模型
+    let minModel = modelEntries[0][0];
+    let minQuota = modelEntries[0][1];
+    modelEntries.forEach(([modelId, quota]) => {
+        if (quota.remaining < minQuota.remaining) {
+            minQuota = quota;
+            minModel = modelId;
+        }
+    });
+    
+    const percentage = (minQuota.remaining * 100).toFixed(0);
+    const shortName = minModel.replace('models/', '').replace('publishers/google/', '').split('/').pop();
+    const barColor = percentage > 50 ? '#10b981' : percentage > 20 ? '#f59e0b' : '#ef4444';
+    
+    // 简洁的一行显示
+    summaryEl.innerHTML = `
+        <span class="quota-summary-icon">📊</span>
+        <span class="quota-summary-model" title="${minModel}">${shortName}</span>
+        <span class="quota-summary-bar"><span style="width:${percentage}%;background:${barColor}"></span></span>
+        <span class="quota-summary-pct">${percentage}%</span>
+    `;
+}
+
+// 展开/收起额度详情
+async function toggleQuotaExpand(cardId, refreshToken) {
+    const detailEl = document.getElementById(`quota-detail-${cardId}`);
+    const toggleEl = document.getElementById(`quota-toggle-${cardId}`);
+    if (!detailEl || !toggleEl) return;
+    
+    const isHidden = detailEl.classList.contains('hidden');
+    
+    if (isHidden) {
+        // 展开
+        detailEl.classList.remove('hidden');
+        toggleEl.textContent = '▲';
+        
+        // 如果还没加载过详情，加载它
+        if (!detailEl.dataset.loaded) {
+            detailEl.innerHTML = '<div class="quota-loading-small">加载中...</div>';
+            await loadQuotaDetail(cardId, refreshToken);
+            detailEl.dataset.loaded = 'true';
+        }
+    } else {
+        // 收起
+        detailEl.classList.add('hidden');
+        toggleEl.textContent = '▼';
+    }
+}
+
+// 加载额度详情
+async function loadQuotaDetail(cardId, refreshToken) {
+    const detailEl = document.getElementById(`quota-detail-${cardId}`);
+    if (!detailEl) return;
+    
+    try {
+        const response = await authFetch(`/admin/tokens/${encodeURIComponent(refreshToken)}/quotas`, {
+            headers: { 'Authorization': `Bearer ${authToken}` }
+        });
+        const data = await response.json();
+        
+        if (data.success && data.data && data.data.models) {
+            const models = data.data.models;
+            const modelEntries = Object.entries(models);
+            
+            if (modelEntries.length === 0) {
+                detailEl.innerHTML = '<div class="quota-empty-small">暂无额度信息</div>';
+                return;
+            }
+            
+            // 按模型类型分组
+            const grouped = { claude: [], gemini: [], other: [] };
+            modelEntries.forEach(([modelId, quota]) => {
+                const item = { modelId, quota };
+                if (modelId.toLowerCase().includes('claude')) grouped.claude.push(item);
+                else if (modelId.toLowerCase().includes('gemini')) grouped.gemini.push(item);
+                else grouped.other.push(item);
+            });
+            
+            let html = '<div class="quota-detail-grid">';
+            
+            const renderGroup = (items, icon) => {
+                if (items.length === 0) return '';
+                let groupHtml = '';
+                items.forEach(({ modelId, quota }) => {
+                    const percentage = (quota.remaining * 100).toFixed(0);
+                    const barColor = percentage > 50 ? '#10b981' : percentage > 20 ? '#f59e0b' : '#ef4444';
+                    const shortName = modelId.replace('models/', '').replace('publishers/google/', '').split('/').pop();
+                    // 紧凑的一行显示
+                    groupHtml += `
+                        <div class="quota-detail-row" title="${modelId} - 重置: ${quota.resetTime}">
+                            <span class="quota-detail-icon">${icon}</span>
+                            <span class="quota-detail-name">${shortName}</span>
+                            <span class="quota-detail-bar"><span style="width:${percentage}%;background:${barColor}"></span></span>
+                            <span class="quota-detail-pct">${percentage}%</span>
+                        </div>
+                    `;
+                });
+                return groupHtml;
+            };
+            
+            html += renderGroup(grouped.claude, '���');
+            html += renderGroup(grouped.gemini, '💎');
+            html += renderGroup(grouped.other, '🔧');
+            html += '</div>';
+            
+            // 添加刷新按钮
+            html += `<button class="btn btn-info btn-xs quota-refresh-btn" onclick="refreshInlineQuota('${cardId}', '${refreshToken}')">🔄 刷新额度</button>`;
+            
+            detailEl.innerHTML = html;
+        } else {
+            const errMsg = data.message || '未知错误';
+            detailEl.innerHTML = `<div class="quota-error-small">加载失败: ${errMsg}</div>`;
+        }
+    } catch (error) {
+        if (error.message !== 'Unauthorized') {
+            detailEl.innerHTML = `<div class="quota-error-small">网络错误</div>`;
+        }
+    }
+}
+
+// 刷新内嵌额度
+async function refreshInlineQuota(cardId, refreshToken) {
+    const detailEl = document.getElementById(`quota-detail-${cardId}`);
+    const summaryEl = document.getElementById(`quota-summary-${cardId}`);
+    
+    if (detailEl) {
+        detailEl.innerHTML = '<div class="quota-loading-small">刷新中...</div>';
+    }
+    if (summaryEl) {
+        summaryEl.textContent = '📊 刷新中...';
+    }
+    
+    // 清除缓存
+    quotaCache.clear(refreshToken);
+    
+    // 强制刷新
+    try {
+        const response = await authFetch(`/admin/tokens/${encodeURIComponent(refreshToken)}/quotas?refresh=true`, {
+            headers: { 'Authorization': `Bearer ${authToken}` }
+        });
+        const data = await response.json();
+        if (data.success && data.data) {
+            quotaCache.set(refreshToken, data.data);
+        }
+    } catch (e) {}
+    
+    // 重新加载摘要和详情
+    await loadTokenQuotaSummary(refreshToken);
+    await loadQuotaDetail(cardId, refreshToken);
+}
+
+// 内联编辑字段
+function editField(event, refreshToken, field, currentValue) {
+    event.stopPropagation();
+    const row = event.currentTarget;
+    const valueSpan = row.querySelector('.info-value');
+    
+    // 如果已经在编辑状态，不重复创建
+    if (row.querySelector('input')) return;
+    
+    const fieldLabels = {
+        projectId: 'Project ID',
+        email: '邮箱'
+    };
+    
+    // 创建输入框
+    const input = document.createElement('input');
+    input.type = field === 'email' ? 'email' : 'text';
+    input.value = currentValue;
+    input.className = 'inline-edit-input';
+    input.placeholder = `输入${fieldLabels[field]}`;
+    
+    // 保存原始内容
+    const originalContent = valueSpan.textContent;
+    valueSpan.style.display = 'none';
+    row.insertBefore(input, valueSpan.nextSibling);
+    input.focus();
+    input.select();
+    
+    // 保存函数
+    const save = async () => {
+        const newValue = input.value.trim();
+        input.disabled = true;
+        
+        try {
+            const response = await authFetch(`/admin/tokens/${encodeURIComponent(refreshToken)}`, {
+                method: 'PUT',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${authToken}`
+                },
+                body: JSON.stringify({ [field]: newValue })
+            });
+            
+            const data = await response.json();
+            if (data.success) {
+                showToast('已保存', 'success');
+                loadTokens();
+            } else {
+                showToast(data.message || '保存失败', 'error');
+                cancel();
+            }
+        } catch (error) {
+            showToast('保存失败', 'error');
+            cancel();
+        }
+    };
+    
+    // 取消函数
+    const cancel = () => {
+        input.remove();
+        valueSpan.style.display = '';
+    };
+    
+    // 事件监听
+    input.addEventListener('blur', () => {
+        setTimeout(() => {
+            if (document.activeElement !== input) {
+                if (input.value.trim() !== currentValue) {
+                    save();
+                } else {
+                    cancel();
+                }
+            }
+        }, 100);
+    });
+    
+    input.addEventListener('keydown', (e) => {
+        if (e.key === 'Enter') {
+            e.preventDefault();
+            save();
+        } else if (e.key === 'Escape') {
+            cancel();
+        }
+    });
+}
+
+// 显示Token详情编辑弹窗
+function showTokenDetail(refreshToken) {
+    const token = cachedTokens.find(t => t.refresh_token === refreshToken);
+    if (!token) {
+        showToast('Token不存在', 'error');
+        return;
+    }
+    
+    const modal = document.createElement('div');
+    modal.className = 'modal form-modal';
+    modal.innerHTML = `
+        <div class="modal-content">
+            <div class="modal-title">📝 Token详情</div>
+            <div class="form-group compact">
+                <label>🎫 Access Token (只读)</label>
+                <div class="token-display">${token.access_token || ''}</div>
+            </div>
+            <div class="form-group compact">
+                <label>🔄 Refresh Token (只读)</label>
+                <div class="token-display">${token.refresh_token}</div>
+            </div>
+            <div class="form-group compact">
+                <label>📦 Project ID</label>
+                <input type="text" id="editProjectId" value="${token.projectId || ''}" placeholder="项目ID">
+            </div>
+            <div class="form-group compact">
+                <label>📧 邮箱</label>
+                <input type="email" id="editEmail" value="${token.email || ''}" placeholder="账号邮箱">
+            </div>
+            <div class="form-group compact">
+                <label>⏰ 过期时间</label>
+                <input type="text" value="${new Date(token.timestamp + token.expires_in * 1000).toLocaleString('zh-CN')}" readonly style="background: var(--bg); cursor: not-allowed;">
+            </div>
+            <div class="modal-actions">
+                <button class="btn btn-secondary" onclick="this.closest('.modal').remove()">取消</button>
+                <button class="btn btn-success" onclick="saveTokenDetail('${refreshToken}')">💾 保存</button>
             </div>
         </div>
-    `).join('');
+    `;
+    document.body.appendChild(modal);
+    modal.onclick = (e) => { if (e.target === modal) modal.remove(); };
+}
+
+// 保存Token详情
+async function saveTokenDetail(refreshToken) {
+    const projectId = document.getElementById('editProjectId').value.trim();
+    const email = document.getElementById('editEmail').value.trim();
+    
+    showLoading('保存中...');
+    try {
+        const response = await authFetch(`/admin/tokens/${encodeURIComponent(refreshToken)}`, {
+            method: 'PUT',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${authToken}`
+            },
+            body: JSON.stringify({ projectId, email })
+        });
+        
+        const data = await response.json();
+        hideLoading();
+        if (data.success) {
+            document.querySelector('.form-modal').remove();
+            showToast('保存成功', 'success');
+            loadTokens();
+        } else {
+            showToast(data.message || '保存失败', 'error');
+        }
+    } catch (error) {
+        hideLoading();
+        showToast('保存失败: ' + error.message, 'error');
+    }
 }
 
 async function toggleToken(refreshToken, enable) {
@@ -397,7 +860,7 @@ async function toggleToken(refreshToken, enable) {
     const confirmed = await showConfirm(`确定要${action}这个Token吗？`, `${action}确认`);
     if (!confirmed) return;
     
-    showLoading(`正在${action}Token...`);
+    showLoading(`正在${action}...`);
     try {
         const response = await authFetch(`/admin/tokens/${encodeURIComponent(refreshToken)}`, {
             method: 'PUT',
@@ -411,7 +874,7 @@ async function toggleToken(refreshToken, enable) {
         const data = await response.json();
         hideLoading();
         if (data.success) {
-            showToast(`Token已${enable ? '启用' : '禁用'}`, 'success');
+            showToast(`已${action}`, 'success');
             loadTokens();
         } else {
             showToast(data.message || '操作失败', 'error');
@@ -423,10 +886,10 @@ async function toggleToken(refreshToken, enable) {
 }
 
 async function deleteToken(refreshToken) {
-    const confirmed = await showConfirm('删除后无法恢复，确定要删除这个Token吗？', '⚠️ 删除确认');
+    const confirmed = await showConfirm('删除后无法恢复，确定删除？', '⚠️ 删除确认');
     if (!confirmed) return;
     
-    showLoading('正在删除Token...');
+    showLoading('正在删除...');
     try {
         const response = await authFetch(`/admin/tokens/${encodeURIComponent(refreshToken)}`, {
             method: 'DELETE',
@@ -436,7 +899,7 @@ async function deleteToken(refreshToken) {
         const data = await response.json();
         hideLoading();
         if (data.success) {
-            showToast('Token已删除', 'success');
+            showToast('已删除', 'success');
             loadTokens();
         } else {
             showToast(data.message || '删除失败', 'error');
@@ -447,18 +910,74 @@ async function deleteToken(refreshToken) {
     }
 }
 
+// 存储token数据用于额度弹窗显示邮箱
+let cachedTokens = [];
+// 当前选中的token（用于额度弹窗）
+let currentQuotaToken = null;
+
+// 额度数据缓存 - 避免频繁请求
+const quotaCache = {
+    data: {},  // { refreshToken: { data, timestamp } }
+    ttl: 5 * 60 * 1000,  // 缓存5分钟
+    
+    get(refreshToken) {
+        const cached = this.data[refreshToken];
+        if (!cached) return null;
+        if (Date.now() - cached.timestamp > this.ttl) {
+            delete this.data[refreshToken];
+            return null;
+        }
+        return cached.data;
+    },
+    
+    set(refreshToken, data) {
+        this.data[refreshToken] = {
+            data,
+            timestamp: Date.now()
+        };
+    },
+    
+    clear(refreshToken) {
+        if (refreshToken) {
+            delete this.data[refreshToken];
+        } else {
+            this.data = {};
+        }
+    }
+};
+
 async function showQuotaModal(refreshToken) {
+    currentQuotaToken = refreshToken;
+    
+    // 找到当前token的索引
+    const activeIndex = cachedTokens.findIndex(t => t.refresh_token === refreshToken);
+    
+    // 生成邮箱标签 - 使用索引来确保只有一个active
+    const emailTabs = cachedTokens.map((t, index) => {
+        const email = t.email || '未知';
+        const shortEmail = email.length > 20 ? email.substring(0, 17) + '...' : email;
+        const isActive = index === activeIndex;
+        return `<button type="button" class="quota-tab${isActive ? ' active' : ''}" data-index="${index}" onclick="switchQuotaAccountByIndex(${index})" title="${email}">${shortEmail}</button>`;
+    }).join('');
+    
     const modal = document.createElement('div');
     modal.className = 'modal';
+    modal.id = 'quotaModal';
     modal.innerHTML = `
-        <div class="modal-content" style="max-width: 600px;">
-            <div class="modal-title">📊 模型额度信息</div>
-            <div id="quotaContent" style="max-height: 60vh; overflow-y: auto;">
+        <div class="modal-content modal-xl">
+            <div class="quota-modal-header">
+                <div class="modal-title">📊 模型额度</div>
+                <div class="quota-update-time" id="quotaUpdateTime"></div>
+            </div>
+            <div class="quota-tabs" id="quotaEmailList">
+                ${emailTabs}
+            </div>
+            <div id="quotaContent" class="quota-container">
                 <div class="quota-loading">加载中...</div>
             </div>
             <div class="modal-actions">
-                <button class="btn btn-info" onclick="refreshQuotaData('${refreshToken}')">🔄 立即刷新</button>
-                <button class="btn btn-secondary" onclick="this.closest('.modal').remove()">关闭</button>
+                <button class="btn btn-info btn-sm" id="quotaRefreshBtn" onclick="refreshQuotaData()">🔄 刷新</button>
+                <button class="btn btn-secondary btn-sm" onclick="this.closest('.modal').remove()">关闭</button>
             </div>
         </div>
     `;
@@ -466,18 +985,73 @@ async function showQuotaModal(refreshToken) {
     modal.onclick = (e) => { if (e.target === modal) modal.remove(); };
     
     await loadQuotaData(refreshToken);
+    
+    // 添加鼠标滚轮横向滚动支持
+    const tabsContainer = document.getElementById('quotaEmailList');
+    if (tabsContainer) {
+        tabsContainer.addEventListener('wheel', (e) => {
+            if (e.deltaY !== 0) {
+                e.preventDefault();
+                tabsContainer.scrollLeft += e.deltaY;
+            }
+        }, { passive: false });
+    }
+}
+
+// 切换账号（通过索引）
+async function switchQuotaAccountByIndex(index) {
+    if (index < 0 || index >= cachedTokens.length) return;
+    
+    const token = cachedTokens[index];
+    currentQuotaToken = token.refresh_token;
+    
+    // 更新标签的激活状态
+    document.querySelectorAll('.quota-tab').forEach((tab, i) => {
+        if (i === index) {
+            tab.classList.add('active');
+        } else {
+            tab.classList.remove('active');
+        }
+    });
+    
+    // 加载新账号的额度
+    await loadQuotaData(token.refresh_token);
+}
+
+// 保留旧函数以兼容
+async function switchQuotaAccount(refreshToken) {
+    const index = cachedTokens.findIndex(t => t.refresh_token === refreshToken);
+    if (index >= 0) {
+        await switchQuotaAccountByIndex(index);
+    }
 }
 
 async function loadQuotaData(refreshToken, forceRefresh = false) {
     const quotaContent = document.getElementById('quotaContent');
     if (!quotaContent) return;
     
-    const refreshBtn = document.querySelector('.modal-content .btn-info');
+    const refreshBtn = document.getElementById('quotaRefreshBtn');
     if (refreshBtn) {
         refreshBtn.disabled = true;
         refreshBtn.textContent = '⏳ 加载中...';
     }
     
+    // 如果不是强制刷新，先检查缓存
+    if (!forceRefresh) {
+        const cached = quotaCache.get(refreshToken);
+        if (cached) {
+            renderQuotaModal(quotaContent, cached);
+            if (refreshBtn) {
+                refreshBtn.disabled = false;
+                refreshBtn.textContent = '🔄 刷新';
+            }
+            return;
+        }
+    } else {
+        // 强制刷新时清除缓存
+        quotaCache.clear(refreshToken);
+    }
+    
     quotaContent.innerHTML = '<div class="quota-loading">加载中...</div>';
     
     try {
@@ -489,85 +1063,9 @@ async function loadQuotaData(refreshToken, forceRefresh = false) {
         const data = await response.json();
         
         if (data.success) {
-            const quotaData = data.data;
-            const models = quotaData.models;
-            
-            if (Object.keys(models).length === 0) {
-                quotaContent.innerHTML = '<div class="quota-empty">暂无额度信息</div>';
-                return;
-            }
-            
-            const lastUpdated = new Date(quotaData.lastUpdated).toLocaleString('zh-CN', {
-                month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit'
-            });
-            
-            // 按模型类型分组
-            const grouped = { claude: [], gemini: [], other: [] };
-            Object.entries(models).forEach(([modelId, quota]) => {
-                const item = { modelId, quota };
-                if (modelId.toLowerCase().includes('claude')) grouped.claude.push(item);
-                else if (modelId.toLowerCase().includes('gemini')) grouped.gemini.push(item);
-                else grouped.other.push(item);
-            });
-            
-            let html = `<div class="quota-header">更新于 ${lastUpdated}</div>`;
-            
-            // 渲染各组
-            if (grouped.claude.length > 0) {
-                html += '<div class="quota-group-title">🤖 Claude 模型</div>';
-                grouped.claude.forEach(({ modelId, quota }) => {
-                    const percentage = (quota.remaining * 100).toFixed(1);
-                    const barColor = percentage > 50 ? '#10b981' : percentage > 20 ? '#f59e0b' : '#ef4444';
-                    html += `
-                        <div class="quota-item">
-                            <div class="quota-model-name">${modelId}</div>
-                            <div class="quota-bar-container">
-                                <div class="quota-bar" style="width: ${percentage}%; background: ${barColor};"></div>
-                                <span class="quota-percentage">${percentage}%</span>
-                            </div>
-                            <div class="quota-reset">🔄 重置: ${quota.resetTime}</div>
-                        </div>
-                    `;
-                });
-            }
-            
-            if (grouped.gemini.length > 0) {
-                html += '<div class="quota-group-title">💎 Gemini 模型</div>';
-                grouped.gemini.forEach(({ modelId, quota }) => {
-                    const percentage = (quota.remaining * 100).toFixed(1);
-                    const barColor = percentage > 50 ? '#10b981' : percentage > 20 ? '#f59e0b' : '#ef4444';
-                    html += `
-                        <div class="quota-item">
-                            <div class="quota-model-name">${modelId}</div>
-                            <div class="quota-bar-container">
-                                <div class="quota-bar" style="width: ${percentage}%; background: ${barColor};"></div>
-                                <span class="quota-percentage">${percentage}%</span>
-                            </div>
-                            <div class="quota-reset">🔄 重置: ${quota.resetTime}</div>
-                        </div>
-                    `;
-                });
-            }
-            
-            if (grouped.other.length > 0) {
-                html += '<div class="quota-group-title">🔧 其他模型</div>';
-                grouped.other.forEach(({ modelId, quota }) => {
-                    const percentage = (quota.remaining * 100).toFixed(1);
-                    const barColor = percentage > 50 ? '#10b981' : percentage > 20 ? '#f59e0b' : '#ef4444';
-                    html += `
-                        <div class="quota-item">
-                            <div class="quota-model-name">${modelId}</div>
-                            <div class="quota-bar-container">
-                                <div class="quota-bar" style="width: ${percentage}%; background: ${barColor};"></div>
-                                <span class="quota-percentage">${percentage}%</span>
-                            </div>
-                            <div class="quota-reset">🔄 重置: ${quota.resetTime}</div>
-                        </div>
-                    `;
-                });
-            }
-            
-            quotaContent.innerHTML = html;
+            // 缓存数据
+            quotaCache.set(refreshToken, data.data);
+            renderQuotaModal(quotaContent, data.data);
         } else {
             quotaContent.innerHTML = `<div class="quota-error">加载失败: ${data.message}</div>`;
         }
@@ -578,13 +1076,113 @@ async function loadQuotaData(refreshToken, forceRefresh = false) {
     } finally {
         if (refreshBtn) {
             refreshBtn.disabled = false;
-            refreshBtn.textContent = '🔄 立即刷新';
+            refreshBtn.textContent = '🔄 刷新';
         }
     }
 }
 
-async function refreshQuotaData(refreshToken) {
-    await loadQuotaData(refreshToken, true);
+async function refreshQuotaData() {
+    if (currentQuotaToken) {
+        await loadQuotaData(currentQuotaToken, true);
+    }
+}
+
+// 渲染额度弹窗内容
+function renderQuotaModal(quotaContent, quotaData) {
+    const models = quotaData.models;
+    
+    // 更新时间显示
+    const updateTimeEl = document.getElementById('quotaUpdateTime');
+    if (updateTimeEl && quotaData.lastUpdated) {
+        const lastUpdated = new Date(quotaData.lastUpdated).toLocaleString('zh-CN', {
+            month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit'
+        });
+        updateTimeEl.textContent = `更新于 ${lastUpdated}`;
+    }
+    
+    if (Object.keys(models).length === 0) {
+        quotaContent.innerHTML = '<div class="quota-empty">暂无额度信息</div>';
+        return;
+    }
+    
+    // 按模型类型分组
+    const grouped = { claude: [], gemini: [], other: [] };
+    Object.entries(models).forEach(([modelId, quota]) => {
+        const item = { modelId, quota };
+        if (modelId.toLowerCase().includes('claude')) grouped.claude.push(item);
+        else if (modelId.toLowerCase().includes('gemini')) grouped.gemini.push(item);
+        else grouped.other.push(item);
+    });
+    
+    let html = '';
+    
+    const renderGroup = (items, title) => {
+        if (items.length === 0) return '';
+        let groupHtml = `<div class="quota-group-title">${title}</div><div class="quota-grid">`;
+        items.forEach(({ modelId, quota }) => {
+            const percentage = (quota.remaining * 100).toFixed(0);
+            const barColor = percentage > 50 ? '#10b981' : percentage > 20 ? '#f59e0b' : '#ef4444';
+            const shortName = modelId.replace('models/', '').replace('publishers/google/', '');
+            groupHtml += `
+                <div class="quota-item">
+                    <div class="quota-model-name" title="${modelId}">${shortName}</div>
+                    <div class="quota-bar-container">
+                        <div class="quota-bar" style="width: ${percentage}%; background: ${barColor};"></div>
+                    </div>
+                    <div class="quota-info-row">
+                        <span class="quota-reset">重置: ${quota.resetTime}</span>
+                        <span class="quota-percentage">${percentage}%</span>
+                    </div>
+                </div>
+            `;
+        });
+        groupHtml += '</div>';
+        return groupHtml;
+    };
+    
+    html += renderGroup(grouped.claude, '🤖 Claude');
+    html += renderGroup(grouped.gemini, '💎 Gemini');
+    html += renderGroup(grouped.other, '🔧 其他');
+    
+    quotaContent.innerHTML = html;
+}
+
+// 切换请求次数输入框的显示
+function toggleRequestCountInput() {
+    const strategy = document.getElementById('rotationStrategy').value;
+    const requestCountGroup = document.getElementById('requestCountGroup');
+    if (requestCountGroup) {
+        requestCountGroup.style.display = strategy === 'request_count' ? 'block' : 'none';
+    }
+}
+
+// 加载轮询策略状态
+async function loadRotationStatus() {
+    try {
+        const response = await authFetch('/admin/rotation', {
+            headers: { 'Authorization': `Bearer ${authToken}` }
+        });
+        const data = await response.json();
+        if (data.success) {
+            const { strategy, requestCount, currentIndex, tokenCounts } = data.data;
+            const strategyNames = {
+                'round_robin': '均衡负载',
+                'quota_exhausted': '额度耗尽切换',
+                'request_count': '自定义次数'
+            };
+            const statusEl = document.getElementById('currentRotationInfo');
+            if (statusEl) {
+                let statusText = `${strategyNames[strategy] || strategy}`;
+                if (strategy === 'request_count') {
+                    statusText += ` (每${requestCount}次)`;
+                }
+                statusText += ` | 当前索引: ${currentIndex}`;
+                statusEl.textContent = statusText;
+            }
+        }
+    } catch (error) {
+        console.error('加载轮询状态失败:', error);
+    }
 }
 
 async function loadConfig() {
@@ -597,6 +1195,12 @@ async function loadConfig() {
             const form = document.getElementById('configForm');
             const { env, json } = data.data;
             
+            // 更新服务器信息显示
+            const serverInfo = document.getElementById('serverInfo');
+            if (serverInfo && json.server) {
+                serverInfo.textContent = `${json.server.host || '0.0.0.0'}:${json.server.port || 8045}`;
+            }
+            
             // 加载 .env 配置
             Object.entries(env).forEach(([key, value]) => {
                 const input = form.elements[key];
@@ -608,19 +1212,33 @@ async function loadConfig() {
                 if (form.elements['PORT']) form.elements['PORT'].value = json.server.port || '';
                 if (form.elements['HOST']) form.elements['HOST'].value = json.server.host || '';
                 if (form.elements['MAX_REQUEST_SIZE']) form.elements['MAX_REQUEST_SIZE'].value = json.server.maxRequestSize || '';
+                if (form.elements['HEARTBEAT_INTERVAL']) form.elements['HEARTBEAT_INTERVAL'].value = json.server.heartbeatInterval || '';
+                if (form.elements['MEMORY_THRESHOLD']) form.elements['MEMORY_THRESHOLD'].value = json.server.memoryThreshold || '';
             }
             if (json.defaults) {
                 if (form.elements['DEFAULT_TEMPERATURE']) form.elements['DEFAULT_TEMPERATURE'].value = json.defaults.temperature ?? '';
                 if (form.elements['DEFAULT_TOP_P']) form.elements['DEFAULT_TOP_P'].value = json.defaults.topP ?? '';
                 if (form.elements['DEFAULT_TOP_K']) form.elements['DEFAULT_TOP_K'].value = json.defaults.topK ?? '';
                 if (form.elements['DEFAULT_MAX_TOKENS']) form.elements['DEFAULT_MAX_TOKENS'].value = json.defaults.maxTokens ?? '';
+                if (form.elements['DEFAULT_THINKING_BUDGET']) form.elements['DEFAULT_THINKING_BUDGET'].value = json.defaults.thinkingBudget ?? '';
             }
             if (json.other) {
                 if (form.elements['TIMEOUT']) form.elements['TIMEOUT'].value = json.other.timeout ?? '';
-                if (form.elements['MAX_IMAGES']) form.elements['MAX_IMAGES'].value = json.other.maxImages ?? '';
-                if (form.elements['USE_NATIVE_AXIOS']) form.elements['USE_NATIVE_AXIOS'].value = json.other.useNativeAxios ? 'true' : 'false';
                 if (form.elements['SKIP_PROJECT_ID_FETCH']) form.elements['SKIP_PROJECT_ID_FETCH'].value = json.other.skipProjectIdFetch ? 'true' : 'false';
             }
+            // 加载轮询策略配置
+            if (json.rotation) {
+                if (form.elements['ROTATION_STRATEGY']) {
+                    form.elements['ROTATION_STRATEGY'].value = json.rotation.strategy || 'round_robin';
+                }
+                if (form.elements['ROTATION_REQUEST_COUNT']) {
+                    form.elements['ROTATION_REQUEST_COUNT'].value = json.rotation.requestCount || 10;
+                }
+                toggleRequestCountInput();
+            }
+            
+            // 加载轮询状态
+            loadRotationStatus();
         }
     } catch (error) {
         showToast('加载配置失败: ' + error.message, 'error');
@@ -639,7 +1257,8 @@ document.getElementById('configForm').addEventListener('submit', async (e) => {
         server: {},
         api: {},
         defaults: {},
-        other: {}
+        other: {},
+        rotation: {}
     };
     
     Object.entries(allConfig).forEach(([key, value]) => {
@@ -647,28 +1266,39 @@ document.getElementById('configForm').addEventListener('submit', async (e) => {
             envConfig[key] = value;
         } else {
             // 映射到 config.json 结构
-            if (key === 'PORT') jsonConfig.server.port = parseInt(value);
-            else if (key === 'HOST') jsonConfig.server.host = value;
-            else if (key === 'MAX_REQUEST_SIZE') jsonConfig.server.maxRequestSize = value;
-            else if (key === 'API_URL') jsonConfig.api.url = value;
-            else if (key === 'API_MODELS_URL') jsonConfig.api.modelsUrl = value;
-            else if (key === 'API_NO_STREAM_URL') jsonConfig.api.noStreamUrl = value;
-            else if (key === 'API_HOST') jsonConfig.api.host = value;
-            else if (key === 'API_USER_AGENT') jsonConfig.api.userAgent = value;
-            else if (key === 'DEFAULT_TEMPERATURE') jsonConfig.defaults.temperature = parseFloat(value);
-            else if (key === 'DEFAULT_TOP_P') jsonConfig.defaults.topP = parseFloat(value);
-            else if (key === 'DEFAULT_TOP_K') jsonConfig.defaults.topK = parseInt(value);
-            else if (key === 'DEFAULT_MAX_TOKENS') jsonConfig.defaults.maxTokens = parseInt(value);
-            else if (key === 'USE_NATIVE_AXIOS') jsonConfig.other.useNativeAxios = value !== 'false';
-            else if (key === 'TIMEOUT') jsonConfig.other.timeout = parseInt(value);
-            else if (key === 'MAX_IMAGES') jsonConfig.other.maxImages = parseInt(value);
+            if (key === 'PORT') jsonConfig.server.port = parseInt(value) || undefined;
+            else if (key === 'HOST') jsonConfig.server.host = value || undefined;
+            else if (key === 'MAX_REQUEST_SIZE') jsonConfig.server.maxRequestSize = value || undefined;
+            else if (key === 'HEARTBEAT_INTERVAL') jsonConfig.server.heartbeatInterval = parseInt(value) || undefined;
+            else if (key === 'MEMORY_THRESHOLD') jsonConfig.server.memoryThreshold = parseInt(value) || undefined;
+            else if (key === 'DEFAULT_TEMPERATURE') jsonConfig.defaults.temperature = parseFloat(value) || undefined;
+            else if (key === 'DEFAULT_TOP_P') jsonConfig.defaults.topP = parseFloat(value) || undefined;
+            else if (key === 'DEFAULT_TOP_K') jsonConfig.defaults.topK = parseInt(value) || undefined;
+            else if (key === 'DEFAULT_MAX_TOKENS') jsonConfig.defaults.maxTokens = parseInt(value) || undefined;
+            else if (key === 'DEFAULT_THINKING_BUDGET') jsonConfig.defaults.thinkingBudget = parseInt(value) || undefined;
+            else if (key === 'TIMEOUT') jsonConfig.other.timeout = parseInt(value) || undefined;
             else if (key === 'SKIP_PROJECT_ID_FETCH') jsonConfig.other.skipProjectIdFetch = value === 'true';
+            else if (key === 'ROTATION_STRATEGY') jsonConfig.rotation.strategy = value || undefined;
+            else if (key === 'ROTATION_REQUEST_COUNT') jsonConfig.rotation.requestCount = parseInt(value) || undefined;
             else envConfig[key] = value;
         }
     });
     
+    // 清理undefined值
+    Object.keys(jsonConfig).forEach(section => {
+        Object.keys(jsonConfig[section]).forEach(key => {
+            if (jsonConfig[section][key] === undefined) {
+                delete jsonConfig[section][key];
+            }
+        });
+        if (Object.keys(jsonConfig[section]).length === 0) {
+            delete jsonConfig[section];
+        }
+    });
+    
     showLoading('正在保存配置...');
     try {
+        // 先保存通用配置
         const response = await authFetch('/admin/config', {
             method: 'PUT',
             headers: {
@@ -679,9 +1309,23 @@ document.getElementById('configForm').addEventListener('submit', async (e) => {
         });
         
         const data = await response.json();
+        
+        // 如果有轮询配置，单独更新轮询策略（触发热更新）
+        if (jsonConfig.rotation && Object.keys(jsonConfig.rotation).length > 0) {
+            await authFetch('/admin/rotation', {
+                method: 'PUT',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${authToken}`
+                },
+                body: JSON.stringify(jsonConfig.rotation)
+            });
+        }
+        
         hideLoading();
         if (data.success) {
-            showToast(data.message, 'success');
+            showToast('配置已保存', 'success');
+            loadConfig(); // 重新加载以更新显示
         } else {
             showToast(data.message || '保存失败', 'error');
         }

public/index.html

@@ -3,14 +3,18 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
-    <title>Token 管理系统</title>
+    <title>Token 管理</title>
+    <!-- 引入 MiSans 字体 -->
+    <link rel="stylesheet" href="https://font.sec.miui.com/font/css?family=MiSans:100,200,300,400,450,500,600,650,700,900:Chinese_Simplify,Latin&display=swap">
+    <!-- 引入 Ubuntu Mono 等宽字体 -->
+    <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Ubuntu+Mono:wght@400;700&display=swap">
     <link rel="stylesheet" href="style.css">
 </head>
 <body>
     <div class="container">
         <!-- 登录表单 -->
         <div id="loginForm" class="login-form">
-            <h2>🔐 Token 管理系统</h2>
+            <h2>Token 管理</h2>
             <form id="login">
                 <div class="form-group">
                     <label>👤 用户名</label>
@@ -27,80 +31,179 @@
         <!-- 主内容 -->
         <div id="mainContent" class="main-content hidden">
             <div class="header">
-                <div class="tabs">
-                    <button class="tab active" onclick="switchTab('tokens')">🎯 Token管理</button>
-                    <button class="tab" onclick="switchTab('settings')">⚙️ 设置</button>
+            <div class="tabs">
+                <button class="tab active" onclick="switchTab('tokens')">🎯 Token</button>
+                <button class="tab" onclick="switchTab('settings')">⚙️ 设置</button>
+            </div>
+                <div class="header-right">
+                    <span class="server-info" id="serverInfo"></span>
+                    <button onclick="logout()">🚪 退出</button>
                 </div>
-                <button onclick="logout()">🚪 退出</button>
             </div>
             <div class="content">
                 <!-- Token管理页面 -->
                 <div id="tokensPage">
-                <!-- 统计卡片 -->
-                <div class="stats">
-                    <div class="stat-card">
-                        <div class="stat-value" id="totalTokens">0</div>
-                        <div class="stat-label">总Token数</div>
-                    </div>
-                    <div class="stat-card" style="background: linear-gradient(135deg, var(--success), #059669);">
-                        <div class="stat-value" id="enabledTokens">0</div>
-                        <div class="stat-label">已启用</div>
-                    </div>
-                    <div class="stat-card" style="background: linear-gradient(135deg, var(--danger), #dc2626);">
-                        <div class="stat-value" id="disabledTokens">0</div>
-                        <div class="stat-label">已禁用</div>
+                    <!-- 统计卡片 + 操作按钮 合并 -->
+                    <div class="top-bar">
+                        <div class="stats-inline">
+                            <div class="stat-item">
+                                <span class="stat-num" id="totalTokens">0</span>
+                                <span class="stat-text">总数</span>
+                            </div>
+                            <div class="stat-item success">
+                                <span class="stat-num" id="enabledTokens">0</span>
+                                <span class="stat-text">启用</span>
+                            </div>
+                            <div class="stat-item danger">
+                                <span class="stat-num" id="disabledTokens">0</span>
+                                <span class="stat-text">禁用</span>
+                            </div>
+                        </div>
+                        <div class="action-btns">
+                            <button type="button" onclick="showOAuthModal()" class="btn btn-success btn-sm">🔐 OAuth</button>
+                            <button type="button" onclick="showManualModal()" class="btn btn-secondary btn-sm">✏️ 手动</button>
+                            <button type="button" onclick="loadTokens()" class="btn btn-warning btn-sm">🔄 刷新</button>
+                            <button type="button" onclick="toggleSensitiveInfo()" class="btn btn-sm" id="toggleSensitiveBtn" title="隐藏/显示敏感信息">👁️ 显示</button>
+                        </div>
                     </div>
-                </div>
 
-                <!-- 添加Token按钮组 -->
-                <div class="add-form">
-                    <h3>➕ 添加新Token<span class="help-tip" title="支持OAuth登录或手动填入Token">?</span></h3>
-                    <div class="btn-group">
-                        <button type="button" onclick="showOAuthModal()" class="btn btn-success">🔐 OAuth登录</button>
-                        <button type="button" onclick="showManualModal()" class="btn btn-secondary">✏️ 手动填入</button>
-                        <button type="button" onclick="loadTokens()" class="btn btn-warning">🔄 刷新</button>
-                    </div>
-                </div>
-
-                <!-- Token网格 -->
-                <div id="tokenList" class="token-grid">
-                    <div class="empty-state">
-                        <div class="empty-state-icon">📦</div>
-                        <div class="empty-state-text">暂无Token</div>
-                        <div class="empty-state-hint">点击上方按钮添加您的第一个Token</div>
+                    <!-- Token网格 -->
+                    <div id="tokenList" class="token-grid">
+                        <div class="empty-state">
+                            <div class="empty-state-icon">📦</div>
+                            <div class="empty-state-text">暂无Token</div>
+                            <div class="empty-state-hint">点击上方OAuth按钮添加Token</div>
+                        </div>
                     </div>
                 </div>
-                </div>
 
                 <!-- 设置页面 -->
                 <div id="settingsPage" class="hidden">
-                    <h3>⚙️ 系统配置</h3>
                     <form id="configForm" class="config-form">
-                        <div class="config-section">
-                            <h4>服务器配置</h4>
-                            <div class="form-group"><label>端口 PORT</label><input type="number" name="PORT"></div>
-                            <div class="form-group"><label>监听地址 HOST</label><input type="text" name="HOST"></div>
-                        </div>
-                        <div class="config-section">
-                            <h4>默认参数</h4>
-                            <div class="form-group"><label>温度 TEMPERATURE</label><input type="number" step="0.1" name="DEFAULT_TEMPERATURE"></div>
-                            <div class="form-group"><label>Top P</label><input type="number" step="0.01" name="DEFAULT_TOP_P"></div>
-                            <div class="form-group"><label>Top K</label><input type="number" name="DEFAULT_TOP_K"></div>
-                            <div class="form-group"><label>最大Token数</label><input type="number" name="DEFAULT_MAX_TOKENS"></div>
-                        </div>
-                        <div class="config-section">
-                            <h4>安全配置</h4>
-                            <div class="form-group"><label>API密钥</label><input type="text" name="API_KEY"></div>
-                            <div class="form-group"><label>最大请求大小</label><input type="text" name="MAX_REQUEST_SIZE"></div>
+                        <div class="config-grid">
+                            <!-- 服务器配置 -->
+                            <div class="config-section">
+                                <h4>🖥️ 服务器</h4>
+                                <div class="form-row-inline">
+                                    <div class="form-group compact">
+                                        <label>端口</label>
+                                        <input type="number" name="PORT" placeholder="8045">
+                                    </div>
+                                    <div class="form-group compact">
+                                        <label>监听地址</label>
+                                        <input type="text" name="HOST" placeholder="0.0.0.0">
+                                    </div>
+                                </div>
+                                <div class="form-row-inline">
+                                    <div class="form-group compact">
+                                        <label>最大请求大小</label>
+                                        <input type="text" name="MAX_REQUEST_SIZE" placeholder="500mb">
+                                    </div>
+                                    <div class="form-group compact">
+                                        <label>API密钥</label>
+                                        <input type="password" name="API_KEY" placeholder="留空则不验证">
+                                    </div>
+                                </div>
+                                <div class="form-group compact">
+                                    <label>图片访问链接</label>
+                                    <input type="text" name="IMAGE_BASE_URL" placeholder="https://your-domain.zeabur.app">
+                                </div>
+                                <div class="form-group compact">
+                                    <label>代理地址</label>
+                                    <input type="text" name="PROXY" placeholder="http://127.0.0.1:7890">
+                                </div>
+                            </div>
+
+                            <!-- 模型默认参数 -->
+                            <div class="config-section">
+                                <h4>🎛️ 模型参数</h4>
+                                <div class="form-row-inline">
+                                    <div class="form-group compact">
+                                        <label>温度</label>
+                                        <input type="number" step="0.1" name="DEFAULT_TEMPERATURE" placeholder="1">
+                                    </div>
+                                    <div class="form-group compact">
+                                        <label>Top P</label>
+                                        <input type="number" step="0.01" name="DEFAULT_TOP_P" placeholder="1">
+                                    </div>
+                                </div>
+                                <div class="form-row-inline">
+                                    <div class="form-group compact">
+                                        <label>Top K</label>
+                                        <input type="number" name="DEFAULT_TOP_K" placeholder="50">
+                                    </div>
+                                    <div class="form-group compact">
+                                        <label>最大Token</label>
+                                        <input type="number" name="DEFAULT_MAX_TOKENS" placeholder="32000">
+                                    </div>
+                                </div>
+                                <div class="form-group compact highlight">
+                                    <label>思考预算 <span class="help-tip" title="思考模型的思考token预算，影响推理深度">?</span></label>
+                                    <input type="number" name="DEFAULT_THINKING_BUDGET" placeholder="16000">
+                                </div>
+                                <div class="form-group compact">
+                                    <label>系统提示词</label>
+                                    <textarea name="SYSTEM_INSTRUCTION" rows="3" placeholder="可选的系统提示词"></textarea>
+                                </div>
+                            </div>
+
+                            <!-- 轮询策略与性能优化 -->
+                            <div class="config-section">
+                                <h4>🔄 轮询与性能</h4>
+                                <div class="form-row-inline">
+                                    <div class="form-group compact">
+                                        <label>策略模式 <span class="help-tip" title="均衡负载：每次请求切换Token&#10;额度耗尽：用完额度才切换&#10;自定义次数：指定次数后切换">?</span></label>
+                                        <select name="ROTATION_STRATEGY" id="rotationStrategy" onchange="toggleRequestCountInput()">
+                                            <option value="round_robin">均衡负载</option>
+                                            <option value="quota_exhausted">额度耗尽切换</option>
+                                            <option value="request_count">自定义次数</option>
+                                        </select>
+                                    </div>
+                                    <div class="form-group compact" id="requestCountGroup">
+                                        <label>每Token请求次数 <span class="help-tip" title="自定义次数模式下，每个Token处理多少次请求后切换">?</span></label>
+                                        <input type="number" name="ROTATION_REQUEST_COUNT" min="1" placeholder="10">
+                                    </div>
+                                </div>
+                                <div class="rotation-status" id="rotationStatus">
+                                    <span class="rotation-label">当前状态:</span>
+                                    <span id="currentRotationInfo">加载中...</span>
+                                </div>
+                                <div class="form-row-inline">
+                                    <div class="form-group compact">
+                                        <label>超时(ms)</label>
+                                        <input type="number" name="TIMEOUT" placeholder="300000">
+                                    </div>
+                                    <div class="form-group compact">
+                                        <label>跳过验证</label>
+                                        <select name="SKIP_PROJECT_ID_FETCH">
+                                            <option value="false">否</option>
+                                            <option value="true">是</option>
+                                        </select>
+                                    </div>
+                                </div>
+                                <div class="form-row-inline">
+                                    <div class="form-group compact">
+                                        <label>心跳间隔(ms) <span class="help-tip" title="SSE心跳间隔，防止CF超时断连">?</span></label>
+                                        <input type="number" name="HEARTBEAT_INTERVAL" placeholder="15000">
+                                    </div>
+                                    <div class="form-group compact">
+                                        <label>内存阈值(MB) <span class="help-tip" title="超过此值触发GC清理">?</span></label>
+                                        <input type="number" name="MEMORY_THRESHOLD" placeholder="100">
+                                    </div>
+                                </div>
+                                <div class="form-group compact">
+                                    <label>🔤 界面字体大小 (px)</label>
+                                    <div class="font-size-control">
+                                        <input type="range" id="fontSizeRange" min="10" max="24" value="18" oninput="changeFontSize(this.value)">
+                                        <input type="number" id="fontSizeInput" min="10" max="24" value="18" onchange="changeFontSize(this.value)" style="width: 60px;">
+                                    </div>
+                                </div>
+                            </div>
                         </div>
-                        <div class="config-section">
-                            <h4>其他配置</h4>
-                            <div class="form-group"><label>超时时间(ms)</label><input type="number" name="TIMEOUT"></div>
-                            <div class="form-group"><label>代理地址</label><input type="text" name="PROXY" placeholder="http://127.0.0.1:7897"></div>
-                            <div class="form-group"><label>跳过ProjectId验证</label><select name="SKIP_PROJECT_ID_FETCH"><option value="false">否</option><option value="true">是</option></select></div>
-                            <div class="form-group"><label>系统提示词</label><textarea name="SYSTEM_INSTRUCTION" rows="3"></textarea></div>
+                        <div class="config-actions">
+                            <button type="submit" class="btn btn-success">💾 保存配置</button>
+                            <button type="button" onclick="loadConfig()" class="btn btn-secondary">🔄 重新加载</button>
                         </div>
-                        <button type="submit" class="btn btn-success">💾 保存配置</button>
                     </form>
                 </div>
             </div>

public/style.css

@@ -1,16 +1,17 @@
 :root {
-    --primary: #6366f1;
-    --primary-dark: #4f46e5;
+    --primary: #0891b2;
+    --primary-dark: #0e7490;
     --success: #10b981;
     --danger: #ef4444;
     --warning: #f59e0b;
-    --info: #3b82f6;
+    --info: #06b6d4;
     --bg: #f8fafc;
     --card: #ffffff;
     --text: #1e293b;
     --text-light: #64748b;
     --border: #e2e8f0;
-    --shadow: 0 4px 6px -1px rgba(0,0,0,0.1), 0 2px 4px -1px rgba(0,0,0,0.06);
+    --shadow: 0 2px 8px rgba(0,0,0,0.08);
+    --font-size-base: 18px;
 }
 
 @media (prefers-color-scheme: dark) {
@@ -23,164 +24,1215 @@
     }
 }
 
-.toast { position: fixed; top: 20px; right: 20px; background: var(--card); border-radius: 12px; padding: 16px 20px; box-shadow: 0 10px 40px rgba(0,0,0,0.2); z-index: 9999; display: flex; align-items: center; gap: 12px; min-width: 280px; max-width: 400px; animation: slideIn 0.3s ease; border-left: 4px solid var(--primary); }
-.toast.success { border-left-color: var(--success); }
-.toast.error { border-left-color: var(--danger); }
-.toast.warning { border-left-color: var(--warning); }
-.toast.info { border-left-color: var(--info); }
-.toast-icon { font-size: 24px; flex-shrink: 0; }
-.toast-content { flex: 1; }
-.toast-title { font-weight: 600; margin-bottom: 4px; color: var(--text); }
-.toast-message { font-size: 14px; color: var(--text-light); }
+* { margin: 0; padding: 0; box-sizing: border-box; }
 
-@keyframes slideIn { from { transform: translateX(400px); opacity: 0; } to { transform: translateX(0); opacity: 1; } }
-@keyframes slideOut { from { transform: translateX(0); opacity: 1; } to { transform: translateX(400px); opacity: 0; } }
+/* 固定背景图片 - 使用静态风景图（清晰无模糊） */
+body::before {
+    content: '';
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background-image: url('https://images.unsplash.com/photo-1506905925346-21bda4d32df4?w=1920&q=80');
+    background-size: cover;
+    background-position: center;
+    background-repeat: no-repeat;
+    z-index: -1;
+}
 
-.modal { position: fixed; inset: 0; background: rgba(0,0,0,0.5); z-index: 9998; display: flex; align-items: center; justify-content: center; padding: 20px; animation: fadeIn 0.2s; }
-.modal-content { background: var(--card); border-radius: 16px; padding: 24px; max-width: 400px; width: 100%; box-shadow: 0 20px 60px rgba(0,0,0,0.3); animation: scaleIn 0.2s; }
-.modal-title { font-size: 20px; font-weight: 700; margin-bottom: 12px; color: var(--text); }
-.modal-message { color: var(--text-light); margin-bottom: 24px; line-height: 1.6; }
-.modal-actions { display: flex; gap: 12px; }
-.modal-actions button { flex: 1; }
-.form-modal .modal-content { max-width: 500px; }
-.form-modal input { margin-bottom: 12px; }
-.form-modal .form-row { display: flex; flex-direction: column; gap: 12px; margin-bottom: 16px; }
-.form-modal .oauth-steps { background: rgba(59,130,246,0.1); padding: 16px; border-radius: 8px; margin-bottom: 16px; border: 2px solid var(--info); }
-.form-modal .oauth-steps p { margin-bottom: 8px; font-size: 14px; }
-.form-modal .oauth-steps p:last-child { margin-bottom: 0; }
+/* iOS风格滚动条 */
+::-webkit-scrollbar {
+    width: 6px;
+    height: 6px;
+}
+::-webkit-scrollbar-track {
+    background: transparent;
+}
+::-webkit-scrollbar-thumb {
+    background: rgba(0, 0, 0, 0.2);
+    border-radius: 10px;
+}
+::-webkit-scrollbar-thumb:hover {
+    background: rgba(0, 0, 0, 0.35);
+}
+::-webkit-scrollbar-thumb:active {
+    background: rgba(0, 0, 0, 0.5);
+}
+::-webkit-scrollbar-corner {
+    background: transparent;
+}
+/* 暗色模式下的滚动条 */
+@media (prefers-color-scheme: dark) {
+    ::-webkit-scrollbar-thumb {
+        background: rgba(255, 255, 255, 0.2);
+    }
+    ::-webkit-scrollbar-thumb:hover {
+        background: rgba(255, 255, 255, 0.35);
+    }
+    ::-webkit-scrollbar-thumb:active {
+        background: rgba(255, 255, 255, 0.5);
+    }
+}
+/* Firefox 滚动条 */
+* {
+    scrollbar-width: thin;
+    scrollbar-color: rgba(0, 0, 0, 0.2) transparent;
+}
+@media (prefers-color-scheme: dark) {
+    * {
+        scrollbar-color: rgba(255, 255, 255, 0.2) transparent;
+    }
+}
+html {
+    font-size: var(--font-size-base);
+}
+body {
+    font-family: 'Ubuntu Mono', 'MiSans', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    background: var(--bg);
+    color: var(--text);
+    line-height: 1.5;
+    min-height: 100vh;
+    font-size: 1rem;
+    /* 字体渲染优化 */
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+    text-rendering: optimizeLegibility;
+    font-weight: 400;
+}
 
-@keyframes fadeIn { from { opacity: 0; } to { opacity: 1; } }
-@keyframes scaleIn { from { transform: scale(0.9); opacity: 0; } to { transform: scale(1); opacity: 1; } }
+/* 确保所有元素继承字体 */
+*, *::before, *::after {
+    font-family: inherit;
+}
 
-.loading-overlay { position: fixed; inset: 0; background: rgba(0,0,0,0.7); z-index: 9999; display: flex; align-items: center; justify-content: center; flex-direction: column; gap: 16px; }
-.spinner { width: 48px; height: 48px; border: 4px solid rgba(255,255,255,0.2); border-top-color: white; border-radius: 50%; animation: spin 0.8s linear infinite; }
-.loading-text { color: white; font-size: 16px; font-weight: 500; }
-.help-tip { display: inline-flex; align-items: center; justify-content: center; width: 18px; height: 18px; border-radius: 50%; background: var(--info); color: white; font-size: 12px; font-weight: 600; cursor: help; margin-left: 6px; }
-.empty-state { text-align: center; padding: 60px 20px; color: var(--text-light); }
-.empty-state-icon { font-size: 64px; margin-bottom: 16px; opacity: 0.5; }
-.empty-state-text { font-size: 18px; font-weight: 500; margin-bottom: 8px; }
-.empty-state-hint { font-size: 14px; }
+/* 等宽字体用于代码/Token显示 */
+code, pre, .mono, .token-display {
+    font-family: 'Ubuntu Mono', 'Consolas', 'Monaco', monospace !important;
+}
 
-* { margin: 0; padding: 0; box-sizing: border-box; }
-body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: var(--bg); color: var(--text); line-height: 1.6; transition: background 0.3s; min-height: 100vh; }
-.container { max-width: 1400px; margin: 0 auto; padding: 1rem; height: 100vh; display: flex; align-items: center; justify-content: center; }
-
-.login-form { background: var(--card); border-radius: 1.5rem; box-shadow: var(--shadow); max-width: 480px; width: 100%; padding: 3rem; }
-.login-form h2 { text-align: center; margin-bottom: 2.5rem; background: linear-gradient(135deg, var(--primary), var(--primary-dark)); -webkit-background-clip: text; -webkit-text-fill-color: transparent; background-clip: text; font-size: 2rem; font-weight: 700; }
-.form-group { margin-bottom: 1.5rem; }
-label { display: block; margin-bottom: 0.75rem; font-weight: 600; color: var(--text); font-size: 0.95rem; }
-input { width: 100%; min-height: 48px; padding: 0.875rem 1rem; border: 2px solid var(--border); border-radius: 0.75rem; font-size: 0.95rem; line-height: 1.5; background: var(--card); color: var(--text); transition: all 0.2s; text-indent: 0.25rem; -webkit-appearance: none; }
-input:focus { outline: none; border-color: var(--primary); box-shadow: 0 0 0 4px rgba(99,102,241,0.1); }
-input::placeholder { color: var(--text-light); opacity: 0.6; }
-
-button { width: 100%; min-height: 52px; padding: 1rem; background: linear-gradient(135deg, var(--primary), var(--primary-dark)); color: white; border: none; border-radius: 0.75rem; cursor: pointer; font-size: 1.05rem; font-weight: 600; letter-spacing: 0.5px; transition: all 0.2s; box-shadow: 0 4px 12px rgba(99,102,241,0.2); position: relative; }
-button:hover:not(:disabled) { transform: translateY(-2px); box-shadow: 0 8px 24px rgba(99,102,241,0.35); }
-button:active:not(:disabled) { transform: translateY(0); box-shadow: 0 2px 8px rgba(99,102,241,0.25); }
+.container { 
+    max-width: 1400px; 
+    margin: 0 auto; 
+    padding: 0.5rem; 
+    height: 100vh; 
+    display: flex; 
+    align-items: center; 
+    justify-content: center; 
+}
+
+/* 登录表单 */
+.login-form {
+    background: rgba(255, 255, 255, 0.6);
+    backdrop-filter: blur(24px) saturate(180%);
+    -webkit-backdrop-filter: blur(24px) saturate(180%);
+    border-radius: 1rem;
+    box-shadow: 0 8px 32px rgba(0,0,0,0.2);
+    max-width: 400px;
+    width: 100%;
+    padding: 2rem;
+    border: 1px solid rgba(255, 255, 255, 0.5);
+}
+@media (prefers-color-scheme: dark) {
+    .login-form {
+        background: rgba(30, 41, 59, 0.65);
+        border: 1px solid rgba(255, 255, 255, 0.2);
+    }
+}
+.login-form h2 { 
+    text-align: center; 
+    margin-bottom: 1.5rem; 
+    background: linear-gradient(135deg, var(--primary), var(--primary-dark)); 
+    -webkit-background-clip: text; 
+    -webkit-text-fill-color: transparent; 
+    background-clip: text; 
+    font-size: 1.5rem; 
+    font-weight: 700; 
+}
+
+.form-group { margin-bottom: 1rem; }
+label { 
+    display: block; 
+    margin-bottom: 0.5rem; 
+    font-weight: 600; 
+    color: var(--text); 
+    font-size: 0.875rem; 
+}
+input, select, textarea { 
+    width: 100%; 
+    min-height: 40px; 
+    padding: 0.5rem 0.75rem; 
+    border: 1.5px solid var(--border); 
+    border-radius: 0.5rem; 
+    font-size: 0.875rem; 
+    background: var(--card); 
+    color: var(--text); 
+    transition: all 0.2s; 
+}
+input:focus, select:focus, textarea:focus {
+    outline: none;
+    border-color: var(--primary);
+    box-shadow: 0 0 0 3px rgba(8,145,178,0.1);
+}
+input::placeholder, textarea::placeholder { color: var(--text-light); opacity: 0.6; }
+
+button {
+    width: 100%;
+    min-height: 44px;
+    padding: 0.75rem;
+    background: linear-gradient(135deg, var(--primary), var(--primary-dark));
+    color: white;
+    border: none;
+    border-radius: 0.5rem;
+    cursor: pointer;
+    font-size: 0.95rem;
+    font-weight: 600;
+    transition: all 0.2s;
+    box-shadow: 0 2px 8px rgba(8,145,178,0.2);
+}
+button:hover:not(:disabled) { transform: translateY(-1px); box-shadow: 0 4px 12px rgba(8,145,178,0.3); }
+button:active:not(:disabled) { transform: translateY(0); }
 button:disabled { opacity: 0.7; cursor: not-allowed; }
-button.loading::after { content: ''; position: absolute; width: 16px; height: 16px; margin-left: 10px; border: 2px solid rgba(255,255,255,0.3); border-top-color: white; border-radius: 50%; animation: spin 0.6s linear infinite; }
+button.loading::after { 
+    content: ''; 
+    position: absolute; 
+    width: 14px; 
+    height: 14px; 
+    margin-left: 8px; 
+    border: 2px solid rgba(255,255,255,0.3); 
+    border-top-color: white; 
+    border-radius: 50%; 
+    animation: spin 0.6s linear infinite; 
+}
 
 @keyframes spin { to { transform: rotate(360deg); } }
 
-.main-content { background: var(--card); border-radius: 1.5rem; box-shadow: var(--shadow); width: 100%; max-width: 1400px; height: calc(100vh - 2rem); display: flex; flex-direction: column; }
-.header { display: flex; justify-content: space-between; align-items: center; padding: 1.5rem 2rem; border-bottom: 2px solid var(--border); flex-shrink: 0; }
-.header h1 { font-size: 1.75rem; background: linear-gradient(135deg, var(--primary), var(--primary-dark)); -webkit-background-clip: text; -webkit-text-fill-color: transparent; background-clip: text; font-weight: 700; }
-.header button { width: auto; padding: 0.625rem 1.5rem; font-size: 0.9rem; }
-.tabs { display: flex; gap: 0.5rem; }
-.tab { background: transparent; color: var(--text-light); border: none; padding: 0.625rem 1.25rem; border-radius: 0.5rem; cursor: pointer; font-weight: 600; transition: all 0.2s; }
+/* 主内容区 */
+.main-content {
+    background: rgba(255, 255, 255, 0.6);
+    backdrop-filter: blur(24px) saturate(180%);
+    -webkit-backdrop-filter: blur(24px) saturate(180%);
+    border-radius: 1rem;
+    box-shadow: 0 8px 32px rgba(0,0,0,0.2);
+    width: 100%;
+    max-width: 1400px;
+    height: calc(100vh - 1rem);
+    display: flex;
+    flex-direction: column;
+    border: 1px solid rgba(255, 255, 255, 0.5);
+}
+@media (prefers-color-scheme: dark) {
+    .main-content {
+        background: rgba(30, 41, 59, 0.65);
+        border: 1px solid rgba(255, 255, 255, 0.2);
+    }
+}
+
+.header { 
+    display: flex; 
+    justify-content: space-between; 
+    align-items: center; 
+    padding: 0.75rem 1rem; 
+    border-bottom: 1.5px solid var(--border); 
+    flex-shrink: 0; 
+}
+.header-right { 
+    display: flex; 
+    align-items: center; 
+    gap: 0.75rem; 
+}
+.server-info {
+    font-size: 0.75rem;
+    color: var(--text-light);
+    background: var(--bg);
+    padding: 0.25rem 0.5rem;
+    border-radius: 0.25rem;
+}
+.header button { 
+    width: auto; 
+    padding: 0.5rem 1rem; 
+    font-size: 0.8rem; 
+    min-height: 36px; 
+}
+
+.tabs { display: flex; gap: 0.25rem; }
+.tab { 
+    background: transparent; 
+    color: var(--text-light); 
+    border: none; 
+    padding: 0.5rem 1rem; 
+    border-radius: 0.375rem; 
+    cursor: pointer; 
+    font-weight: 600; 
+    font-size: 0.875rem; 
+    transition: all 0.2s; 
+    min-height: 36px; 
+    box-shadow: none; 
+}
 .tab:hover { background: var(--bg); color: var(--text); }
-.tab.active { background: linear-gradient(135deg, var(--primary), var(--primary-dark)); color: white; box-shadow: 0 2px 8px rgba(99,102,241,0.3); }
-.content { padding: 2rem; flex: 1; overflow-y: auto; }
-.content::-webkit-scrollbar { width: 8px; }
-.content::-webkit-scrollbar-track { background: var(--bg); border-radius: 4px; }
-.content::-webkit-scrollbar-thumb { background: var(--border); border-radius: 4px; }
-.content::-webkit-scrollbar-thumb:hover { background: var(--text-light); }
-
-.add-form { background: var(--bg); padding: 1.5rem; border-radius: 1rem; margin-bottom: 2rem; border: 2px solid var(--border); }
-.add-form h3 { margin-bottom: 1.25rem; font-size: 1.25rem; font-weight: 600; }
-.btn-group { display: flex; gap: 0.75rem; margin-bottom: 1.25rem; flex-wrap: wrap; }
-.btn-group .btn { width: auto; flex: 1; min-width: 140px; }
-.oauth-box { background: rgba(251,191,36,0.1); padding: 1.5rem; border-radius: 1rem; margin-bottom: 1.25rem; border: 2px solid var(--warning); }
-.oauth-box p { margin-bottom: 1rem; color: var(--text); font-size: 0.95rem; }
-.form-row { display: flex; gap: 0.75rem; margin-bottom: 1rem; flex-wrap: wrap; }
-.form-row input { flex: 1; min-width: 200px; }
-
-.token-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(380px, 1fr)); gap: 1.25rem; }
-.token-card { background: var(--bg); border: 2px solid var(--border); border-radius: 1rem; padding: 1.5rem; transition: all 0.3s; position: relative; overflow: hidden; }
-.token-card::before { content: ''; position: absolute; top: 0; left: 0; right: 0; height: 4px; background: linear-gradient(90deg, var(--primary), var(--primary-dark)); opacity: 0; transition: opacity 0.3s; }
-.token-card:hover { border-color: var(--primary); box-shadow: var(--shadow); transform: translateY(-2px); }
-.token-card:hover::before { opacity: 1; }
-.token-header { display: flex; justify-content: space-between; align-items: center; margin-bottom: 1rem; }
-.token-id { font-size: 0.75rem; color: var(--text-light); font-family: monospace; }
-.token-info { display: flex; flex-direction: column; gap: 0.75rem; margin-bottom: 1.25rem; }
-.info-row { display: flex; align-items: center; gap: 0.5rem; font-size: 0.875rem; }
-.info-label { color: var(--text-light); min-width: 80px; font-weight: 500; }
-.info-value { color: var(--text); font-family: monospace; font-size: 0.8rem; }
-.token-actions { display: grid; grid-template-columns: 1fr 1fr; gap: 0.5rem; }
-
-.btn { padding: 0.625rem 1rem; border: none; border-radius: 0.5rem; cursor: pointer; font-size: 0.875rem; font-weight: 600; transition: all 0.2s; white-space: nowrap; text-align: center; }
+.tab.active {
+    background: linear-gradient(135deg, var(--primary), var(--primary-dark));
+    color: white;
+    box-shadow: 0 2px 6px rgba(8,145,178,0.25);
+}
+
+.content {
+    padding: 1rem;
+    flex: 1;
+    overflow-y: auto;
+}
+
+/* 顶部栏 - 统计+操作 */
+.top-bar {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    background: rgba(255, 255, 255, 0.6);
+    padding: 0.75rem 1rem;
+    border-radius: 0.75rem;
+    margin-bottom: 1rem;
+    border: 1.5px solid var(--border);
+}
+@media (prefers-color-scheme: dark) {
+    .top-bar {
+        background: rgba(30, 41, 59, 0.6);
+    }
+}
+.stats-inline { 
+    display: flex; 
+    gap: 1.5rem; 
+}
+.stat-item {
+    display: flex;
+    align-items: baseline;
+    gap: 0.25rem;
+}
+.stat-num {
+    font-size: 1.25rem;
+    font-weight: 700;
+    color: var(--primary);
+    line-height: 1;
+}
+.stat-item.success .stat-num { color: var(--success); }
+.stat-item.danger .stat-num { color: var(--danger); }
+.stat-text {
+    font-size: 0.85rem;
+    color: var(--text-light);
+    line-height: 1;
+}
+.action-btns { 
+    display: flex; 
+    gap: 0.5rem; 
+}
+
+/* 按钮样式 */
+.btn { 
+    padding: 0.5rem 0.875rem; 
+    border: none; 
+    border-radius: 0.375rem; 
+    cursor: pointer; 
+    font-size: 0.8rem; 
+    font-weight: 600; 
+    transition: all 0.2s; 
+    white-space: nowrap; 
+    text-align: center; 
+    display: inline-flex; 
+    align-items: center; 
+    justify-content: center; 
+    gap: 0.25rem; 
+    min-height: 36px; 
+    box-shadow: none; 
+}
 .btn:hover { transform: translateY(-1px); }
+.btn-sm { padding: 0.375rem 0.75rem; font-size: 0.75rem; min-height: 32px; }
+.btn-xs { padding: 0.25rem 0.5rem; font-size: 0.7rem; min-height: 28px; min-width: 28px; }
 .btn-danger { background: var(--danger); color: white; }
 .btn-warning { background: var(--warning); color: white; }
 .btn-success { background: var(--success); color: white; }
 .btn-secondary { background: #6b7280; color: white; }
+.btn-info { background: var(--info); color: white; }
 
-.hidden { display: none; }
-.status { padding: 0.375rem 0.875rem; border-radius: 9999px; font-size: 0.75rem; font-weight: 600; display: inline-flex; align-items: center; gap: 0.25rem; }
+/* Token网格 */
+.token-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
+    gap: 0.75rem;
+}
+.token-card {
+    background: rgba(255, 255, 255, 0.6);
+    border: 1.5px solid var(--border);
+    border-radius: 0.75rem;
+    padding: 0.875rem;
+    transition: all 0.2s;
+    position: relative;
+    overflow: hidden;
+}
+@media (prefers-color-scheme: dark) {
+    .token-card {
+        background: rgba(30, 41, 59, 0.6);
+    }
+}
+.token-card:hover {
+    border-color: var(--primary);
+    box-shadow: 0 6px 16px rgba(0,0,0,0.12);
+    background: rgba(255, 255, 255, 0.85);
+    transform: scale(1.02);
+    z-index: 1;
+    position: relative;
+}
+@media (prefers-color-scheme: dark) {
+    .token-card:hover {
+        background: rgba(30, 41, 59, 0.85);
+    }
+}
+.token-card.disabled { opacity: 0.6; }
+.token-card.expired { border-color: var(--danger); }
+
+.token-header { 
+    display: flex; 
+    justify-content: space-between; 
+    align-items: center; 
+    margin-bottom: 0.5rem; 
+}
+.token-id {
+    font-size: 0.7rem;
+    color: var(--text-light);
+}
+
+.token-info { 
+    display: flex; 
+    flex-direction: column; 
+    gap: 0.375rem; 
+    margin-bottom: 0.75rem; 
+}
+.info-row { 
+    display: flex; 
+    align-items: center; 
+    gap: 0.375rem; 
+    font-size: 0.8rem; 
+}
+.info-label { 
+    flex-shrink: 0; 
+    width: 20px; 
+    text-align: center; 
+}
+.info-value {
+    color: var(--text);
+    font-size: 0.75rem;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+.info-row.expired-text .info-value { color: var(--danger); }
+.info-row.editable {
+    cursor: pointer;
+    padding: 0.25rem;
+    margin: -0.25rem;
+    border-radius: 0.25rem;
+    transition: background 0.2s;
+}
+.info-row.editable:hover {
+    background: rgba(8,145,178,0.08);
+}
+.info-edit-icon {
+    font-size: 0.6rem;
+    opacity: 0;
+    transition: opacity 0.2s;
+    margin-left: auto;
+    flex-shrink: 0;
+}
+.info-row.editable:hover .info-edit-icon {
+    opacity: 0.5;
+}
+
+/* Token完整显示样式 */
+.token-display {
+    background: var(--bg);
+    border: 1px solid var(--border);
+    border-radius: 6px;
+    padding: 0.5rem 0.75rem;
+    font-family: 'Ubuntu Mono', 'MiSans', 'Consolas', monospace;
+    font-size: 0.75rem;
+    line-height: 1.4;
+    word-break: break-all;
+    color: var(--text-light);
+    max-height: 80px;
+    overflow-y: auto;
+    user-select: all;
+    cursor: text;
+}
+.inline-edit-input {
+    flex: 1;
+    min-height: 24px;
+    padding: 0.125rem 0.375rem;
+    font-size: 0.75rem;
+    border: 1px solid var(--primary);
+    border-radius: 0.25rem;
+    background: var(--card);
+}
+.inline-edit-input:focus {
+    outline: none;
+    box-shadow: 0 0 0 2px rgba(8,145,178,0.2);
+}
+
+/* Token卡片头部 */
+.token-header-right {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+.btn-icon {
+    width: 24px;
+    height: 24px;
+    min-height: 24px;
+    min-width: 24px;
+    padding: 0;
+    background: transparent;
+    border: 1px solid var(--border);
+    border-radius: 0.25rem;
+    cursor: pointer;
+    font-size: 0.7rem;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: all 0.2s;
+    box-shadow: none;
+}
+.btn-icon:hover {
+    background: var(--primary);
+    border-color: var(--primary);
+    transform: none;
+}
+
+.token-actions { 
+    display: flex; 
+    gap: 0.375rem; 
+    justify-content: flex-end; 
+}
+
+.status { 
+    padding: 0.25rem 0.5rem; 
+    border-radius: 9999px; 
+    font-size: 0.7rem; 
+    font-weight: 600; 
+    display: inline-flex; 
+    align-items: center; 
+}
 .status.enabled { background: rgba(16,185,129,0.15); color: var(--success); }
 .status.disabled { background: rgba(239,68,68,0.15); color: var(--danger); }
 
-.stats { display: flex; gap: 1.5rem; margin-bottom: 2rem; flex-wrap: wrap; }
-.stat-card { flex: 1; min-width: 150px; background: linear-gradient(135deg, var(--primary), var(--primary-dark)); padding: 1.25rem; border-radius: 1rem; color: white; }
-.stat-value { font-size: 2rem; font-weight: 700; margin-bottom: 0.25rem; }
-.stat-label { font-size: 0.875rem; opacity: 0.9; }
-
-.config-form { max-width: 800px; }
-.config-form h3 { margin-bottom: 1.5rem; font-size: 1.5rem; }
-.config-section { background: var(--bg); padding: 1.5rem; border-radius: 1rem; margin-bottom: 1.5rem; border: 2px solid var(--border); }
-.config-section h4 { margin-bottom: 1rem; color: var(--primary); font-size: 1.1rem; }
-.config-form .form-group { margin-bottom: 1rem; }
-.config-form label { display: block; margin-bottom: 0.5rem; font-weight: 600; font-size: 0.9rem; }
-.config-form input, .config-form select, .config-form textarea { width: 100%; padding: 0.75rem; border: 2px solid var(--border); border-radius: 0.5rem; background: var(--card); color: var(--text); font-size: 0.9rem; }
-.config-form textarea { resize: vertical; font-family: inherit; }
-.config-form button[type="submit"] { margin-top: 1rem; }
+/* 空状态 */
+.empty-state {
+    text-align: center;
+    padding: 3rem 1rem;
+    color: var(--text-light);
+    grid-column: 1 / -1;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    min-height: 300px;
+}
+.empty-state-icon { font-size: 3rem; margin-bottom: 0.75rem; opacity: 0.5; }
+.empty-state-text { font-size: 1rem; font-weight: 500; margin-bottom: 0.375rem; }
+.empty-state-hint { font-size: 0.8rem; }
 
-@media (max-width: 768px) {
-    .container { padding: 0; height: 100vh; }
-    .login-form { margin: 1rem; padding: 2rem; border-radius: 1rem; }
-    .login-form h2 { font-size: 1.5rem; }
-    .main-content { height: 100vh; border-radius: 0; }
-    .header { padding: 1rem; flex-wrap: wrap; gap: 1rem; }
-    .header h1 { font-size: 1.25rem; }
-    .tabs { width: 100%; }
-    .tab { flex: 1; }
-    .content { padding: 1rem; }
-    .token-grid { grid-template-columns: 1fr; }
-    .form-row { flex-direction: column; }
-    .form-row input { min-width: 100%; }
-    .btn-group { flex-direction: column; }
-    .btn-group .btn { width: 100%; }
-    .stats { flex-direction: column; }
-    .toast { right: 10px; left: 10px; min-width: auto; max-width: none; }
-    .modal { padding: 10px; }
+/* 设置页面 */
+.config-form { max-width: 100%; }
+.config-grid { 
+    display: grid; 
+    grid-template-columns: repeat(auto-fit, minmax(280px, 1fr)); 
+    gap: 1rem; 
+    margin-bottom: 1rem; 
+}
+.config-section {
+    background: rgba(255, 255, 255, 0.6);
+    padding: 1rem;
+    border-radius: 0.75rem;
+    border: 1.5px solid var(--border);
+}
+@media (prefers-color-scheme: dark) {
+    .config-section {
+        background: rgba(30, 41, 59, 0.6);
+    }
+}
+.config-section h4 { 
+    margin-bottom: 0.75rem; 
+    color: var(--primary); 
+    font-size: 0.95rem; 
+    font-weight: 600; 
+}
+.form-row-inline { 
+    display: grid; 
+    grid-template-columns: 1fr 1fr; 
+    gap: 0.5rem; 
+    margin-bottom: 0.5rem; 
+}
+.form-group.compact { margin-bottom: 0.5rem; }
+.form-group.compact label { 
+    font-size: 0.75rem; 
+    margin-bottom: 0.25rem; 
+    color: var(--text-light); 
+}
+.form-group.compact input,
+.form-group.compact select {
+    min-height: 36px;
+    padding: 0.375rem 0.5rem;
+    font-size: 0.8rem;
+}
+.form-group.compact textarea {
+    min-height: 60px;
+    max-height: 300px;
+    padding: 0.375rem 0.5rem;
+    font-size: 0.8rem;
+    resize: vertical;
+    height: auto;
+    /* 自适应内容高度 - 纯CSS方案，零JS资源消耗 */
+    field-sizing: content;
+}
+.form-group.highlight {
+    background: rgba(8,145,178,0.08);
+    padding: 0.5rem;
+    border-radius: 0.5rem;
+    margin-top: 0.5rem;
+}
+.form-group.highlight label { 
+    color: var(--primary); 
+    font-weight: 600; 
+}
+.config-actions {
+    display: flex;
+    gap: 0.5rem;
+    justify-content: flex-start;
 }
+.config-actions .btn { width: auto; }
 
-.btn-info { background: var(--info); color: white; }
-.token-actions { display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 0.5rem; }
+/* 字体大小控制 */
+.font-size-control {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+.font-size-control input[type="range"] {
+    flex: 1;
+    min-height: auto;
+    height: 6px;
+    padding: 0;
+    cursor: pointer;
+}
+.font-size-control input[type="number"] {
+    width: 60px;
+    text-align: center;
+    flex-shrink: 0;
+}
+
+/* 轮询策略状态显示 */
+.rotation-status {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.5rem 0.75rem;
+    background: rgba(8,145,178,0.08);
+    border-radius: 0.5rem;
+    margin-top: 0.5rem;
+    font-size: 0.75rem;
+}
+.rotation-label {
+    color: var(--text-light);
+    font-weight: 500;
+}
+#currentRotationInfo {
+    color: var(--primary);
+    font-weight: 600;
+}
 
-.quota-section { margin-top: 1rem; padding-top: 1rem; border-top: 2px solid var(--border); }
-.quota-loading, .quota-error, .quota-empty { text-align: center; padding: 1rem; color: var(--text-light); font-size: 0.875rem; }
+/* Toast通知 */
+.toast { 
+    position: fixed; 
+    top: 16px; 
+    right: 16px; 
+    background: var(--card); 
+    border-radius: 0.75rem; 
+    padding: 0.75rem 1rem; 
+    box-shadow: 0 8px 24px rgba(0,0,0,0.15); 
+    z-index: 9999; 
+    display: flex; 
+    align-items: center; 
+    gap: 0.75rem; 
+    min-width: 240px; 
+    max-width: 360px; 
+    animation: slideIn 0.3s ease; 
+    border-left: 3px solid var(--primary); 
+}
+.toast.success { border-left-color: var(--success); }
+.toast.error { border-left-color: var(--danger); }
+.toast.warning { border-left-color: var(--warning); }
+.toast.info { border-left-color: var(--info); }
+.toast-icon { font-size: 1.25rem; flex-shrink: 0; }
+.toast-content { flex: 1; }
+.toast-title { font-weight: 600; font-size: 0.875rem; color: var(--text); }
+.toast-message { font-size: 0.8rem; color: var(--text-light); }
+
+@keyframes slideIn { from { transform: translateX(400px); opacity: 0; } to { transform: translateX(0); opacity: 1; } }
+@keyframes slideOut { from { transform: translateX(0); opacity: 1; } to { transform: translateX(400px); opacity: 0; } }
+
+/* Modal弹窗 */
+.modal { 
+    position: fixed; 
+    inset: 0; 
+    background: rgba(0,0,0,0.5); 
+    z-index: 9998; 
+    display: flex; 
+    align-items: center; 
+    justify-content: center; 
+    padding: 1rem; 
+    animation: fadeIn 0.2s; 
+}
+.modal-content {
+    background: rgba(255, 255, 255, 0.8);
+    backdrop-filter: blur(24px) saturate(180%);
+    -webkit-backdrop-filter: blur(24px) saturate(180%);
+    border-radius: 1rem;
+    padding: 1.25rem;
+    max-width: 400px;
+    width: 100%;
+    box-shadow: 0 16px 48px rgba(0,0,0,0.2);
+    animation: scaleIn 0.2s;
+    border: 1px solid rgba(255, 255, 255, 0.5);
+}
+@media (prefers-color-scheme: dark) {
+    .modal-content {
+        background: rgba(30, 41, 59, 0.8);
+        border: 1px solid rgba(255, 255, 255, 0.15);
+    }
+}
+.modal-content.modal-lg { max-width: 700px; }
+.modal-content.modal-xl {
+    max-width: 900px;
+    display: flex;
+    flex-direction: column;
+    max-height: 80vh;
+    overflow: hidden;
+}
+.modal-content.modal-xl .quota-container {
+    flex: 1;
+    overflow-y: auto;
+    overflow-x: hidden;
+}
+.modal-content.modal-xl .modal-actions {
+    flex-shrink: 0;
+    border-top: 1px solid var(--border);
+    padding-top: 1rem;
+    margin-top: 0.5rem;
+    background: transparent;
+}
+.modal-title { font-size: 1rem; font-weight: 700; margin-bottom: 0.75rem; color: var(--text); }
+.modal-message { color: var(--text-light); margin-bottom: 1rem; line-height: 1.5; font-size: 0.85rem; }
+.modal-actions { display: flex; gap: 0.5rem; justify-content: flex-end; }
+.modal-actions button { flex: none; width: auto; }
+
+.form-modal .modal-content { max-width: 480px; }
+.form-modal input { margin-bottom: 0.75rem; }
+.form-modal .form-row { display: flex; flex-direction: column; gap: 0.75rem; margin-bottom: 1rem; }
+.form-modal .oauth-steps { 
+    background: rgba(59,130,246,0.1); 
+    padding: 0.875rem; 
+    border-radius: 0.5rem; 
+    margin-bottom: 1rem; 
+    border: 1.5px solid var(--info); 
+}
+.form-modal .oauth-steps p { margin-bottom: 0.5rem; font-size: 0.8rem; }
+.form-modal .oauth-steps p:last-child { margin-bottom: 0; }
+
+@keyframes fadeIn { from { opacity: 0; } to { opacity: 1; } }
+@keyframes scaleIn { from { transform: scale(0.95); opacity: 0; } to { transform: scale(1); opacity: 1; } }
+
+/* Loading遮罩 */
+.loading-overlay { 
+    position: fixed; 
+    inset: 0; 
+    background: rgba(0,0,0,0.6); 
+    z-index: 9999; 
+    display: flex; 
+    align-items: center; 
+    justify-content: center; 
+    flex-direction: column; 
+    gap: 1rem; 
+}
+.spinner { 
+    width: 40px; 
+    height: 40px; 
+    border: 3px solid rgba(255,255,255,0.2); 
+    border-top-color: white; 
+    border-radius: 50%; 
+    animation: spin 0.7s linear infinite; 
+}
+.loading-text { color: white; font-size: 0.875rem; font-weight: 500; }
+
+/* 帮助提示 */
+.help-tip { 
+    display: inline-flex; 
+    align-items: center; 
+    justify-content: center; 
+    width: 16px; 
+    height: 16px; 
+    border-radius: 50%; 
+    background: var(--info); 
+    color: white; 
+    font-size: 0.65rem; 
+    font-weight: 600; 
+    cursor: help; 
+    margin-left: 4px; 
+}
+
+/* 额度弹窗头部 */
+.quota-modal-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 0.75rem;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+}
+.quota-update-time {
+    font-size: 0.75rem;
+    color: var(--text-light);
+}
+
+/* 额度弹窗 - 标签页样式 */
+.quota-tabs {
+    display: flex;
+    gap: 0.625rem;
+    margin-bottom: 1rem;
+    overflow-x: auto;
+    overflow-y: hidden;
+    scrollbar-width: thin;
+    scrollbar-color: rgba(0,0,0,0.2) transparent;
+    padding: 0.375rem;
+    margin: -0.375rem;
+    margin-bottom: 0.625rem;
+}
+.quota-tabs::-webkit-scrollbar {
+    height: 4px;
+}
+.quota-tabs::-webkit-scrollbar-thumb {
+    background: rgba(0,0,0,0.2);
+    border-radius: 2px;
+}
+.quota-tab {
+    font-size: 0.8rem;
+    font-weight: 500;
+    color: var(--text-light) !important;
+    padding: 0.5rem 1rem;
+    background: var(--bg) !important;
+    border: 2px solid var(--border) !important;
+    border-radius: 0.5rem;
+    cursor: pointer;
+    transition: all 0.15s ease;
+    white-space: nowrap;
+    min-height: auto;
+    box-shadow: none !important;
+    width: auto;
+    line-height: 1.2;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    flex-shrink: 0;
+}
+.quota-tab:hover {
+    color: var(--primary) !important;
+    border-color: var(--primary) !important;
+    background: rgba(8,145,178,0.05) !important;
+    transform: none;
+}
+.quota-tab.active {
+    color: white !important;
+    background: var(--primary) !important;
+    border-color: var(--primary) !important;
+}
+.quota-container {
+    max-height: 55vh;
+    overflow: auto;
+    position: relative;
+    padding: 0.25rem;
+}
+.quota-loading, .quota-error, .quota-empty {
+    text-align: center;
+    padding: 1.5rem;
+    color: var(--text-light);
+    font-size: 0.875rem;
+}
 .quota-error { color: var(--danger); }
-.quota-header { font-weight: 600; margin-bottom: 0.75rem; font-size: 0.9rem; color: var(--text); }
-.quota-item { margin-bottom: 1rem; }
-.quota-item:last-child { margin-bottom: 0; }
-.quota-model-name { font-size: 0.8rem; color: var(--text); margin-bottom: 0.5rem; font-family: monospace; font-weight: 500; }
-.quota-bar-container { position: relative; height: 24px; background: var(--border); border-radius: 12px; overflow: hidden; margin-bottom: 0.375rem; }
-.quota-bar { height: 100%; border-radius: 12px; transition: width 0.3s ease; position: relative; }
-.quota-percentage { position: absolute; right: 8px; top: 50%; transform: translateY(-50%); font-size: 0.75rem; font-weight: 600; color: white; text-shadow: 0 1px 2px rgba(0,0,0,0.3); z-index: 1; }
-.quota-reset { font-size: 0.75rem; color: var(--text-light); }
-.quota-group-title { font-size: 1rem; font-weight: 700; color: var(--text); margin: 1.25rem 0 0.75rem 0; padding-bottom: 0.5rem; border-bottom: 2px solid var(--border); }
+.quota-group-title {
+    font-size: 0.9rem;
+    font-weight: 700;
+    color: var(--text);
+    margin: 1rem 0 0.5rem 0;
+    padding-bottom: 0.375rem;
+    border-bottom: 1.5px solid var(--border);
+}
 .quota-group-title:first-child { margin-top: 0; }
+.quota-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
+    gap: 0.75rem;
+    padding: 0.5rem;
+}
+.quota-item {
+    background: rgba(255,255,255,0.6);
+    padding: 0.625rem;
+    border-radius: 0.5rem;
+    border: 1.5px solid var(--border);
+    transition: transform 0.15s ease, box-shadow 0.15s ease, border-color 0.15s ease, background 0.15s ease;
+    cursor: default;
+}
+.quota-item:hover {
+    transform: scale(1.02);
+    box-shadow: 0 6px 16px rgba(0,0,0,0.12);
+    border-color: var(--primary);
+    background: rgba(255,255,255,0.95);
+    z-index: 1;
+    position: relative;
+}
+@media (prefers-color-scheme: dark) {
+    .quota-item {
+        background: rgba(30, 41, 59, 0.6);
+    }
+    .quota-item:hover {
+        background: rgba(30, 41, 59, 0.9);
+    }
+}
+.quota-model-name {
+    font-size: 0.75rem;
+    color: var(--text);
+    margin-bottom: 0.375rem;
+    font-weight: 500;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+.quota-bar-container {
+    position: relative;
+    height: 0.5rem;
+    background: var(--border);
+    border-radius: 0.25rem;
+    overflow: hidden;
+    margin-bottom: 0.375rem;
+}
+.quota-bar {
+    height: 100%;
+    border-radius: 0.25rem;
+    transition: width 0.3s ease;
+}
+.quota-info-row {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    font-size: 0.7rem;
+}
+.quota-percentage {
+    font-weight: 600;
+    color: var(--text);
+}
+.quota-reset {
+    color: var(--text-light);
+}
 
+/* Token卡片内嵌额度 */
+.token-quota-inline {
+    background: rgba(8,145,178,0.05);
+    border: 1px solid var(--border);
+    border-radius: 0.5rem;
+    margin-bottom: 0.75rem;
+    overflow: hidden;
+}
+.quota-inline-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 0.375rem 0.5rem;
+    cursor: pointer;
+    transition: background 0.2s;
+}
+.quota-inline-header:hover {
+    background: rgba(8,145,178,0.1);
+}
+.quota-inline-summary {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    flex: 1;
+    min-width: 0;
+    font-size: 0.75rem;
+}
+.quota-summary-icon {
+    flex-shrink: 0;
+}
+.quota-summary-model {
+    flex: 1;
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    color: var(--text);
+    font-weight: 500;
+}
+.quota-summary-bar {
+    flex: 0 0 60px;
+    height: 8px;
+    background: var(--border);
+    border-radius: 4px;
+    overflow: hidden;
+}
+.quota-summary-bar span {
+    display: block;
+    height: 100%;
+    border-radius: 4px;
+}
+.quota-summary-pct {
+    flex-shrink: 0;
+    font-weight: 600;
+    font-size: 0.7rem;
+    color: var(--primary);
+    min-width: 32px;
+    text-align: right;
+}
+.quota-inline-toggle {
+    font-size: 0.65rem;
+    color: var(--text-light);
+    flex-shrink: 0;
+    margin-left: 0.5rem;
+}
+.quota-inline-detail {
+    border-top: 1px solid var(--border);
+    padding: 0.5rem;
+    background: var(--bg);
+}
+.quota-detail-grid {
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+    margin-bottom: 0.5rem;
+    max-height: 200px;
+    overflow-y: auto;
+}
+.quota-detail-row {
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+    padding: 0.25rem 0;
+    font-size: 0.7rem;
+    border-bottom: 1px solid var(--border);
+}
+.quota-detail-row:last-child {
+    border-bottom: none;
+}
+.quota-detail-icon {
+    flex-shrink: 0;
+    font-size: 0.65rem;
+}
+.quota-detail-name {
+    flex: 1;
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    color: var(--text);
+}
+.quota-detail-bar {
+    flex: 0 0 50px;
+    height: 6px;
+    background: var(--border);
+    border-radius: 3px;
+    overflow: hidden;
+}
+.quota-detail-bar span {
+    display: block;
+    height: 100%;
+    border-radius: 3px;
+}
+.quota-detail-pct {
+    flex-shrink: 0;
+    font-weight: 600;
+    font-size: 0.65rem;
+    color: var(--primary);
+    min-width: 28px;
+    text-align: right;
+}
+.quota-refresh-btn {
+    width: 100%;
+    margin-top: 0.5rem;
+}
+.quota-loading-small {
+    font-size: 0.7rem;
+    color: var(--text-light);
+    text-align: center;
+    padding: 0.5rem;
+}
+.quota-empty-small, .quota-error-small {
+    font-size: 0.7rem;
+    color: var(--text-light);
+    text-align: center;
+    padding: 0.5rem;
+}
+.quota-error-small { color: var(--danger); }
+.quota-summary-error {
+    color: var(--danger);
+    font-size: 0.7rem;
+}
+
+.hidden { display: none; }
+
+/* 敏感信息模糊 */
+.sensitive-info.blurred {
+    filter: blur(4px);
+    user-select: none;
+    cursor: default;
+}
+
+/* 响应式 */
 @media (max-width: 768px) {
-    .token-actions { grid-template-columns: 1fr; }
+    .container { padding: 0; height: 100vh; }
+    .login-form { margin: 0.5rem; padding: 1.5rem; }
+    .login-form h2 { font-size: 1.25rem; }
+    .main-content { height: 100vh; border-radius: 0; }
+    .header {
+        padding: 0.5rem 0.75rem;
+        flex-wrap: nowrap;
+        gap: 0.5rem;
+    }
+    .header-right {
+        flex-shrink: 0;
+    }
+    .header-right .server-info {
+        display: none;
+    }
+    .header-right button {
+        padding: 0.375rem 0.5rem;
+        font-size: 0.7rem;
+        min-height: 32px;
+    }
+    .tabs {
+        flex: 1;
+        min-width: 0;
+    }
+    .tab { flex: 1; font-size: 0.7rem; padding: 0.375rem 0.5rem; min-height: 32px; }
+    .content { padding: 0.75rem; }
+    
+    .top-bar { flex-direction: column; gap: 0.5rem; align-items: stretch; padding: 0.5rem 0.75rem; }
+    .stats-inline { justify-content: space-around; }
+    .action-btns {
+        display: grid;
+        grid-template-columns: repeat(4, 1fr);
+        gap: 0.375rem;
+    }
+    .action-btns .btn-sm {
+        padding: 0.375rem 0.25rem;
+        font-size: 0.7rem;
+        min-height: 32px;
+    }
+    
+    .token-grid { grid-template-columns: 1fr; }
+    .config-grid { grid-template-columns: 1fr; }
+    .form-row-inline { grid-template-columns: 1fr; }
+    .toast { right: 8px; left: 8px; min-width: auto; max-width: none; }
+    .modal { padding: 0.25rem; }
+    .modal-content { padding: 0.75rem; }
+    .modal-content.modal-xl {
+        max-width: 100%;
+        max-height: 90vh;
+        margin: 0.25rem;
+    }
+    .quota-modal-header {
+        flex-direction: column;
+        align-items: flex-start;
+        gap: 0.25rem;
+    }
+    .quota-tabs {
+        flex-wrap: nowrap;
+        gap: 0.375rem;
+        overflow-x: auto;
+        -webkit-overflow-scrolling: touch;
+        padding-bottom: 0.25rem;
+    }
+    .quota-tab {
+        font-size: 0.75rem;
+        padding: 0.3rem 0.6rem;
+    }
+    .quota-grid {
+        grid-template-columns: 1fr;
+        gap: 0.5rem;
+        padding: 0.25rem;
+    }
+    .quota-item {
+        padding: 0.5rem;
+    }
+    .quota-item:hover {
+        transform: none;
+    }
+    .quota-group-title {
+        font-size: 0.85rem;
+        margin: 0.75rem 0 0.375rem 0;
+    }
+    
+    /* 移动端内嵌额度优化 */
+    .quota-summary-model {
+        font-size: 0.7rem;
+    }
+    
+    /* 移动端Token卡片操作按钮 */
+    .token-actions {
+        display: grid;
+        grid-template-columns: repeat(3, 1fr);
+        gap: 0.25rem;
+    }
+    .token-actions .btn-xs {
+        padding: 0.375rem 0.25rem;
+        font-size: 0.65rem;
+        min-height: 28px;
+    }
+}
+
+@media (max-width: 480px) {
+    .stat-num { font-size: 1rem; }
+    .stat-text { font-size: 0.75rem; }
+    .btn-sm { padding: 0.25rem 0.375rem; font-size: 0.65rem; min-height: 30px; }
+    .token-card { padding: 0.625rem; }
+    .info-row { font-size: 0.7rem; }
+    .info-label { width: 18px; }
+    .info-value { font-size: 0.7rem; }
+    
+    /* 超小屏幕按钮2x2布局 */
+    .action-btns {
+        grid-template-columns: repeat(2, 1fr);
+    }
+    
+    .quota-summary-model {
+        font-size: 0.65rem;
+    }
+    .quota-summary-pct {
+        font-size: 0.65rem;
+    }
+    .quota-summary-bar {
+        flex: 0 0 40px;
+    }
+    .quota-detail-name {
+        font-size: 0.6rem;
+    }
+    .quota-detail-pct {
+        font-size: 0.6rem;
+    }
+    
+    /* Token卡片头部优化 */
+    .token-header {
+        flex-wrap: wrap;
+        gap: 0.25rem;
+    }
+    .status {
+        font-size: 0.65rem;
+        padding: 0.2rem 0.4rem;
+    }
+    .token-id {
+        font-size: 0.6rem;
+    }
 }

src/AntigravityRequester.js

@@ -6,6 +6,9 @@ import fs from 'fs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
+// 缓冲区大小警告阈值（不限制，只警告）
+const BUFFER_WARNING_SIZE = 50 * 1024 * 1024; // 50MB 警告
+
 class antigravityRequester {
     constructor(options = {}) {
         this.binPath = options.binPath;
@@ -15,6 +18,7 @@ class antigravityRequester {
         this.pendingRequests = new Map();
         this.buffer = '';
         this.writeQueue = Promise.resolve();
+        this.bufferWarned = false;
     }
 
     _getExecutablePath() {
@@ -64,15 +68,28 @@ class antigravityRequester {
         
         // 使用 setImmediate 异步处理数据,避免阻塞
         this.proc.stdout.on('data', (data) => {
-            this.buffer += data.toString();
+            const chunk = data.toString();
+            
+            // 缓冲区大小监控（仅警告，不限制，因为图片响应可能很大）
+            if (!this.bufferWarned && this.buffer.length > BUFFER_WARNING_SIZE) {
+                console.warn(`AntigravityRequester: 缓冲区较大 (${Math.round(this.buffer.length / 1024 / 1024)}MB)，可能有大型响应`);
+                this.bufferWarned = true;
+            }
+            
+            this.buffer += chunk;
             
             // 使用 setImmediate 异步处理,避免阻塞 stdout 读取
             setImmediate(() => {
-                const lines = this.buffer.split('\n');
-                this.buffer = lines.pop();
-
-                for (const line of lines) {
-                    if (!line.trim()) continue;
+                let start = 0;
+                let end;
+                
+                // 高效的行分割（避免 split 创建大量字符串）
+                while ((end = this.buffer.indexOf('\n', start)) !== -1) {
+                    const line = this.buffer.slice(start, end).trim();
+                    start = end + 1;
+                    
+                    if (!line) continue;
+                    
                     try {
                         const response = JSON.parse(line);
                         const pending = this.pendingRequests.get(response.id);
@@ -92,9 +109,13 @@ class antigravityRequester {
                             }
                         }
                     } catch (e) {
-                        console.error('Failed to parse response:', e, 'Line:', line);
+                        // 忽略 JSON 解析错误（可能是不完整的行）
                     }
                 }
+                
+                // 保留未处理的部分
+                this.buffer = start < this.buffer.length ? this.buffer.slice(start) : '';
+                this.bufferWarned = false;
             });
         });
 
@@ -168,9 +189,17 @@ class antigravityRequester {
                 if (canWrite) {
                     resolve();
                 } else {
-                    // 等待 drain 事件
-                    this.proc.stdin.once('drain', resolve);
-                    this.proc.stdin.once('error', reject);
+                    // 等待 drain 事件，并在任一事件触发后移除另一个监听器
+                    const onDrain = () => {
+                        this.proc.stdin.removeListener('error', onError);
+                        resolve();
+                    };
+                    const onError = (err) => {
+                        this.proc.stdin.removeListener('drain', onDrain);
+                        reject(err);
+                    };
+                    this.proc.stdin.once('drain', onDrain);
+                    this.proc.stdin.once('error', onError);
                 }
             });
         }).catch(err => {
@@ -180,8 +209,49 @@ class antigravityRequester {
 
     close() {
         if (this.proc) {
-            this.proc.stdin.end();
+            // 先拒绝所有待处理的请求
+            for (const [id, pending] of this.pendingRequests) {
+                if (pending.reject) {
+                    pending.reject(new Error('Requester closed'));
+                } else if (pending.streamResponse && pending.streamResponse._onError) {
+                    pending.streamResponse._onError(new Error('Requester closed'));
+                }
+            }
+            this.pendingRequests.clear();
+            
+            // 清理缓冲区
+            this.buffer = '';
+            
+            // 关闭输入流
+            try {
+                this.proc.stdin.end();
+            } catch (e) {
+                // 忽略关闭错误
+            }
+            
+            // 给子进程一点时间优雅退出，否则强制终止
+            const proc = this.proc;
             this.proc = null;
+            
+            setTimeout(() => {
+                try {
+                    if (proc && !proc.killed) {
+                        proc.kill('SIGTERM');
+                        // 如果 SIGTERM 无效，1秒后使用 SIGKILL
+                        setTimeout(() => {
+                            try {
+                                if (proc && !proc.killed) {
+                                    proc.kill('SIGKILL');
+                                }
+                            } catch (e) {
+                                // 忽略错误
+                            }
+                        }, 1000);
+                    }
+                } catch (e) {
+                    // 忽略错误
+                }
+            }, 500);
         }
     }
 }

src/api/client.js

@@ -4,11 +4,61 @@ import config from '../config/config.js';
 import { generateToolCallId } from '../utils/idGenerator.js';
 import AntigravityRequester from '../AntigravityRequester.js';
 import { saveBase64Image } from '../utils/imageStorage.js';
+import logger from '../utils/logger.js';
+import { httpAgent, httpsAgent } from '../utils/utils.js';
+import memoryManager, { MemoryPressure } from '../utils/memoryManager.js';
 
 // 请求客户端：优先使用 AntigravityRequester，失败则降级到 axios
 let requester = null;
 let useAxios = false;
 
+// ==================== 模型列表缓存（智能管理） ====================
+// 缓存过期时间根据内存压力动态调整
+const getModelCacheTTL = () => {
+  const baseTTL = config.cache?.modelListTTL || 60 * 60 * 1000;
+  const pressure = memoryManager.currentPressure;
+  // 高压力时缩短缓存时间
+  if (pressure === MemoryPressure.CRITICAL) return Math.min(baseTTL, 5 * 60 * 1000);
+  if (pressure === MemoryPressure.HIGH) return Math.min(baseTTL, 15 * 60 * 1000);
+  return baseTTL;
+};
+
+let modelListCache = null;
+let modelListCacheTime = 0;
+
+// 默认模型列表（当 API 请求失败时使用）
+const DEFAULT_MODELS = [
+  'claude-opus-4-5',
+  'claude-opus-4-5-thinking',
+  'claude-sonnet-4-5-thinking',
+  'claude-sonnet-4-5',
+  'gemini-3-pro-high',
+  'gemini-2.5-flash-lite',
+  'gemini-3-pro-image',
+  'gemini-2.5-flash-thinking',
+  'gemini-2.5-pro',
+  'gemini-2.5-flash',
+  'gemini-3-pro-low',
+  'chat_20706',
+  'rev19-uic3-1p',
+  'gpt-oss-120b-medium',
+  'chat_23310'
+];
+
+// 生成默认模型列表响应
+function getDefaultModelList() {
+  const created = Math.floor(Date.now() / 1000);
+  return {
+    object: 'list',
+    data: DEFAULT_MODELS.map(id => ({
+      id,
+      object: 'model',
+      created,
+      owned_by: 'google'
+    }))
+  };
+}
+
 if (config.useNativeAxios === true) {
   useAxios = true;
 } else {
@@ -20,6 +70,106 @@ if (config.useNativeAxios === true) {
   }
 }
 
+// ==================== 零拷贝优化 ====================
+
+// 预编译的常量（避免重复创建字符串）
+const DATA_PREFIX = 'data: ';
+const DATA_PREFIX_LEN = DATA_PREFIX.length;
+
+// 高效的行分割器（零拷贝，避免 split 创建新数组）
+// 使用对象池复用 LineBuffer 实例
+class LineBuffer {
+  constructor() {
+    this.buffer = '';
+    this.lines = [];
+  }
+  
+  // 追加数据并返回完整的行
+  append(chunk) {
+    this.buffer += chunk;
+    this.lines.length = 0; // 重用数组
+    
+    let start = 0;
+    let end;
+    while ((end = this.buffer.indexOf('\n', start)) !== -1) {
+      this.lines.push(this.buffer.slice(start, end));
+      start = end + 1;
+    }
+    
+    // 保留未完成的部分
+    this.buffer = start < this.buffer.length ? this.buffer.slice(start) : '';
+    return this.lines;
+  }
+  
+  // 清空缓冲区（用于归还到池之前）
+  clear() {
+    this.buffer = '';
+    this.lines.length = 0;
+  }
+}
+
+// LineBuffer 对象池
+const lineBufferPool = [];
+const getLineBuffer = () => {
+  const buffer = lineBufferPool.pop();
+  if (buffer) {
+    buffer.clear();
+    return buffer;
+  }
+  return new LineBuffer();
+};
+const releaseLineBuffer = (buffer) => {
+  const maxSize = memoryManager.getPoolSizes().lineBuffer;
+  if (lineBufferPool.length < maxSize) {
+    buffer.clear();
+    lineBufferPool.push(buffer);
+  }
+};
+
+// 对象池：复用 toolCall 对象
+const toolCallPool = [];
+const getToolCallObject = () => toolCallPool.pop() || { id: '', type: 'function', function: { name: '', arguments: '' } };
+const releaseToolCallObject = (obj) => {
+  const maxSize = memoryManager.getPoolSizes().toolCall;
+  if (toolCallPool.length < maxSize) toolCallPool.push(obj);
+};
+
+// 注册内存清理回调
+function registerMemoryCleanup() {
+  memoryManager.registerCleanup((pressure) => {
+    const poolSizes = memoryManager.getPoolSizes();
+    
+    // 根据压力缩减对象池
+    while (toolCallPool.length > poolSizes.toolCall) {
+      toolCallPool.pop();
+    }
+    while (lineBufferPool.length > poolSizes.lineBuffer) {
+      lineBufferPool.pop();
+    }
+    
+    // 高压力或紧急时清理模型缓存
+    if (pressure === MemoryPressure.HIGH || pressure === MemoryPressure.CRITICAL) {
+      const ttl = getModelCacheTTL();
+      const now = Date.now();
+      if (modelListCache && (now - modelListCacheTime) > ttl) {
+        modelListCache = null;
+        modelListCacheTime = 0;
+        logger.info('已清理过期模型列表缓存');
+      }
+    }
+    
+    // 紧急时强制清理模型缓存
+    if (pressure === MemoryPressure.CRITICAL && modelListCache) {
+      modelListCache = null;
+      modelListCacheTime = 0;
+      logger.info('紧急清理模型列表缓存');
+    }
+  });
+}
+
+// 初始化时注册清理回调
+registerMemoryCleanup();
+
 // ==================== 辅助函数 ====================
 
 function buildHeaders(token) {
@@ -38,6 +188,9 @@ function buildAxiosConfig(url, headers, body = null) {
     url,
     headers,
     timeout: config.timeout,
+    // 使用自定义 DNS 解析的 Agent（优先 IPv4，失败则 IPv6）
+    httpAgent,
+    httpsAgent,
     proxy: config.proxy ? (() => {
       const proxyUrl = new URL(config.proxy);
       return { protocol: proxyUrl.protocol.replace(':', ''), host: proxyUrl.hostname, port: parseInt(proxyUrl.port) };
@@ -86,19 +239,17 @@ async function handleApiError(error, token) {
   throw new Error(`API请求失败 (${status}): ${errorBody}`);
 }
 
-// 转换 functionCall 为 OpenAI 格式
+// 转换 functionCall 为 OpenAI 格式（使用对象池）
 function convertToToolCall(functionCall) {
-  return {
-    id: functionCall.id || generateToolCallId(),
-    type: 'function',
-    function: {
-      name: functionCall.name,
-      arguments: JSON.stringify(functionCall.args)
-    }
-  };
+  const toolCall = getToolCallObject();
+  toolCall.id = functionCall.id || generateToolCallId();
+  toolCall.function.name = functionCall.name;
+  toolCall.function.arguments = JSON.stringify(functionCall.args);
+  return toolCall;
 }
 
 // 解析并发送流式响应片段（会修改 state 并触发 callback）
+// 支持 DeepSeek 格式：思维链内容通过 reasoning_content 字段输出
 function parseAndEmitStreamChunk(line, state, callback) {
   if (!line.startsWith('data: ')) return;
   
@@ -110,18 +261,10 @@ function parseAndEmitStreamChunk(line, state, callback) {
     if (parts) {
       for (const part of parts) {
         if (part.thought === true) {
-          // 思维链内容
-          if (!state.thinkingStarted) {
-            callback({ type: 'thinking', content: '<think>\n' });
-            state.thinkingStarted = true;
-          }
-          callback({ type: 'thinking', content: part.text || '' });
+          // 思维链内容 - 使用 DeepSeek 格式的 reasoning_content
+          callback({ type: 'reasoning', reasoning_content: part.text || '' });
         } else if (part.text !== undefined) {
           // 普通文本内容
-          if (state.thinkingStarted) {
-            callback({ type: 'thinking', content: '\n</think>\n' });
-            state.thinkingStarted = false;
-          }
           callback({ type: 'text', content: part.text });
         } else if (part.functionCall) {
           // 工具调用
@@ -132,10 +275,6 @@ function parseAndEmitStreamChunk(line, state, callback) {
     
     // 响应结束时发送工具调用和使用统计
     if (data.response?.candidates?.[0]?.finishReason) {
-      if (state.thinkingStarted) {
-        callback({ type: 'thinking', content: '\n</think>\n' });
-        state.thinkingStarted = false;
-      }
       if (state.toolCalls.length > 0) {
         callback({ type: 'tool_calls', tool_calls: state.toolCalls });
         state.toolCalls = [];
@@ -143,8 +282,8 @@ function parseAndEmitStreamChunk(line, state, callback) {
       // 提取 token 使用统计
       const usage = data.response?.usageMetadata;
       if (usage) {
-        callback({ 
-          type: 'usage', 
+        callback({
+          type: 'usage',
           usage: {
             prompt_tokens: usage.promptTokenCount || 0,
             completion_tokens: usage.candidatesTokenCount || 0,
@@ -163,31 +302,34 @@ function parseAndEmitStreamChunk(line, state, callback) {
 export async function generateAssistantResponse(requestBody, token, callback) {
   
   const headers = buildHeaders(token);
-  const state = { thinkingStarted: false, toolCalls: [] };
-  let buffer = ''; // 缓冲区：处理跨 chunk 的不完整行
+  const state = { toolCalls: [] };
+  const lineBuffer = getLineBuffer(); // 从对象池获取
   
   const processChunk = (chunk) => {
-    buffer += chunk;
-    const lines = buffer.split('\n');
-    buffer = lines.pop(); // 保留最后一行（可能不完整）
-    lines.forEach(line => parseAndEmitStreamChunk(line, state, callback));
+    const lines = lineBuffer.append(chunk);
+    for (let i = 0; i < lines.length; i++) {
+      parseAndEmitStreamChunk(lines[i], state, callback);
+    }
   };
   
-  if (useAxios) {
-    try {
+  try {
+    if (useAxios) {
       const axiosConfig = { ...buildAxiosConfig(config.api.url, headers, requestBody), responseType: 'stream' };
       const response = await axios(axiosConfig);
       
-      response.data.on('data', chunk => processChunk(chunk.toString()));
+      // 使用 Buffer 直接处理，避免 toString 的内存分配
+      response.data.on('data', chunk => {
+        processChunk(typeof chunk === 'string' ? chunk : chunk.toString('utf8'));
+      });
+      
       await new Promise((resolve, reject) => {
-        response.data.on('end', resolve);
+        response.data.on('end', () => {
+          releaseLineBuffer(lineBuffer); // 归还到对象池
+          resolve();
+        });
         response.data.on('error', reject);
       });
-    } catch (error) {
-      await handleApiError(error, token);
-    }
-  } else {
-    try {
+    } else {
       const streamResponse = requester.antigravity_fetchStream(config.api.url, buildRequesterConfig(headers, requestBody));
       let errorBody = '';
       let statusCode = null;
@@ -195,19 +337,45 @@ export async function generateAssistantResponse(requestBody, token, callback) {
       await new Promise((resolve, reject) => {
         streamResponse
           .onStart(({ status }) => { statusCode = status; })
-          .onData((chunk) => statusCode !== 200 ? errorBody += chunk : processChunk(chunk))
-          .onEnd(() => statusCode !== 200 ? reject({ status: statusCode, message: errorBody }) : resolve())
+          .onData((chunk) => {
+            if (statusCode !== 200) {
+              errorBody += chunk;
+            } else {
+              processChunk(chunk);
+            }
+          })
+          .onEnd(() => {
+            releaseLineBuffer(lineBuffer); // 归还到对象池
+            if (statusCode !== 200) {
+              reject({ status: statusCode, message: errorBody });
+            } else {
+              resolve();
+            }
+          })
           .onError(reject);
       });
-    } catch (error) {
-      await handleApiError(error, token);
     }
+  } catch (error) {
+    releaseLineBuffer(lineBuffer); // 确保归还
+    await handleApiError(error, token);
   }
 }
 
 export async function getAvailableModels() {
+  // 检查缓存是否有效（动态 TTL）
+  const now = Date.now();
+  const ttl = getModelCacheTTL();
+  if (modelListCache && (now - modelListCacheTime) < ttl) {
+    logger.info(`使用缓存的模型列表 (剩余有效期: ${Math.round((ttl - (now - modelListCacheTime)) / 1000)}秒)`);
+    return modelListCache;
+  }
+  
   const token = await tokenManager.getToken();
-  if (!token) throw new Error('没有可用的token，请运行 npm run login 获取token');
+  if (!token) {
+    // 没有 token 时返回默认模型列表
+    logger.warn('没有可用的 token，返回默认模型列表');
+    return getDefaultModelList();
+  }
   
   const headers = buildHeaders(token);
   
@@ -224,28 +392,58 @@ export async function getAvailableModels() {
       data = await response.json();
     }
     //console.log(JSON.stringify(data,null,2));
-    const modelList = Object.keys(data.models).map(id => ({
+    const created = Math.floor(Date.now() / 1000);
+    const modelList = Object.keys(data.models || {}).map(id => ({
         id,
         object: 'model',
-        created: Math.floor(Date.now() / 1000),
+        created,
         owned_by: 'google'
       }));
-    modelList.push({
-      id: "claude-opus-4-5",
-      object: 'model',
-      created: Math.floor(Date.now() / 1000),
-      owned_by: 'google'
-    })
     
-    return {
+    // 添加默认模型（如果 API 返回的列表中没有）
+    const existingIds = new Set(modelList.map(m => m.id));
+    for (const defaultModel of DEFAULT_MODELS) {
+      if (!existingIds.has(defaultModel)) {
+        modelList.push({
+          id: defaultModel,
+          object: 'model',
+          created,
+          owned_by: 'google'
+        });
+      }
+    }
+    
+    const result = {
       object: 'list',
       data: modelList
     };
+    
+    // 更新缓存
+    modelListCache = result;
+    modelListCacheTime = now;
+    const currentTTL = getModelCacheTTL();
+    logger.info(`模型列表已缓存 (有效期: ${currentTTL / 1000}秒, 模型数量: ${modelList.length})`);
+    
+    return result;
   } catch (error) {
-    await handleApiError(error, token);
+    // 如果请求失败但有缓存，返回过期的缓存
+    if (modelListCache) {
+      logger.warn(`获取模型列表失败，使用过期缓存: ${error.message}`);
+      return modelListCache;
+    }
+    // 没有缓存时返回默认模型列表
+    logger.warn(`获取模型列表失败，返回默认模型列表: ${error.message}`);
+    return getDefaultModelList();
   }
 }
 
+// 清除模型列表缓存（可用于手动刷新）
+export function clearModelListCache() {
+  modelListCache = null;
+  modelListCacheTime = 0;
+  logger.info('模型列表缓存已清除');
+}
+
 export async function getModelsWithQuotas(token) {
   const headers = buildHeaders(token);
   
@@ -301,13 +499,14 @@ export async function generateAssistantResponseNoStream(requestBody, token) {
   // 解析响应内容
   const parts = data.response?.candidates?.[0]?.content?.parts || [];
   let content = '';
-  let thinkingContent = '';
+  let reasoningContent = '';
   const toolCalls = [];
   const imageUrls = [];
   
   for (const part of parts) {
     if (part.thought === true) {
-      thinkingContent += part.text || '';
+      // 思维链内容 - 使用 DeepSeek 格式的 reasoning_content
+      reasoningContent += part.text || '';
     } else if (part.text !== undefined) {
       content += part.text;
     } else if (part.functionCall) {
@@ -319,11 +518,6 @@ export async function generateAssistantResponseNoStream(requestBody, token) {
     }
   }
   
-  // 拼接思维链标签
-  if (thinkingContent) {
-    content = `<think>\n${thinkingContent}\n</think>\n${content}`;
-  }
-  
   // 提取 token 使用统计
   const usage = data.response?.usageMetadata;
   const usageData = usage ? {
@@ -336,10 +530,10 @@ export async function generateAssistantResponseNoStream(requestBody, token) {
   if (imageUrls.length > 0) {
     let markdown = content ? content + '\n\n' : '';
     markdown += imageUrls.map(url => `![image](${url})`).join('\n\n');
-    return { content: markdown, toolCalls, usage: usageData };
+    return { content: markdown, reasoningContent: reasoningContent || null, toolCalls, usage: usageData };
   }
   
-  return { content, toolCalls, usage: usageData };
+  return { content, reasoningContent: reasoningContent || null, toolCalls, usage: usageData };
 }
 
 export async function generateImageForSD(requestBody, token) {
@@ -371,3 +565,6 @@ export async function generateImageForSD(requestBody, token) {
 export function closeRequester() {
   if (requester) requester.close();
 }
+
+// 导出内存清理注册函数（供外部调用）
+export { registerMemoryCleanup };

src/auth/quota_manager.js

@@ -2,6 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { log } from '../utils/logger.js';
+import memoryManager, { MemoryPressure } from '../utils/memoryManager.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -12,9 +13,11 @@ class QuotaManager {
     this.cache = new Map();
     this.CACHE_TTL = 5 * 60 * 1000; // 5分钟缓存
     this.CLEANUP_INTERVAL = 60 * 60 * 1000; // 1小时清理一次
+    this.cleanupTimer = null;
     this.ensureFileExists();
     this.loadFromFile();
     this.startCleanupTimer();
+    this.registerMemoryCleanup();
   }
 
   ensureFileExists() {
@@ -93,7 +96,35 @@ class QuotaManager {
   }
 
   startCleanupTimer() {
-    setInterval(() => this.cleanup(), this.CLEANUP_INTERVAL);
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+    }
+    this.cleanupTimer = setInterval(() => this.cleanup(), this.CLEANUP_INTERVAL);
+  }
+
+  stopCleanupTimer() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+
+  // 注册内存清理回调
+  registerMemoryCleanup() {
+    memoryManager.registerCleanup((pressure) => {
+      // 根据压力级别调整缓存 TTL
+      if (pressure === MemoryPressure.CRITICAL) {
+        // 紧急时清理所有缓存
+        const size = this.cache.size;
+        if (size > 0) {
+          this.cache.clear();
+          log.info(`紧急清理 ${size} 个额度缓存`);
+        }
+      } else if (pressure === MemoryPressure.HIGH) {
+        // 高压力时清理过期缓存
+        this.cleanup();
+      }
+    });
   }
 
   convertToBeijingTime(utcTimeStr) {

src/auth/token_manager.js

@@ -4,17 +4,30 @@ import { fileURLToPath } from 'url';
 import axios from 'axios';
 import { log } from '../utils/logger.js';
 import { generateSessionId, generateProjectId } from '../utils/idGenerator.js';
-import config from '../config/config.js';
+import config, { getConfigJson } from '../config/config.js';
 import { OAUTH_CONFIG } from '../constants/oauth.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+// 轮询策略枚举
+const RotationStrategy = {
+  ROUND_ROBIN: 'round_robin',           // 均衡负载：每次请求切换
+  QUOTA_EXHAUSTED: 'quota_exhausted',   // 额度耗尽才切换
+  REQUEST_COUNT: 'request_count'        // 自定义次数后切换
+};
+
 class TokenManager {
   constructor(filePath = path.join(__dirname,'..','..','data' ,'accounts.json')) {
     this.filePath = filePath;
     this.tokens = [];
     this.currentIndex = 0;
+    
+    // 轮询策略相关 - 使用原子操作避免锁
+    this.rotationStrategy = RotationStrategy.ROUND_ROBIN;
+    this.requestCountPerToken = 50;  // request_count 策略下每个token请求次数后切换
+    this.tokenRequestCounts = new Map();  // 记录每个token的请求次数
+    
     this.ensureFileExists();
     this.initialize();
   }
@@ -42,12 +55,22 @@ class TokenManager {
       }));
       
       this.currentIndex = 0;
+      this.tokenRequestCounts.clear();
+      
+      // 加载轮询策略配置
+      this.loadRotationConfig();
+      
       if (this.tokens.length === 0) {
         log.warn('⚠ 暂无可用账号，请使用以下方式添加：');
         log.warn('  方式1: 运行 npm run login 命令登录');
         log.warn('  方式2: 访问前端管理页面添加账号');
       } else {
         log.info(`成功加载 ${this.tokens.length} 个可用token`);
+        if (this.rotationStrategy === RotationStrategy.REQUEST_COUNT) {
+          log.info(`轮询策略: ${this.rotationStrategy}, 每token请求 ${this.requestCountPerToken} 次后切换`);
+        } else {
+          log.info(`轮询策略: ${this.rotationStrategy}`);
+        }
       }
     } catch (error) {
       log.error('初始化token失败:', error.message);
@@ -55,6 +78,36 @@ class TokenManager {
     }
   }
 
+  // 加载轮询策略配置
+  loadRotationConfig() {
+    try {
+      const jsonConfig = getConfigJson();
+      if (jsonConfig.rotation) {
+        this.rotationStrategy = jsonConfig.rotation.strategy || RotationStrategy.ROUND_ROBIN;
+        this.requestCountPerToken = jsonConfig.rotation.requestCount || 10;
+      }
+    } catch (error) {
+      log.warn('加载轮询配置失败，使用默认值:', error.message);
+    }
+  }
+
+  // 更新轮询策略（热更新）
+  updateRotationConfig(strategy, requestCount) {
+    if (strategy && Object.values(RotationStrategy).includes(strategy)) {
+      this.rotationStrategy = strategy;
+    }
+    if (requestCount && requestCount > 0) {
+      this.requestCountPerToken = requestCount;
+    }
+    // 重置计数器
+    this.tokenRequestCounts.clear();
+    if (this.rotationStrategy === RotationStrategy.REQUEST_COUNT) {
+      log.info(`轮询策略已更新: ${this.rotationStrategy}, 每token请求 ${this.requestCountPerToken} 次后切换`);
+    } else {
+      log.info(`轮询策略已更新: ${this.rotationStrategy}`);
+    }
+  }
+
   async fetchProjectId(token) {
     const response = await axios({
       method: 'POST',
@@ -156,14 +209,79 @@ class TokenManager {
     this.currentIndex = this.currentIndex % Math.max(this.tokens.length, 1);
   }
 
+  // 原子操作：获取并递增请求计数
+  incrementRequestCount(tokenKey) {
+    const current = this.tokenRequestCounts.get(tokenKey) || 0;
+    const newCount = current + 1;
+    this.tokenRequestCounts.set(tokenKey, newCount);
+    return newCount;
+  }
+
+  // 原子操作：重置请求计数
+  resetRequestCount(tokenKey) {
+    this.tokenRequestCounts.set(tokenKey, 0);
+  }
+
+  // 判断是否应该切换到下一个token
+  shouldRotate(token) {
+    switch (this.rotationStrategy) {
+      case RotationStrategy.ROUND_ROBIN:
+        // 均衡负载：每次请求后都切换
+        return true;
+        
+      case RotationStrategy.QUOTA_EXHAUSTED:
+        // 额度耗尽才切换：检查token的hasQuota标记
+        // 如果hasQuota为false，说明额度已耗尽，需要切换
+        return token.hasQuota === false;
+        
+      case RotationStrategy.REQUEST_COUNT:
+        // 自定义次数后切换
+        const tokenKey = token.refresh_token;
+        const count = this.incrementRequestCount(tokenKey);
+        if (count >= this.requestCountPerToken) {
+          this.resetRequestCount(tokenKey);
+          return true;
+        }
+        return false;
+        
+      default:
+        return true;
+    }
+  }
+
+  // 标记token额度耗尽
+  markQuotaExhausted(token) {
+    token.hasQuota = false;
+    this.saveToFile(token);
+    log.warn(`...${token.access_token.slice(-8)}: 额度已耗尽，标记为无额度`);
+    
+    // 如果是额度耗尽策略，立即切换到下一个token
+    if (this.rotationStrategy === RotationStrategy.QUOTA_EXHAUSTED) {
+      this.currentIndex = (this.currentIndex + 1) % Math.max(this.tokens.length, 1);
+    }
+  }
+
+  // 恢复token额度（用于额度重置后）
+  restoreQuota(token) {
+    token.hasQuota = true;
+    this.saveToFile(token);
+    log.info(`...${token.access_token.slice(-8)}: 额度已恢复`);
+  }
+
   async getToken() {
     if (this.tokens.length === 0) return null;
 
-    //const startIndex = this.currentIndex;
     const totalTokens = this.tokens.length;
+    const startIndex = this.currentIndex;
 
     for (let i = 0; i < totalTokens; i++) {
-      const token = this.tokens[this.currentIndex];
+      const index = (startIndex + i) % totalTokens;
+      const token = this.tokens[index];
+      
+      // 额度耗尽策略：跳过无额度的token
+      if (this.rotationStrategy === RotationStrategy.QUOTA_EXHAUSTED && token.hasQuota === false) {
+        continue;
+      }
       
       try {
         if (this.isExpired(token)) {
@@ -187,12 +305,19 @@ class TokenManager {
               this.saveToFile(token);
             } catch (error) {
               log.error(`...${token.access_token.slice(-8)}: 获取projectId失败:`, error.message);
-              this.currentIndex = (this.currentIndex + 1) % this.tokens.length;
               continue;
             }
           }
         }
-        this.currentIndex = (this.currentIndex + 1) % this.tokens.length;
+        
+        // 更新当前索引
+        this.currentIndex = index;
+        
+        // 根据策略决定是否切换
+        if (this.shouldRotate(token)) {
+          this.currentIndex = (this.currentIndex + 1) % totalTokens;
+        }
+        
         return token;
       } catch (error) {
         if (error.statusCode === 403 || error.statusCode === 400) {
@@ -201,11 +326,21 @@ class TokenManager {
           if (this.tokens.length === 0) return null;
         } else {
           log.error(`...${token.access_token.slice(-8)} 刷新失败:`, error.message);
-          this.currentIndex = (this.currentIndex + 1) % this.tokens.length;
         }
       }
     }
 
+    // 如果所有token都无额度，重置所有token的额度状态并重试
+    if (this.rotationStrategy === RotationStrategy.QUOTA_EXHAUSTED) {
+      log.warn('所有token额度已耗尽，重置额度状态');
+      this.tokens.forEach(t => {
+        t.hasQuota = true;
+      });
+      this.saveToFile();
+      // 返回第一个可用token
+      return this.tokens[0] || null;
+    }
+
     return null;
   }
 
@@ -242,6 +377,9 @@ class TokenManager {
       if (tokenData.email) {
         newToken.email = tokenData.email;
       }
+      if (tokenData.hasQuota !== undefined) {
+        newToken.hasQuota = tokenData.hasQuota;
+      }
       
       allTokens.push(newToken);
       fs.writeFileSync(this.filePath, JSON.stringify(allTokens, null, 2), 'utf8');
@@ -311,13 +449,28 @@ class TokenManager {
         timestamp: token.timestamp,
         enable: token.enable !== false,
         projectId: token.projectId || null,
-        email: token.email || null
+        email: token.email || null,
+        hasQuota: token.hasQuota !== false
       }));
     } catch (error) {
       log.error('获取Token列表失败:', error.message);
       return [];
     }
   }
+
+  // 获取当前轮询配置
+  getRotationConfig() {
+    return {
+      strategy: this.rotationStrategy,
+      requestCount: this.requestCountPerToken,
+      currentIndex: this.currentIndex,
+      tokenCounts: Object.fromEntries(this.tokenRequestCounts)
+    };
+  }
 }
+
+// 导出策略枚举
+export { RotationStrategy };
+
 const tokenManager = new TokenManager();
 export default tokenManager;

src/config/config.js

@@ -27,10 +27,41 @@ if (fs.existsSync(configJsonPath)) {
 // 加载 .env
 dotenv.config();
 
+// 获取代理配置：优先使用 PROXY，其次使用系统代理环境变量
+function getProxyConfig() {
+  // 优先使用显式配置的 PROXY
+  if (process.env.PROXY) {
+    return process.env.PROXY;
+  }
+  
+  // 检查系统代理环境变量（按优先级）
+  const systemProxy = process.env.HTTPS_PROXY ||
+                      process.env.https_proxy ||
+                      process.env.HTTP_PROXY ||
+                      process.env.http_proxy ||
+                      process.env.ALL_PROXY ||
+                      process.env.all_proxy;
+  
+  if (systemProxy) {
+    log.info(`使用系统代理: ${systemProxy}`);
+  }
+  
+  return systemProxy || null;
+}
+
 const config = {
   server: {
     port: jsonConfig.server?.port || 8045,
-    host: jsonConfig.server?.host || '0.0.0.0'
+    host: jsonConfig.server?.host || '0.0.0.0',
+    heartbeatInterval: jsonConfig.server?.heartbeatInterval || 15000,  // 心跳间隔(ms)，防止CF超时
+    memoryThreshold: jsonConfig.server?.memoryThreshold || 500  // 内存阈值(MB)，超过触发GC
+  },
+  cache: {
+    modelListTTL: jsonConfig.cache?.modelListTTL || 60 * 60 * 1000  // 模型列表缓存时间(ms)，默认60分钟
+  },
+  rotation: {
+    strategy: jsonConfig.rotation?.strategy || 'round_robin',  // 轮询策略: round_robin, quota_exhausted, request_count
+    requestCount: jsonConfig.rotation?.requestCount || 10  // request_count策略下每个token的请求次数
   },
   imageBaseUrl: process.env.IMAGE_BASE_URL || null,
   maxImages: jsonConfig.other?.maxImages || 10,
@@ -45,7 +76,8 @@ const config = {
     temperature: jsonConfig.defaults?.temperature || 1,
     top_p: jsonConfig.defaults?.topP || 0.85,
     top_k: jsonConfig.defaults?.topK || 50,
-    max_tokens: jsonConfig.defaults?.maxTokens || 8096
+    max_tokens: jsonConfig.defaults?.maxTokens || 32000,
+    thinking_budget: jsonConfig.defaults?.thinkingBudget || 16000
   },
   security: {
     maxRequestSize: jsonConfig.server?.maxRequestSize || '50mb',
@@ -57,8 +89,8 @@ const config = {
     jwtSecret: process.env.JWT_SECRET || 'your-jwt-secret-key-change-this-in-production'
   },
   useNativeAxios: jsonConfig.other?.useNativeAxios !== false,
-  timeout: jsonConfig.other?.timeout || 180000,
-  proxy: process.env.PROXY || null,
+  timeout: jsonConfig.other?.timeout || 300000,
+  proxy: getProxyConfig(),
   systemInstruction: process.env.SYSTEM_INSTRUCTION || '',
   skipProjectIdFetch: jsonConfig.other?.skipProjectIdFetch === true
 };

src/routes/admin.js

@@ -129,21 +129,26 @@ router.post('/oauth/exchange', authMiddleware, async (req, res) => {
       logger.warn('获取用户邮箱失败:', err.message);
     }
     
-    if (config.skipProjectIdFetch) {
-      account.projectId = generateProjectId();
-      logger.info('使用随机生成的projectId: ' + account.projectId);
-    } else {
-      try {
-        const projectId = await tokenManager.fetchProjectId(account);
-        if (projectId === undefined) {
-          return res.status(400).json({ success: false, message: '该账号无资格使用（无法获取projectId）' });
-        }
+    // 始终尝试获取 projectId 进行资格校验
+    // 如果无资格，自动退回到无资格模式使用随机 projectId
+    try {
+      const projectId = await tokenManager.fetchProjectId(account);
+      if (projectId === undefined) {
+        // 无资格，自动退回到无资格模式
+        account.projectId = generateProjectId();
+        account.hasQuota = false;
+        logger.warn('该账号无资格使用，已自动退回无资格模式，使用随机projectId: ' + account.projectId);
+      } else {
         account.projectId = projectId;
+        account.hasQuota = true;
         logger.info('账号验证通过，projectId: ' + projectId);
-      } catch (error) {
-        logger.error('验证账号资格失败:', error.message);
-        return res.status(500).json({ success: false, message: '验证账号资格失败: ' + error.message });
       }
+    } catch (error) {
+      // 获取失败时也退回到无资格模式
+      logger.warn('验证账号资格失败: ' + error.message + '，已自动退回无资格模式');
+      account.projectId = generateProjectId();
+      account.hasQuota = false;
+      logger.info('使用随机生成的projectId: ' + account.projectId);
     }
     
     res.json({ success: true, data: account });
@@ -191,6 +196,49 @@ router.put('/config', authMiddleware, (req, res) => {
   }
 });
 
+// 获取轮询策略配置
+router.get('/rotation', authMiddleware, (req, res) => {
+  try {
+    const rotationConfig = tokenManager.getRotationConfig();
+    res.json({ success: true, data: rotationConfig });
+  } catch (error) {
+    logger.error('获取轮询配置失败:', error.message);
+    res.status(500).json({ success: false, message: error.message });
+  }
+});
+
+// 更新轮询策略配置
+router.put('/rotation', authMiddleware, (req, res) => {
+  try {
+    const { strategy, requestCount } = req.body;
+    
+    // 验证策略值
+    const validStrategies = ['round_robin', 'quota_exhausted', 'request_count'];
+    if (strategy && !validStrategies.includes(strategy)) {
+      return res.status(400).json({
+        success: false,
+        message: `无效的策略，可选值: ${validStrategies.join(', ')}`
+      });
+    }
+    
+    // 更新内存中的配置
+    tokenManager.updateRotationConfig(strategy, requestCount);
+    
+    // 同时保存到config.json
+    const currentConfig = getConfigJson();
+    if (!currentConfig.rotation) currentConfig.rotation = {};
+    if (strategy) currentConfig.rotation.strategy = strategy;
+    if (requestCount) currentConfig.rotation.requestCount = requestCount;
+    saveConfigJson(currentConfig);
+    
+    logger.info(`轮询策略已更新: ${strategy || '未变'}, 请求次数: ${requestCount || '未变'}`);
+    res.json({ success: true, message: '轮询策略已更新', data: tokenManager.getRotationConfig() });
+  } catch (error) {
+    logger.error('更新轮询配置失败:', error.message);
+    res.status(500).json({ success: false, message: error.message });
+  }
+});
+
 // 获取指定Token的模型额度
 router.get('/tokens/:refreshToken/quotas', authMiddleware, async (req, res) => {
   try {
@@ -209,7 +257,8 @@ router.get('/tokens/:refreshToken/quotas', authMiddleware, async (req, res) => {
         tokenData = await tokenManager.refreshToken(tokenData);
       } catch (error) {
         logger.error('刷新token失败:', error.message);
-        return res.status(401).json({ success: false, message: 'Token已过期且刷新失败' });
+        // 使用 400 而不是 401，避免前端误认为 JWT 登录过期
+        return res.status(400).json({ success: false, message: 'Google Token已过期且刷新失败，请重新登录Google账号' });
       }
     }
     

src/server/index.js

@@ -9,12 +9,39 @@ import config from '../config/config.js';
 import tokenManager from '../auth/token_manager.js';
 import adminRouter from '../routes/admin.js';
 import sdRouter from '../routes/sd.js';
+import memoryManager, { MemoryPressure } from '../utils/memoryManager.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 const app = express();
 
+// ==================== 心跳机制（防止 CF 超时） ====================
+const HEARTBEAT_INTERVAL = config.server.heartbeatInterval || 15000; // 从配置读取心跳间隔
+const SSE_HEARTBEAT = Buffer.from(': heartbeat\n\n');
+
+// 创建心跳定时器
+const createHeartbeat = (res) => {
+  const timer = setInterval(() => {
+    if (!res.writableEnded) {
+      res.write(SSE_HEARTBEAT);
+    } else {
+      clearInterval(timer);
+    }
+  }, HEARTBEAT_INTERVAL);
+  
+  // 响应结束时清理
+  res.on('close', () => clearInterval(timer));
+  res.on('finish', () => clearInterval(timer));
+  
+  return timer;
+};
+
+// 预编译的常量字符串（避免重复创建）
+const SSE_PREFIX = Buffer.from('data: ');
+const SSE_SUFFIX = Buffer.from('\n\n');
+const SSE_DONE = Buffer.from('data: [DONE]\n\n');
+
 // 工具函数：生成响应元数据
 const createResponseMeta = () => ({
   id: `chatcmpl-${Date.now()}`,
@@ -26,25 +53,54 @@ const setStreamHeaders = (res) => {
   res.setHeader('Content-Type', 'text/event-stream');
   res.setHeader('Cache-Control', 'no-cache');
   res.setHeader('Connection', 'keep-alive');
+  res.setHeader('X-Accel-Buffering', 'no'); // 禁用 nginx 缓冲
+};
+
+// 工具函数：构建流式数据块（使用动态对象池减少 GC）
+// 支持 DeepSeek 格式的 reasoning_content
+const chunkPool = [];
+const getChunkObject = () => chunkPool.pop() || { choices: [{ index: 0, delta: {}, finish_reason: null }] };
+const releaseChunkObject = (obj) => {
+  const maxSize = memoryManager.getPoolSizes().chunk;
+  if (chunkPool.length < maxSize) chunkPool.push(obj);
 };
 
-// 工具函数：构建流式数据块
-const createStreamChunk = (id, created, model, delta, finish_reason = null) => ({
-  id,
-  object: 'chat.completion.chunk',
-  created,
-  model,
-  choices: [{ index: 0, delta, finish_reason }]
+// 注册内存清理回调
+memoryManager.registerCleanup((pressure) => {
+  const poolSizes = memoryManager.getPoolSizes();
+  // 根据压力缩减对象池
+  while (chunkPool.length > poolSizes.chunk) {
+    chunkPool.pop();
+  }
 });
 
-// 工具函数：写入流式数据
+// 启动内存管理器
+memoryManager.start(30000);
+
+const createStreamChunk = (id, created, model, delta, finish_reason = null) => {
+  const chunk = getChunkObject();
+  chunk.id = id;
+  chunk.object = 'chat.completion.chunk';
+  chunk.created = created;
+  chunk.model = model;
+  chunk.choices[0].delta = delta;
+  chunk.choices[0].finish_reason = finish_reason;
+  return chunk;
+};
+
+// 工具函数：零拷贝写入流式数据
 const writeStreamData = (res, data) => {
-  res.write(`data: ${JSON.stringify(data)}\n\n`);
+  const json = JSON.stringify(data);
+  // 释放对象回池
+  if (data.choices) releaseChunkObject(data);
+  res.write(SSE_PREFIX);
+  res.write(json);
+  res.write(SSE_SUFFIX);
 };
 
 // 工具函数：结束流式响应
 const endStream = (res) => {
-  res.write('data: [DONE]\n\n');
+  res.write(SSE_DONE);
   res.end();
 };
 
@@ -102,6 +158,26 @@ app.get('/v1/models', async (req, res) => {
   }
 });
 
+// 内存监控端点
+app.get('/v1/memory', (req, res) => {
+  const usage = process.memoryUsage();
+  res.json({
+    heapUsed: usage.heapUsed,
+    heapTotal: usage.heapTotal,
+    rss: usage.rss,
+    external: usage.external,
+    arrayBuffers: usage.arrayBuffers,
+    pressure: memoryManager.getCurrentPressure(),
+    poolSizes: memoryManager.getPoolSizes(),
+    chunkPoolSize: chunkPool.length
+  });
+});
+
+// 健康检查端点
+app.get('/health', (req, res) => {
+  res.json({ status: 'ok', uptime: process.uptime() });
+});
+
 
 
 app.post('/v1/chat/completions', async (req, res) => {
@@ -136,35 +212,54 @@ app.post('/v1/chat/completions', async (req, res) => {
     if (stream) {
       setStreamHeaders(res);
       
-      if (isImageModel) {
-        //console.log(JSON.stringify(requestBody,null,2));
-        const { content, usage } = await generateAssistantResponseNoStream(requestBody, token);
-        writeStreamData(res, createStreamChunk(id, created, model, { content }));
-        writeStreamData(res, { ...createStreamChunk(id, created, model, {}, 'stop'), usage });
-        endStream(res);
-      } else {
-        let hasToolCall = false;
-        let usageData = null;
-        await generateAssistantResponse(requestBody, token, (data) => {
-          if (data.type === 'usage') {
-            usageData = data.usage;
-          } else {
-            const delta = data.type === 'tool_calls' 
-              ? { tool_calls: data.tool_calls } 
-              : { content: data.content };
-            if (data.type === 'tool_calls') hasToolCall = true;
-            writeStreamData(res, createStreamChunk(id, created, model, delta));
-          }
-        });
-        writeStreamData(res, { ...createStreamChunk(id, created, model, {}, hasToolCall ? 'tool_calls' : 'stop'), usage: usageData });
+      // 启动心跳，防止 Cloudflare 超时断连
+      const heartbeatTimer = createHeartbeat(res);
+      
+      try {
+        if (isImageModel) {
+          //console.log(JSON.stringify(requestBody,null,2));
+          const { content, usage } = await generateAssistantResponseNoStream(requestBody, token);
+          writeStreamData(res, createStreamChunk(id, created, model, { content }));
+          writeStreamData(res, { ...createStreamChunk(id, created, model, {}, 'stop'), usage });
+        } else {
+          let hasToolCall = false;
+          let usageData = null;
+          await generateAssistantResponse(requestBody, token, (data) => {
+            if (data.type === 'usage') {
+              usageData = data.usage;
+            } else if (data.type === 'reasoning') {
+              // DeepSeek 格式：思维链内容通过 reasoning_content 字段输出
+              const delta = { reasoning_content: data.reasoning_content };
+              writeStreamData(res, createStreamChunk(id, created, model, delta));
+            } else if (data.type === 'tool_calls') {
+              hasToolCall = true;
+              const delta = { tool_calls: data.tool_calls };
+              writeStreamData(res, createStreamChunk(id, created, model, delta));
+            } else {
+              const delta = { content: data.content };
+              writeStreamData(res, createStreamChunk(id, created, model, delta));
+            }
+          });
+          writeStreamData(res, { ...createStreamChunk(id, created, model, {}, hasToolCall ? 'tool_calls' : 'stop'), usage: usageData });
+        }
+      } finally {
+        clearInterval(heartbeatTimer);
         endStream(res);
       }
     } else {
-      const { content, toolCalls, usage } = await generateAssistantResponseNoStream(requestBody, token);
-      const message = { role: 'assistant', content };
+      // 非流式请求：设置较长超时，避免大模型响应超时
+      req.setTimeout(0); // 禁用请求超时
+      res.setTimeout(0); // 禁用响应超时
+      
+      const { content, reasoningContent, toolCalls, usage } = await generateAssistantResponseNoStream(requestBody, token);
+      // DeepSeek 格式：reasoning_content 在 content 之前
+      const message = { role: 'assistant' };
+      if (reasoningContent) message.reasoning_content = reasoningContent;
+      message.content = content;
       if (toolCalls.length > 0) message.tool_calls = toolCalls;
       
-      res.json({
+      // 使用预构建的响应对象，减少内存分配
+      const response = {
         id,
         object: 'chat.completion',
         created,
@@ -175,7 +270,9 @@ app.post('/v1/chat/completions', async (req, res) => {
           finish_reason: toolCalls.length > 0 ? 'tool_calls' : 'stop'
         }],
         usage
-      });
+      };
+      
+      res.json(response);
     }
   } catch (error) {
     logger.error('生成响应失败:', error.message);
@@ -224,13 +321,40 @@ server.on('error', (error) => {
 
 const shutdown = () => {
   logger.info('正在关闭服务器...');
+  
+  // 停止内存管理器
+  memoryManager.stop();
+  logger.info('已停止内存管理器');
+  
+  // 关闭子进程请求器
   closeRequester();
+  logger.info('已关闭子进程请求器');
+  
+  // 清理对象池
+  chunkPool.length = 0;
+  logger.info('已清理对象池');
+  
   server.close(() => {
     logger.info('服务器已关闭');
     process.exit(0);
   });
-  setTimeout(() => process.exit(0), 5000);
+  
+  // 5秒超时强制退出
+  setTimeout(() => {
+    logger.warn('服务器关闭超时，强制退出');
+    process.exit(0);
+  }, 5000);
 };
 
 process.on('SIGINT', shutdown);
 process.on('SIGTERM', shutdown);
+
+// 未捕获异常处理
+process.on('uncaughtException', (error) => {
+  logger.error('未捕获异常:', error.message);
+  // 不立即退出，让当前请求完成
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+  logger.error('未处理的 Promise 拒绝:', reason);
+});

src/utils/configReloader.js

@@ -9,8 +9,9 @@ const CONFIG_MAPPING = [
   { target: 'defaults.temperature', source: 'defaults.temperature', default: 1 },
   { target: 'defaults.top_p', source: 'defaults.topP', default: 0.85 },
   { target: 'defaults.top_k', source: 'defaults.topK', default: 50 },
-  { target: 'defaults.max_tokens', source: 'defaults.maxTokens', default: 8096 },
-  { target: 'timeout', source: 'other.timeout', default: 180000 },
+  { target: 'defaults.max_tokens', source: 'defaults.maxTokens', default: 32000 },
+  { target: 'defaults.thinking_budget', source: 'defaults.thinkingBudget', default: 16000 },
+  { target: 'timeout', source: 'other.timeout', default: 300000 },
   { target: 'skipProjectIdFetch', source: 'other.skipProjectIdFetch', default: false, transform: v => v === true },
   { target: 'maxImages', source: 'other.maxImages', default: 10 },
   { target: 'useNativeAxios', source: 'other.useNativeAxios', default: true, transform: v => v !== false },
@@ -21,9 +22,27 @@ const CONFIG_MAPPING = [
   { target: 'api.userAgent', source: 'api.userAgent', default: 'antigravity/1.11.3 windows/amd64' }
 ];
 
+/**
+ * 获取代理配置：优先使用 PROXY，其次使用系统代理环境变量
+ */
+function getProxyConfig() {
+  // 优先使用显式配置的 PROXY
+  if (process.env.PROXY) {
+    return process.env.PROXY;
+  }
+  
+  // 检查系统代理环境变量（按优先级）
+  return process.env.HTTPS_PROXY ||
+         process.env.https_proxy ||
+         process.env.HTTP_PROXY ||
+         process.env.http_proxy ||
+         process.env.ALL_PROXY ||
+         process.env.all_proxy ||
+         null;
+}
+
 const ENV_MAPPING = [
   { target: 'security.apiKey', env: 'API_KEY', default: null },
-  { target: 'proxy', env: 'PROXY', default: null },
   { target: 'systemInstruction', env: 'SYSTEM_INSTRUCTION', default: '' }
 ];
 
@@ -62,4 +81,7 @@ export function reloadConfig() {
     const value = process.env[env] || defaultValue;
     setNestedValue(config, target, value);
   });
+  
+  // 单独处理代理配置（支持系统代理环境变量）
+  config.proxy = getProxyConfig();
 }

src/utils/memoryManager.js

@@ -0,0 +1,268 @@
+/**
+ * 智能内存管理器
+ * 采用分级策略，根据内存压力动态调整缓存和对象池
+ * 目标：在保证性能的前提下，将内存稳定在 20MB 左右
+ */
+
+import logger from './logger.js';
+
+// 内存压力级别
+const MemoryPressure = {
+  LOW: 'low',       // < 15MB - 正常运行
+  MEDIUM: 'medium', // 15-25MB - 轻度清理
+  HIGH: 'high',     // 25-35MB - 积极清理
+  CRITICAL: 'critical' // > 35MB - 紧急清理
+};
+
+// 阈值配置（字节）
+const THRESHOLDS = {
+  LOW: 15 * 1024 * 1024,      // 15MB
+  MEDIUM: 25 * 1024 * 1024,   // 25MB
+  HIGH: 35 * 1024 * 1024,     // 35MB
+  TARGET: 20 * 1024 * 1024    // 20MB 目标
+};
+
+// 对象池最大大小配置（根据压力调整）
+const POOL_SIZES = {
+  [MemoryPressure.LOW]: { chunk: 30, toolCall: 15, lineBuffer: 5 },
+  [MemoryPressure.MEDIUM]: { chunk: 20, toolCall: 10, lineBuffer: 3 },
+  [MemoryPressure.HIGH]: { chunk: 10, toolCall: 5, lineBuffer: 2 },
+  [MemoryPressure.CRITICAL]: { chunk: 5, toolCall: 3, lineBuffer: 1 }
+};
+
+class MemoryManager {
+  constructor() {
+    this.currentPressure = MemoryPressure.LOW;
+    this.cleanupCallbacks = new Set();
+    this.lastGCTime = 0;
+    this.gcCooldown = 10000; // GC 冷却时间 10秒
+    this.checkInterval = null;
+    this.isShuttingDown = false;
+    
+    // 统计信息
+    this.stats = {
+      gcCount: 0,
+      cleanupCount: 0,
+      peakMemory: 0
+    };
+  }
+
+  /**
+   * 启动内存监控
+   * @param {number} interval - 检查间隔（毫秒）
+   */
+  start(interval = 30000) {
+    if (this.checkInterval) return;
+    
+    this.checkInterval = setInterval(() => {
+      if (!this.isShuttingDown) {
+        this.check();
+      }
+    }, interval);
+    
+    // 首次立即检查
+    this.check();
+    logger.info(`内存管理器已启动 (检查间隔: ${interval/1000}秒)`);
+  }
+
+  /**
+   * 停止内存监控
+   */
+  stop() {
+    this.isShuttingDown = true;
+    if (this.checkInterval) {
+      clearInterval(this.checkInterval);
+      this.checkInterval = null;
+    }
+    this.cleanupCallbacks.clear();
+    logger.info('内存管理器已停止');
+  }
+
+  /**
+   * 注册清理回调
+   * @param {Function} callback - 清理函数，接收 pressure 参数
+   */
+  registerCleanup(callback) {
+    this.cleanupCallbacks.add(callback);
+  }
+
+  /**
+   * 取消注册清理回调
+   * @param {Function} callback
+   */
+  unregisterCleanup(callback) {
+    this.cleanupCallbacks.delete(callback);
+  }
+
+  /**
+   * 获取当前内存使用情况
+   */
+  getMemoryUsage() {
+    const usage = process.memoryUsage();
+    return {
+      heapUsed: usage.heapUsed,
+      heapTotal: usage.heapTotal,
+      rss: usage.rss,
+      external: usage.external,
+      heapUsedMB: Math.round(usage.heapUsed / 1024 / 1024 * 10) / 10
+    };
+  }
+
+  /**
+   * 确定内存压力级别
+   */
+  getPressureLevel(heapUsed) {
+    if (heapUsed < THRESHOLDS.LOW) return MemoryPressure.LOW;
+    if (heapUsed < THRESHOLDS.MEDIUM) return MemoryPressure.MEDIUM;
+    if (heapUsed < THRESHOLDS.HIGH) return MemoryPressure.HIGH;
+    return MemoryPressure.CRITICAL;
+  }
+
+  /**
+   * 获取当前压力下的对象池大小配置
+   */
+  getPoolSizes() {
+    return POOL_SIZES[this.currentPressure];
+  }
+
+  /**
+   * 获取当前压力级别
+   */
+  getCurrentPressure() {
+    return this.currentPressure;
+  }
+
+  /**
+   * 检查内存并触发相应清理
+   */
+  check() {
+    const { heapUsed, heapUsedMB } = this.getMemoryUsage();
+    const newPressure = this.getPressureLevel(heapUsed);
+    
+    // 更新峰值统计
+    if (heapUsed > this.stats.peakMemory) {
+      this.stats.peakMemory = heapUsed;
+    }
+    
+    // 压力级别变化时记录日志
+    if (newPressure !== this.currentPressure) {
+      logger.info(`内存压力变化: ${this.currentPressure} -> ${newPressure} (${heapUsedMB}MB)`);
+      this.currentPressure = newPressure;
+    }
+    
+    // 根据压力级别执行不同策略
+    switch (newPressure) {
+      case MemoryPressure.CRITICAL:
+        this.handleCriticalPressure(heapUsedMB);
+        break;
+      case MemoryPressure.HIGH:
+        this.handleHighPressure(heapUsedMB);
+        break;
+      case MemoryPressure.MEDIUM:
+        this.handleMediumPressure(heapUsedMB);
+        break;
+      // LOW 压力不需要特殊处理
+    }
+    
+    return newPressure;
+  }
+
+  /**
+   * 处理中等压力
+   */
+  handleMediumPressure(heapUsedMB) {
+    // 通知各模块缩减对象池
+    this.notifyCleanup(MemoryPressure.MEDIUM);
+    this.stats.cleanupCount++;
+  }
+
+  /**
+   * 处理高压力
+   */
+  handleHighPressure(heapUsedMB) {
+    logger.info(`内存较高 (${heapUsedMB}MB)，执行积极清理`);
+    this.notifyCleanup(MemoryPressure.HIGH);
+    this.stats.cleanupCount++;
+    
+    // 尝试触发 GC（带冷却）
+    this.tryGC();
+  }
+
+  /**
+   * 处理紧急压力
+   */
+  handleCriticalPressure(heapUsedMB) {
+    logger.warn(`内存紧急 (${heapUsedMB}MB)，执���紧急清理`);
+    this.notifyCleanup(MemoryPressure.CRITICAL);
+    this.stats.cleanupCount++;
+    
+    // 强制 GC（忽略冷却）
+    this.forceGC();
+  }
+
+  /**
+   * 通知所有注册的清理回调
+   */
+  notifyCleanup(pressure) {
+    for (const callback of this.cleanupCallbacks) {
+      try {
+        callback(pressure);
+      } catch (error) {
+        logger.error('清理回调执行失败:', error.message);
+      }
+    }
+  }
+
+  /**
+   * 尝试触发 GC（带冷却时间）
+   */
+  tryGC() {
+    const now = Date.now();
+    if (now - this.lastGCTime < this.gcCooldown) {
+      return false;
+    }
+    return this.forceGC();
+  }
+
+  /**
+   * 强制触发 GC
+   */
+  forceGC() {
+    if (global.gc) {
+      const before = this.getMemoryUsage().heapUsedMB;
+      global.gc();
+      this.lastGCTime = Date.now();
+      this.stats.gcCount++;
+      const after = this.getMemoryUsage().heapUsedMB;
+      logger.info(`GC 完成: ${before}MB -> ${after}MB (释放 ${(before - after).toFixed(1)}MB)`);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * 手动触发检查和清理
+   */
+  cleanup() {
+    return this.check();
+  }
+
+  /**
+   * 获取统计信息
+   */
+  getStats() {
+    const memory = this.getMemoryUsage();
+    return {
+      ...this.stats,
+      currentPressure: this.currentPressure,
+      currentHeapMB: memory.heapUsedMB,
+      peakMemoryMB: Math.round(this.stats.peakMemory / 1024 / 1024 * 10) / 10,
+      poolSizes: this.getPoolSizes()
+    };
+  }
+}
+
+// 单例导出
+const memoryManager = new MemoryManager();
+export default memoryManager;
+export { MemoryPressure, THRESHOLDS };

src/utils/utils.js

@@ -2,6 +2,43 @@ import config from '../config/config.js';
 import tokenManager from '../auth/token_manager.js';
 import { generateRequestId } from './idGenerator.js';
 import os from 'os';
+import dns from 'dns';
+import http from 'http';
+import https from 'https';
+import logger from './logger.js';
+
+// ==================== DNS 解析优化 ====================
+// 自定义 DNS 解析：优先 IPv4，失败则回退 IPv6
+function customLookup(hostname, options, callback) {
+  // 先尝试 IPv4
+  dns.lookup(hostname, { ...options, family: 4 }, (err4, address4, family4) => {
+    if (!err4 && address4) {
+      // IPv4 成功
+      return callback(null, address4, family4);
+    }
+    // IPv4 失败，尝试 IPv6
+    dns.lookup(hostname, { ...options, family: 6 }, (err6, address6, family6) => {
+      if (!err6 && address6) {
+        // IPv6 成功
+        logger.debug(`DNS: ${hostname} IPv4 失败，使用 IPv6: ${address6}`);
+        return callback(null, address6, family6);
+      }
+      // 都失败，返回 IPv4 的错误
+      callback(err4 || err6);
+    });
+  });
+}
+
+// 创建使用自定义 DNS 解析的 HTTP/HTTPS Agent
+const httpAgent = new http.Agent({
+  lookup: customLookup,
+  keepAlive: true
+});
+
+const httpsAgent = new https.Agent({
+  lookup: customLookup,
+  keepAlive: true
+});
 
 function extractImagesFromContent(content) {
   const result = { text: '', images: [] };
@@ -118,7 +155,11 @@ function handleToolCall(message, antigravityMessages){
 function openaiMessageToAntigravity(openaiMessages){
   const antigravityMessages = [];
   for (const message of openaiMessages) {
-    if (message.role === "user" || message.role === "system") {
+    if (message.role === "user") {
+      const extracted = extractImagesFromContent(message.content);
+      handleUserMessage(extracted, antigravityMessages);
+    } else if (message.role === "system") {
+      // 中间的 system 消息作为 user 处理（开头的 system 已在 generateRequestBody 中过滤）
       const extracted = extractImagesFromContent(message.content);
       handleUserMessage(extracted, antigravityMessages);
     } else if (message.role === "assistant") {
@@ -130,7 +171,72 @@ function openaiMessageToAntigravity(openaiMessages){
   
   return antigravityMessages;
 }
+
+/**
+ * 从 OpenAI 消息中提取并合并 system 指令
+ * 规则：
+ * 1. SYSTEM_INSTRUCTION 作为基础 system，可为空
+ * 2. 保留用户首条 system 信息，合并在基础 system 后面
+ * 3. 如果连续多条 system，合并成一条 system
+ * 4. 避免把真正的 system 重复作为 user 发送
+ */
+function extractSystemInstruction(openaiMessages) {
+  const baseSystem = config.systemInstruction || '';
+  
+  // 收集开头连续的 system 消息
+  const systemTexts = [];
+  for (const message of openaiMessages) {
+    if (message.role === 'system') {
+      const content = typeof message.content === 'string'
+        ? message.content
+        : (Array.isArray(message.content)
+            ? message.content.filter(item => item.type === 'text').map(item => item.text).join('')
+            : '');
+      if (content.trim()) {
+        systemTexts.push(content.trim());
+      }
+    } else {
+      // 遇到非 system 消息就停止收集
+      break;
+    }
+  }
+  
+  // 合并：基础 system + 用户的 system 消息
+  const parts = [];
+  if (baseSystem.trim()) {
+    parts.push(baseSystem.trim());
+  }
+  if (systemTexts.length > 0) {
+    parts.push(systemTexts.join('\n\n'));
+  }
+  
+  return parts.join('\n\n');
+}
+// reasoning_effort 到 thinkingBudget 的映射
+const REASONING_EFFORT_MAP = {
+  'low': 1024,
+  'medium': 16000,
+  'high': 32000
+};
+
 function generateGenerationConfig(parameters, enableThinking, actualModelName){
+  // 获取思考预算：
+  // 1. 优先使用 thinking_budget（直接数值）
+  // 2. 其次使用 reasoning_effort（OpenAI 格式：low/medium/high）
+  // 3. 最后使用配置默认值或硬编码默认值
+  const defaultThinkingBudget = config.defaults.thinking_budget ?? 16000;
+  
+  let thinkingBudget = 0;
+  if (enableThinking) {
+    if (parameters.thinking_budget !== undefined) {
+      thinkingBudget = parameters.thinking_budget;
+    } else if (parameters.reasoning_effort !== undefined) {
+      thinkingBudget = REASONING_EFFORT_MAP[parameters.reasoning_effort] ?? defaultThinkingBudget;
+    } else {
+      thinkingBudget = defaultThinkingBudget;
+    }
+  }
+  
   const generationConfig = {
     topP: parameters.top_p ?? config.defaults.top_p,
     topK: parameters.top_k ?? config.defaults.top_k,
@@ -146,7 +252,7 @@ function generateGenerationConfig(parameters, enableThinking, actualModelName){
     ],
     thinkingConfig: {
       includeThoughts: enableThinking,
-      thinkingBudget: enableThinking ? 1024 : 0
+      thinkingBudget: thinkingBudget
     }
   }
   if (enableThinking && actualModelName.includes("claude")){
@@ -208,15 +314,25 @@ function generateRequestBody(openaiMessages,modelName,parameters,openaiTools,tok
   const enableThinking = isEnableThinking(modelName);
   const actualModelName = modelMapping(modelName);
   
-  return{
+  // 提取合并后的 system 指令
+  const mergedSystemInstruction = extractSystemInstruction(openaiMessages);
+  
+  // 过滤掉开头连续的 system 消息，避免重复作为 user 发送
+  let startIndex = 0;
+  for (let i = 0; i < openaiMessages.length; i++) {
+    if (openaiMessages[i].role === 'system') {
+      startIndex = i + 1;
+    } else {
+      break;
+    }
+  }
+  const filteredMessages = openaiMessages.slice(startIndex);
+  
+  const requestBody = {
     project: token.projectId,
     requestId: generateRequestId(),
     request: {
-      contents: openaiMessageToAntigravity(openaiMessages),
-      systemInstruction: {
-        role: "user",
-        parts: [{ text: config.systemInstruction }]
-      },
+      contents: openaiMessageToAntigravity(filteredMessages),
       tools: convertOpenAIToolsToAntigravity(openaiTools),
       toolConfig: {
         functionCallingConfig: {
@@ -228,7 +344,17 @@ function generateRequestBody(openaiMessages,modelName,parameters,openaiTools,tok
     },
     model: actualModelName,
     userAgent: "antigravity"
+  };
+  
+  // 只有当有 system 指令时才添加 systemInstruction 字段
+  if (mergedSystemInstruction) {
+    requestBody.request.systemInstruction = {
+      role: "user",
+      parts: [{ text: mergedSystemInstruction }]
+    };
   }
+  
+  return requestBody;
 }
 function getDefaultIp(){
   const interfaces = os.networkInterfaces();
@@ -250,5 +376,7 @@ function getDefaultIp(){
 export{
   generateRequestId,
   generateRequestBody,
-  getDefaultIp
+  getDefaultIp,
+  httpAgent,
+  httpsAgent
 }

test/test-memory.js

@@ -0,0 +1,291 @@
+/**
+ * 内存优化效果测试脚本
+ * 用于验证服务的内存使用是否控制在目标范围内（约20MB）
+ */
+
+const http = require('http');
+const { spawn } = require('child_process');
+const path = require('path');
+
+// 配置
+const PORT = process.env.PORT || 9876;
+const BASE_URL = `http://localhost:${PORT}`;
+const TEST_DURATION_MS = 60000; // 测试持续时间：60秒
+const SAMPLE_INTERVAL_MS = 2000; // 采样间隔：2秒
+const REQUEST_INTERVAL_MS = 1000; // 请求间隔：1秒
+
+// 内存采样数据
+const memorySamples = [];
+let serverProcess = null;
+let testStartTime = null;
+
+/**
+ * 格式化内存大小
+ */
+function formatMemory(bytes) {
+  const mb = bytes / 1024 / 1024;
+  return `${mb.toFixed(2)} MB`;
+}
+
+/**
+ * 发送HTTP请求
+ */
+function sendRequest(urlPath, method = 'GET', body = null) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(urlPath, BASE_URL);
+    const options = {
+      hostname: url.hostname,
+      port: url.port,
+      path: url.pathname,
+      method: method,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      timeout: 5000
+    };
+
+    const req = http.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => resolve({ status: res.statusCode, data }));
+    });
+
+    req.on('error', reject);
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Request timeout'));
+    });
+
+    if (body) {
+      req.write(JSON.stringify(body));
+    }
+    req.end();
+  });
+}
+
+/**
+ * 获取服务器内存使用情况（通过 /v1/memory 端点）
+ */
+async function getServerMemory() {
+  try {
+    const response = await sendRequest('/v1/memory');
+    if (response.status === 200) {
+      const data = JSON.parse(response.data);
+      return data;
+    }
+  } catch (e) {
+    // 如果端点不存在，返回 null
+  }
+  return null;
+}
+
+/**
+ * 模拟API请求
+ */
+async function simulateLoad() {
+  const requests = [
+    { path: '/v1/models', method: 'GET' },
+    { path: '/health', method: 'GET' },
+    { path: '/v1/chat/completions', method: 'POST', body: {
+      model: 'test-model',
+      messages: [{ role: 'user', content: 'Hello, this is a test message for memory optimization.' }],
+      stream: false
+    }},
+  ];
+
+  const randomRequest = requests[Math.floor(Math.random() * requests.length)];
+  try {
+    await sendRequest(randomRequest.path, randomRequest.method, randomRequest.body);
+  } catch (e) {
+    // 忽略请求错误，重点是测试内存
+  }
+}
+
+/**
+ * 启动服务器进程
+ */
+function startServer() {
+  return new Promise((resolve, reject) => {
+    console.log('🚀 启动服务器...');
+    
+    const serverPath = path.join(__dirname, '..', 'src', 'server', 'index.js');
+    serverProcess = spawn('node', ['--expose-gc', serverPath], {
+      cwd: path.join(__dirname, '..'),
+      env: { ...process.env, PORT: PORT.toString() },
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    let started = false;
+    
+    serverProcess.stdout.on('data', (data) => {
+      const output = data.toString();
+      if (!started && (output.includes('listening') || output.includes('Server started') || output.includes('服务器'))) {
+        started = true;
+        setTimeout(resolve, 1000); // 等待服务器完全就绪
+      }
+    });
+
+    serverProcess.stderr.on('data', (data) => {
+      console.error('Server stderr:', data.toString());
+    });
+
+    serverProcess.on('error', reject);
+
+    // 超时处理
+    setTimeout(() => {
+      if (!started) {
+        started = true;
+        resolve(); // 即使没有检测到启动消息，也继续测试
+      }
+    }, 5000);
+  });
+}
+
+/**
+ * 停止服务器进程
+ */
+function stopServer() {
+  if (serverProcess) {
+    console.log('\n🛑 停止服务器...');
+    serverProcess.kill('SIGTERM');
+    serverProcess = null;
+  }
+}
+
+/**
+ * 采集内存样本
+ */
+async function collectMemorySample() {
+  const memoryInfo = await getServerMemory();
+  const elapsed = Date.now() - testStartTime;
+  
+  if (memoryInfo) {
+    memorySamples.push({
+      time: elapsed,
+      heapUsed: memoryInfo.heapUsed,
+      heapTotal: memoryInfo.heapTotal,
+      rss: memoryInfo.rss,
+      external: memoryInfo.external
+    });
+    
+    console.log(`📊 [${(elapsed/1000).toFixed(1)}s] Heap: ${formatMemory(memoryInfo.heapUsed)} / ${formatMemory(memoryInfo.heapTotal)}, RSS: ${formatMemory(memoryInfo.rss)}`);
+  } else {
+    // 如果没有内存端点，使用进程内存估算
+    const usage = process.memoryUsage();
+    console.log(`📊 [${(elapsed/1000).toFixed(1)}s] 测试进程内存 - Heap: ${formatMemory(usage.heapUsed)}, RSS: ${formatMemory(usage.rss)}`);
+  }
+}
+
+/**
+ * 分析内存数据
+ */
+function analyzeResults() {
+  if (memorySamples.length === 0) {
+    console.log('\n⚠️ 没有采集到内存数据（服务器可能没有 /v1/memory 端点）');
+    console.log('请手动检查服���器日志中的内存使用情况。');
+    return;
+  }
+
+  const heapValues = memorySamples.map(s => s.heapUsed);
+  const rssValues = memorySamples.map(s => s.rss);
+
+  const heapMin = Math.min(...heapValues);
+  const heapMax = Math.max(...heapValues);
+  const heapAvg = heapValues.reduce((a, b) => a + b, 0) / heapValues.length;
+
+  const rssMin = Math.min(...rssValues);
+  const rssMax = Math.max(...rssValues);
+  const rssAvg = rssValues.reduce((a, b) => a + b, 0) / rssValues.length;
+
+  console.log('\n📈 内存统计分析');
+  console.log('═'.repeat(50));
+  console.log(`采样数量: ${memorySamples.length}`);
+  console.log(`测试时长: ${((memorySamples[memorySamples.length-1]?.time || 0) / 1000).toFixed(1)} 秒`);
+  console.log('');
+  console.log('Heap 使用:');
+  console.log(`  最小: ${formatMemory(heapMin)}`);
+  console.log(`  最大: ${formatMemory(heapMax)}`);
+  console.log(`  平均: ${formatMemory(heapAvg)}`);
+  console.log('');
+  console.log('RSS (常驻内存):');
+  console.log(`  最小: ${formatMemory(rssMin)}`);
+  console.log(`  最大: ${formatMemory(rssMax)}`);
+  console.log(`  平均: ${formatMemory(rssAvg)}`);
+  console.log('');
+
+  // 评估是否达到目标
+  const TARGET_HEAP = 20 * 1024 * 1024; // 20MB
+  const TARGET_RSS = 50 * 1024 * 1024;  // 50MB (RSS 通常比 heap 大)
+
+  if (heapAvg <= TARGET_HEAP) {
+    console.log('✅ 堆内存使用达标！平均使用低于 20MB 目标。');
+  } else {
+    console.log(`⚠️ 堆内存使用未达标。平均 ${formatMemory(heapAvg)}，目标 20MB。`);
+  }
+
+  if (heapMax - heapMin < 10 * 1024 * 1024) {
+    console.log('✅ 内存波动稳定！波动范围小于 10MB。');
+  } else {
+    console.log(`⚠️ 内存波动较大。范围: ${formatMemory(heapMax - heapMin)}`);
+  }
+}
+
+/**
+ * 主测试流程
+ */
+async function runTest() {
+  console.log('🧪 反重力服务内存优化测试');
+  console.log('═'.repeat(50));
+  console.log(`目标: 堆内存保持在 ~20MB`);
+  console.log(`测试时长: ${TEST_DURATION_MS / 1000} 秒`);
+  console.log(`采样间隔: ${SAMPLE_INTERVAL_MS / 1000} 秒`);
+  console.log('═'.repeat(50));
+  console.log('');
+
+  try {
+    await startServer();
+    console.log('✅ 服务器已启动\n');
+    
+    testStartTime = Date.now();
+    
+    // 设置采样定时器
+    const sampleInterval = setInterval(collectMemorySample, SAMPLE_INTERVAL_MS);
+    
+    // 设置负载模拟定时器
+    const loadInterval = setInterval(simulateLoad, REQUEST_INTERVAL_MS);
+    
+    // 等待测试完成
+    await new Promise(resolve => setTimeout(resolve, TEST_DURATION_MS));
+    
+    // 清理定时器
+    clearInterval(sampleInterval);
+    clearInterval(loadInterval);
+    
+    // 最后采集一次
+    await collectMemorySample();
+    
+    // 分析结果
+    analyzeResults();
+    
+  } catch (error) {
+    console.error('❌ 测试失败:', error.message);
+  } finally {
+    stopServer();
+    process.exit(0);
+  }
+}
+
+// 处理进程退出
+process.on('SIGINT', () => {
+  console.log('\n收到中断信号...');
+  stopServer();
+  process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+  stopServer();
+  process.exit(0);
+});
+
+// 运行测试
+runTest();