Upload 9 files

.env.example

@@ -3,15 +3,15 @@
 # ============================================
 
 # 管理员密钥（必需，用于登录管理面板）
+# 明文示例：
 ADMIN_KEY=your-admin-secret-key
+# Hash 示例（SHA256）：ADMIN_KEY=sha256:你的32字节hex
 
 # API密钥（可选，用于API端点认证，优先级：环境变量 > settings.yaml）
 # API_KEY=your-api-key
 
-# 路径前缀（可选，用于隐藏端点路径，提高安全性）
-# 如果设置了，端点将为: /{PATH_PREFIX}/, /{PATH_PREFIX}/v1/
-# 如果未设置，端点将为: /, /v1/
-# PATH_PREFIX=your-random-path-prefix
+# 服务端口（可选，默认 7860）
+# PORT=7860
 
 # ============================================
 # 其他配置请在管理面板的"系统设置"中配置

.gitignore

@@ -35,12 +35,9 @@ ENV/
 # Project specific
 .env
 *.log
-data/stats.json
-data/settings.yaml
-accounts.json
 
 # Generated files
-data/images/
+data/
 logs/
 
 # OS

Dockerfile

@@ -1,5 +1,16 @@
+# 多阶段构建：前端构建
+FROM node:20-alpine AS frontend-builder
+WORKDIR /frontend
+COPY frontend/package*.json ./
+RUN npm ci
+COPY frontend/ ./
+RUN npm run build
+
+# 后端运行环境
 FROM python:3.11-slim
 WORKDIR /app
+
+# 安装 Python 依赖
 COPY requirements.txt .
 RUN apt-get update && apt-get install -y --no-install-recommends \
     gcc \
@@ -7,17 +18,20 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     && apt-get purge -y gcc \
     && apt-get autoremove -y \
     && rm -rf /var/lib/apt/lists/*
+
+# 复制后端代码
 COPY main.py .
-# 复制 core 模块
 COPY core ./core
-# 复制 util 目录
 COPY util ./util
-# 复制 templates 目录
-COPY templates ./templates
-# 复制 static 目录
-COPY static ./static
-# 创建数据目录
-RUN mkdir -p ./data/images
-# 声明数据卷（运行时需要 -v 挂载才能持久化）
+
+# 复制前端构建产物
+COPY --from=frontend-builder /frontend/dist ./static
+
+# 创建数据目录（支持本地和 HF Spaces Pro）
+RUN mkdir -p ./data
+
+# 声明数据卷
 VOLUME ["/app/data"]
+
+# 启动服务
 CMD ["python", "-u", "main.py"]

README.md

@@ -1,729 +1,125 @@
----
-title: Gemini Business2API
-emoji: 💎
-colorFrom: pink
-colorTo: blue
-sdk: docker
-pinned: false
-license: mit
----
+<p align="center">
+  <img src="docs/logo.svg" width="120" alt="Gemini Business2API logo" />
+</p>
+<h1 align="center">Gemini Business2API</h1>
+<p align="center">赋予硅基生物以灵魂</p>
+<p align="center">当时明月在 · 曾照彩云归</p>
+<p align="center">
+  <strong>简体中文</strong> | <a href="docs/README_EN.md">English</a>
+</p>
+<p align="center"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" /> <img src="https://img.shields.io/badge/Python-3.11+-3776AB?logo=python&logoColor=white" /> <img src="https://img.shields.io/badge/FastAPI-0.110-009688?logo=fastapi&logoColor=white" /> <img src="https://img.shields.io/badge/Vue-3-4FC08D?logo=vue.js&logoColor=white" /> <img src="https://img.shields.io/badge/Vite-7-646CFF?logo=vite&logoColor=white" /> <img src="https://img.shields.io/badge/Docker-ready-2496ED?logo=docker&logoColor=white" /></p>
+
+<p align="center">将 Gemini Business 转换为 OpenAI 兼容接口，支持多账号负载均衡、图像生成、多模态能力与内置管理面板。</p>
 
-#  Gemini Business2API
+---
 
-将 Google Gemini Business API 转换为 OpenAI 兼容接口，支持多账户负载均衡。
-感谢Claude老师！
+## 📜 开源协议与声明
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
+**开源协议**: MIT License - 查看 [LICENSE](LICENSE) 文件了解详情
 
-**快速部署到 HuggingFace Spaces:**
+**使用声明**:
+- ⚠️ **本项目仅限学习与研究用途，禁止用于商业用途**
+- 📝 **使用时请保留本声明、原作者信息与开源来源**
+- 🔗 **项目地址**: [github.com/Dreamy-rain/gemini-business2api](https://github.com/Dreamy-rain/gemini-business2api)
 
-[![Deploy to Spaces](https://huggingface.co/datasets/huggingface/badges/resolve/main/deploy-to-spaces-md.svg)](https://huggingface.co/spaces/xiaoyukkkk/gemini-business2api?duplicate=true)
+---
 
 ## ✨ 功能特性
 
-### 核心功能
-- ✅ **OpenAI API 完全兼容** - 无缝对接现有工具
-- ✅ **流式响应支持** - 实时输出
-- ✅ **多模态支持** - 支持 100+ 种文件类型（图片、PDF、Office 文档、音频、视频、代码等）
-- ✅ **图片生成 & 图生图** - 支持 `gemini-3-pro-preview` 模型
-- ✅ **智能文件处理** - 自动识别文件类型，支持 URL 和 Base64 格式
-
-### 多账户管理
-- ✅ **多账户负载均衡** - 支持多账户轮询，故障自动转移
-- ✅ **智能熔断机制** - 账户连续失败自动熔断，429限流10分钟后自动恢复
-- ✅ **三层重试策略** - 新会话重试、请求重试、账户切换
-- ✅ **智能会话复用** - 自动管理对话历史，缓存过期自动清理
-- ✅ **在线配置管理** - Web界面编辑账户配置，实时生效
-- ✅ **账户过期自动禁用** - 设置过期时间，过期后自动禁用不可选用
-- ✅ **手动禁用/启用** - 管理面板一键禁用/启用账户
-- ✅ **错误永久禁用** - 普通错误触发熔断后永久禁用，需手动启用恢复
-
-### 系统功能
-- ✅ **JWT自动管理** - 无需手动刷新令牌
-- 📊 **可视化管理面板** - 实时监控账户状态、过期时间、失败计数、累计对话次数
-- 📈 **账户使用统计** - 自动统计每个账户累计对话次数，持久化保存
-- 📝 **公开日志系统** - 实时查看服务运行状态（内存最多3000条，自动淘汰）
-- 🔐 **双重认证保护** - API_KEY 保护聊天接口，ADMIN_KEY 保护管理面板
-- 📡 **实时状态监控** - 公开统计接口，实时查看服务状态和请求统计
-
-### 性能优化
-- ⚡ **异步文件 I/O** - 避免阻塞事件循环，提升并发性能
-- ⚡ **HTTP 连接池优化** - 提升高并发场景下的稳定性
-- ⚡ **图片并行下载** - 多图场景下显著提升响应速度
-- ⚡ **智能锁优化** - 减少锁竞争，提升账户选择效率
-- ⚡ **会话并发控制** - Session 级别锁，避免对话冲突
-
-## 📸 功能展示
-
-### 图片生成效果
-
-<table>
-  <tr>
-    <td><img src="https://github.com/user-attachments/assets/d6837897-63f2-4a17-ba4a-f59030e37018" alt="图片生成示例1" width="800"/></td>
-    <td><img src="https://github.com/user-attachments/assets/dc597631-b00b-4307-bba1-c0ed21db0e1b" alt="图片生成示例2" width="800"/></td>
-  </tr>
-  <tr>
-    <td><img src="https://github.com/user-attachments/assets/4e3a1ffa-dea9-4207-ac9b-bb32f8e83c6f" alt="图片生成示例3" width="800"/></td>
-    <td><img src="https://github.com/user-attachments/assets/53a30edd-c2ec-4cd3-a0bd-ccf68884472a" alt="图片生成示例4" width="800"/></td>
-  </tr>
-</table>
-
-### 管理面板
-
-<table>
-  <tr>
-    <td><img src="https://github.com/user-attachments/assets/d0548b2b-b57e-4857-8ed0-b48b4daef34f" alt="管理面板1" width="800"/></td>
-    <td><img src="https://github.com/user-attachments/assets/6b2aff95-e48f-412f-9e6e-2e893595b6dd" alt="管理面板2" width="800"/></td>
-  </tr>
-</table>
-
-### 日志系统
-
-<table>
-  <tr>
-    <td><img src="https://github.com/user-attachments/assets/4c9c38c4-6322-4057-b5f0-a10f8b82b6ae" alt="日志系统1" width="800"/></td>
-    <td><img src="https://github.com/user-attachments/assets/095b86d7-3924-4258-954a-85bda9e8478e" alt="日志系统2" width="800"/></td>
-  </tr>
-</table>
+- ✅ OpenAI API 完全兼容 - 无缝对接现有工具
+- ✅ 多账号负载均衡 - 轮询与故障自动切换
+- ✅ 流式输出 - 实时响应
+- ✅ 多模态输入 - 100+ 文件类型（图片、PDF、Office 文档、音频、视频、代码等）
+- ✅ 图片生成 & 图生图 - 模型可配置，Base64 或 URL 返回
+- ✅ 智能文件处理 - 自动识别文件类型，支持 URL 与 Base64
+- ✅ 日志与监控 - 实时状态与统计信息
+- ✅ 代理支持 - 通过 PROXY 配置
+- ✅ 内置管理面板 - 在线配置与账号管理
+
+## 🤖 模型功能
+
+| 模型ID                   | 识图 | 香蕉绘图 | 原生联网 | 文件多模态 |
+| ------------------------ | ---- | -------- | -------- | ---------- |
+| `gemini-auto`            | ✅    | 可选     | ✅        | ✅          |
+| `gemini-2.5-flash`       | ✅    | 可选     | ✅        | ✅          |
+| `gemini-2.5-pro`         | ✅    | 可选     | ✅        | ✅          |
+| `gemini-3-flash-preview` | ✅    | 可选     | ✅        | ✅          |
+| `gemini-3-pro-preview`   | ✅    | 可选     | ✅        | ✅          |
 
 ## 🚀 快速开始
 
-### 方法一: HuggingFace Spaces 部署（推荐）
-
-1. Fork 本项目到你的 GitHub 账户
-2. 在 [HuggingFace Spaces](https://huggingface.co/spaces) 创建新 Space
-3. 选择 Docker SDK，关联你的 GitHub 仓库
-4. 配置环境变量（Settings → Variables and secrets）：
-   ```bash
-   ACCOUNTS_CONFIG='[{"secure_c_ses":"your_cookie","csesidx":"your_idx","config_id":"your_config"}]'
-   PATH_PREFIX=path_prefix
-   ADMIN_KEY=your_admin_key
-   API_KEY=your_api_key
-   LOGO_URL=https://your-domain.com/logo.png
-   CHAT_URL=https://your-chat-app.com
-   ```
-5. 等待构建完成（约 2-3 分钟）
-6. 访问你的 Space URL 开始使用
-
-### 方法二: Docker 部署
-
-```bash
-# 1. 克隆项目
-git clone https://github.com/YOUR_USERNAME/gemini-business2api.git
-cd gemini-business2api
-
-# 2. 构建并运行
-docker build -t gemini-business2api .
-docker run -d \
-  -p 7860:7860 \
-  -e ACCOUNTS_CONFIG='[{"secure_c_ses":"your_cookie","csesidx":"your_idx","config_id":"your_config"}]' \
-  -e PATH_PREFIX=path_prefix \
-  -e ADMIN_KEY=your_admin_key \
-  -e API_KEY=your_api_key \
-  -e LOGO_URL=https://your-domain.com/logo.png \
-  -e CHAT_URL=https://your-chat-app.com \
-  gemini-business2api
-```
-
-### 方法三: 本地运行
+### 方式一：本地运行（推荐）
 
 ```bash
-# 1. 安装依赖
 pip install -r requirements.txt
-
-# 2. 配置环境变量
 cp .env.example .env
-# 编辑 .env 文件，填入实际配置
-
-# 3. 启动服务
+# 编辑 .env 设置 ADMIN_KEY
 python main.py
 ```
 
-服务将在 `http://localhost:7860` 启动
-
-## ⚙️ 配置说明
-
-### 必需的环境变量
-
-```bash
-# 账户配置（必需）
-ACCOUNTS_CONFIG='[{"secure_c_ses":"your_cookie","csesidx":"your_idx","config_id":"your_config"}]'
-
-# 路径前缀（必需）
-PATH_PREFIX=path_prefix
-
-# 管理员密钥（必需）
-ADMIN_KEY=your_admin_key
-
-# API访问密钥（可选，推荐设置）
-API_KEY=your_api_key
-
-# 图片URL生成（可选，推荐设置）
-BASE_URL=https://your-domain.com
-
-# 全局代理（可选）
-PROXY=http://127.0.0.1:7890
-
-# 公开展示配置（可选）
-LOGO_URL=https://your-domain.com/logo.png
-CHAT_URL=https://your-chat-app.com
-MODEL_NAME=gemini-business
-
-# 重试配置（可选）
-MAX_NEW_SESSION_TRIES=5        # 新会话尝试账户数（默认5）
-MAX_REQUEST_RETRIES=3          # 请求失败重试次数（默认3）
-MAX_ACCOUNT_SWITCH_TRIES=5     # 每次重试查找账户次数（默认5）
-ACCOUNT_FAILURE_THRESHOLD=3    # 账户失败阈值，达到后熔断（默认3）
-RATE_LIMIT_COOLDOWN_SECONDS=600 # 429限流冷却时间，秒（默认600=10分钟）
-SESSION_CACHE_TTL_SECONDS=3600 # 会话缓存过期时间，秒（默认3600=1小时）
-```
-
-### 重试机制说明
-
-系统提供三层重试保护：
-
-1. **新会话创建重试**：创建新对话时，如果账户失败，自动切换到其他账户（最多尝试5个）
-2. **请求失败重试**：对话过程中出错，自动重试并切换账户（最多重试3次）
-3. **智能熔断机制**：
-   - 账户连续失败3次 → 自动标记为不可用
-   - **429限流错误**：冷却10分钟后自动��复
-   - **普通错误**：永久禁用，需手动启用
-   - JWT失败和请求失败都会触发熔断
-```
-
-### 多账户配置示例
-
-```bash
-ACCOUNTS_CONFIG='[
-  {
-    "id": "account_1",
-    "secure_c_ses": "CSE.Ad...",
-    "csesidx": "498...",
-    "config_id": "0cd...",
-    "host_c_oses": "COS.Af...",
-    "expires_at": "2025-12-23 23:03:20"
-  },
-  {
-    "id": "account_2",
-    "secure_c_ses": "CSE.Ad...",
-    "csesidx": "208...",
-    "config_id": "782..."
-  }
-]'
-```
-
-**配置字段说明**:
-- `secure_c_ses` (必需): `__Secure-C_SES` Cookie 值
-- `csesidx` (必需): 会话索引
-- `config_id` (必需): 配置 ID
-- `id` (可选): 账户标识
-- `host_c_oses` (可选): `__Host-C_OSES` Cookie 值
-- `expires_at` (可选): 过期时间，格式 `YYYY-MM-DD HH:MM:SS`
-
-**提示**: 参考项目根目录的 `.env.example` 和 `accounts_config.example.json` 文件
-
-## 🔧 获取配置参数
-
-1. 访问 [Google Gemini Business](https://business.gemini.google)
-2. 打开浏览器开发者工具 (F12)
-3. 切换到 **Application** → **Cookies**，找到:
-   - `__Secure-C_SES` → `secure_c_ses`
-   - `__Host-C_OSES` → `host_c_oses` (可选)
-4. 切换到 **Network** 标签，刷新页面
-5. 找到 `streamGenerate` 请求，查看 Payload:
-   - `csesidx` → `csesidx`
-   - `configId` → `config_id`
-
-## 📖 API 使用
-
-### 支持的模型
-
-| 模型名称                 | 说明                   | 图片生成 |
-| ------------------------ | ---------------------- | -------- |
-| `gemini-auto`            | 自动选择最佳模型(默认) | ❌        |
-| `gemini-2.5-flash`       | Flash 2.5 - 快速响应   | ❌        |
-| `gemini-2.5-pro`         | Pro 2.5 - 高质量输出   | ❌        |
-| `gemini-3-flash-preview` | Flash 3 预览版         | ❌        |
-| `gemini-3-pro-preview`   | Pro 3 预览版           | ✅        |
-
-### 访问端点
-
-| 端点                                     | 方法   | 说明                        |
-| ---------------------------------------- | ------ | --------------------------- |
-| `/{PATH_PREFIX}/v1/models`               | GET    | 获取模型列表                |
-| `/{PATH_PREFIX}/v1/chat/completions`     | POST   | 聊天接口（需API_KEY）       |
-| `/{PATH_PREFIX}`                   | GET    | 管理面板（需ADMIN_KEY）     |
-| `/{PATH_PREFIX}/accounts`          | GET    | 获取账户状态（需ADMIN_KEY） |
-| `/{PATH_PREFIX}/accounts-config`   | GET    | 获取账户配置（需ADMIN_KEY） |
-| `/{PATH_PREFIX}/accounts-config`   | PUT    | 更新账户配置（需ADMIN_KEY） |
-| `/{PATH_PREFIX}/accounts/{id}`     | DELETE | 删除指定账户（需ADMIN_KEY） |
-| `/{PATH_PREFIX}/accounts/{id}/disable` | PUT | 禁用指定账户（需ADMIN_KEY） |
-| `/{PATH_PREFIX}/accounts/{id}/enable`  | PUT | 启用指定账户（需ADMIN_KEY） |
-| `/{PATH_PREFIX}/log`               | GET    | 获取系统日志（需ADMIN_KEY） |
-| `/{PATH_PREFIX}/log`               | DELETE | 清空系统日志（需ADMIN_KEY） |
-| `/public/log/html`                       | GET    | 公开日志页面（无需认证）    |
-| `/public/stats`                          | GET    | 公开统计信息（无需认证）    |
-| `/public/stats/html`                     | GET    | 实时状态监控页面（无需认证）|
-
-**访问示例**：
-
-假设你的配置为：
-- Space URL: `https://your-space.hf.space`
-- PATH_PREFIX: `my_prefix`
-- ADMIN_KEY: `my_admin_key`
-
-则访问地址为：
-- **管理面板**: `https://your-space.hf.space/my_prefix?key=my_admin_key`
-- **公开日志**: `https://your-space.hf.space/public/log/html`
-- **API 端点**: `https://your-space.hf.space/my_prefix/v1/chat/completions`
-
-### 基本对话
-
-```bash
-curl -X POST http://localhost:7860/v1/v1/chat/completions \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer your_api_key" \
-  -d '{
-    "model": "gemini-2.5-flash",
-    "messages": [
-      {"role": "user", "content": "Hello!"}
-    ],
-    "stream": true
-  }'
-```
-
-### 多模态输入（支持 100+ 种文件类型）
-
-本项目支持图片、PDF、Office 文档、音频、视频、代码等 100+ 种文件类型。详细列表请查看 [支持的文件类型清单](docs/SUPPORTED_FILE_TYPES.md)。
-
-#### 图片输入
-
-```bash
-# Base64 格式
-curl -X POST http://localhost:7860/v1/v1/chat/completions \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer your_api_key" \
-  -d '{
-    "model": "gemini-2.5-pro",
-    "messages": [
-      {
-        "role": "user",
-        "content": [
-          {"type": "text", "text": "这张图片里有什么?"},
-          {"type": "image_url", "image_url": {"url": "data:image/jpeg;base64,<base64_encoded_image>"}}
-        ]
-      }
-    ]
-  }'
-
-# URL 格式（自动下载并转换）
-curl -X POST http://localhost:7860/v1/v1/chat/completions \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer your_api_key" \
-  -d '{
-    "model": "gemini-2.5-pro",
-    "messages": [
-      {
-        "role": "user",
-        "content": [
-          {"type": "text", "text": "分析这张图片"},
-          {"type": "image_url", "image_url": {"url": "https://example.com/image.jpg"}}
-        ]
-      }
-    ]
-  }'
-```
-
-#### PDF 文档
-
-```bash
-curl -X POST http://localhost:7860/v1/v1/chat/completions \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer your_api_key" \
-  -d '{
-    "model": "gemini-2.5-pro",
-    "messages": [
-      {
-        "role": "user",
-        "content": [
-          {"type": "text", "text": "总结这个PDF的内容"},
-          {"type": "image_url", "image_url": {"url": "https://example.com/document.pdf"}}
-        ]
-      }
-    ]
-  }'
-```
-
-#### Office 文档（Word、Excel、PowerPoint）
-
-```bash
-# Word 文档
-curl -X POST http://localhost:7860/v1/v1/chat/completions \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer your_api_key" \
-  -d '{
-    "model": "gemini-2.5-pro",
-    "messages": [
-      {
-        "role": "user",
-        "content": [
-          {"type": "text", "text": "总结这个Word文档"},
-          {"type": "image_url", "image_url": {"url": "https://example.com/document.docx"}}
-        ]
-      }
-    ]
-  }'
-
-# Excel 表格
-curl -X POST http://localhost:7860/v1/v1/chat/completions \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer your_api_key" \
-  -d '{
-    "model": "gemini-2.5-pro",
-    "messages": [
-      {
-        "role": "user",
-        "content": [
-          {"type": "text", "text": "分析这个Excel数据"},
-          {"type": "image_url", "image_url": {"url": "https://example.com/data.xlsx"}}
-        ]
-      }
-    ]
-  }'
-```
-
-#### 音频文件（语音转录）
-
-```bash
-curl -X POST http://localhost:7860/v1/v1/chat/completions \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer your_api_key" \
-  -d '{
-    "model": "gemini-2.5-pro",
-    "messages": [
-      {
-        "role": "user",
-        "content": [
-          {"type": "text", "text": "转录这段音频"},
-          {"type": "image_url", "image_url": {"url": "https://example.com/audio.mp3"}}
-        ]
-      }
-    ]
-  }'
-```
-
-#### 视频文件（场景分析）
-
-```bash
-curl -X POST http://localhost:7860/v1/v1/chat/completions \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer your_api_key" \
-  -d '{
-    "model": "gemini-2.5-pro",
-    "messages": [
-      {
-        "role": "user",
-        "content": [
-          {"type": "text", "text": "描述这个视频的内容"},
-          {"type": "image_url", "image_url": {"url": "https://example.com/video.mp4"}}
-        ]
-      }
-    ]
-  }'
-```
-
-**支持的文件类型**（12 个分类，100+ 种格式）：
-
-- 🖼️ **图片文件** - 11 种格式（PNG, JPEG, WebP, GIF, BMP, TIFF, SVG, ICO, HEIC, HEIF, AVIF）
-- 📄 **文档文件** - 9 种格式（PDF, TXT, Markdown, HTML, XML, CSV, TSV, RTF, LaTeX）
-- 📊 **Microsoft Office** - 6 种格式（.docx, .doc, .xlsx, .xls, .pptx, .ppt）
-- 📝 **Google Workspace** - 3 种格式（Docs, Sheets, Slides）
-- 💻 **代码文件** - 19 种语言（Python, JavaScript, TypeScript, Java, C/C++, Go, Rust, PHP, Ruby, Swift, Kotlin, Scala, Shell, PowerShell, SQL, R, MATLAB 等）
-- 🎨 **Web 开发** - 8 种格式（CSS, SCSS, LESS, JSON, YAML, TOML, Vue, Svelte）
-- 🎵 **音频文件** - 10 种格式（MP3, WAV, AAC, M4A, OGG, FLAC, AIFF, WMA, OPUS, AMR）
-- 🎬 **视频文件** - 10 种格式（MP4, MOV, AVI, MPEG, WebM, FLV, WMV, MKV, 3GPP, M4V）
-- 📦 **数据文件** - 6 种格式（JSON, JSONL, CSV, TSV, Parquet, Avro）
-- 🗜️ **压缩文件** - 5 种格式（ZIP, RAR, 7Z, TAR, GZ）
-- 🔧 **配置文件** - 5 种格式（YAML, TOML, INI, ENV, Properties）
-- 📚 **电子书** - 2 种格式（EPUB, MOBI）
-
-完整列表和使用示例请查看 [支持的文件类型清单](docs/SUPPORTED_FILE_TYPES.md)
-
-### 图片生成
-
-```bash
-curl -X POST http://localhost:7860/v1/v1/chat/completions \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer your_api_key" \
-  -d '{
-    "model": "gemini-3-pro-preview",
-    "messages": [
-      {"role": "user", "content": "画一只可爱的猫咪"}
-    ]
-  }'
-```
-
-### 图生图（Image-to-Image）
+### 方式二：Docker
 
 ```bash
-curl -X POST http://localhost:7860/v1/v1/chat/completions \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer your_api_key" \
-  -d '{
-    "model": "gemini-3-pro-preview",
-    "messages": [
-      {
-        "role": "user",
-        "content": [
-          {"type": "text", "text": "将这张图片改成水彩画风格"},
-          {"type": "image_url", "image_url": {"url": "data:image/jpeg;base64,<base64_encoded_image>"}}
-        ]
-      }
-    ]
-  }'
-```
-
-## ❓ 常见问题
-
-### 1. 如何在线编辑账户配置？
-
-访问管理面板 `/{PATH_PREFIX}?key=YOUR_ADMIN_KEY`，点击"编辑配置"按钮：
-- ✅ 实时编辑 JSON 格式配置
-- ✅ 保存后立即生效，无需重启
-- ✅ 配置保存到 `accounts.json` 文件
-- ⚠️ 重启后从环境变量 `ACCOUNTS_CONFIG` 重新加载
-
-**建议**：在线修改后，同步更新环境变量 `ACCOUNTS_CONFIG`，避免重启后配置丢失。
-
-### 2. 账户熔断后如何恢复？
-
-账户连续失败3次后会自动熔断（标记为不可用）：
-- ⏰ **429限流错误**：冷却10分钟后自动恢复（可通过 `RATE_LIMIT_COOLDOWN_SECONDS` 配置）
-- 🔄 **普通错误**：永久禁用，需在管理面板手动点击"启用"按钮恢复
-- ✅ **成功后**：失败计数重置为0，账户恢复正常
-
-可在管理面板实时查看账户状态和失败计数。
-
-### 3. 账户禁用功能有哪些？
-
-管理面板提供完整的账户禁用管理功能，不同禁用状态有不同的恢复方式：
-
-#### 📋 **账户状态说明**
-
-| 状态 | 显示 | 颜色 | 自动恢复 | 恢复方式 | 倒计时 |
-|------|------|------|---------|---------|--------|
-| **正常** | 正常/即将过期 | 绿色/橙色 | - | - | ❌ |
-| **过期禁用** | 过期禁用 | 灰色 | ❌ | 修改过期时间 | ❌ |
-| **手动禁用** | 手动禁用 | 灰色 | ❌ | 点击"启用"按钮 | ❌ |
-| **错误禁用** | 错误禁用 | 红色 | ❌ | 点击"启用"按钮 | ❌ |
-| **429限流** | 429限流 | 橙色 | ✅ 10分钟 | 自动恢复或点击"启用" | ✅ |
-
-#### ⚙️ **功能说明**
-
-1. **账户过期自动禁用**
-   - 在账户配置中设置 `expires_at` 字段（格式：`YYYY-MM-DD HH:MM:SS`）
-   - 过期后账户自动禁用，不参与轮询选择
-   - 页面显示灰色半透明卡片，仅保留"删除"按钮
-   - 需要修改过期时间才能重新启用
-
-2. **手动禁用/启用**
-   - 管理面板每个账户卡片都有"禁用"按钮
-   - 点击后立即禁用，不参与轮询选择
-   - 显示灰色半透明卡片，提供"启用"+"删除"按钮
-   - 点击"启用"按钮即可恢复
-
-3. **错误自动禁用（永久）**
-   - 账户连续失败3次触发（非429错误）
-   - 自动标记为不可用，永久禁用
-   - 显示红色半透明卡片，提供"启用"+"删除"按钮
-   - 需要手动点击"启用"按钮恢复
-
-4. **429限流自动禁用（临时）**
-   - 账户连续遇到429错误3次触发
-   - 自动冷却10分钟（可配置 `RATE_LIMIT_COOLDOWN_SECONDS`）
-   - 显示橙色卡片，带倒计时显示（如：`567秒 (429限流)`）
-   - 冷却期过后自动恢复，或手动点击"启用"立即恢复
-
-#### 💡 **使用建议**
-
-- **临时维护**：使用"手动禁用"功能暂时停用账户
-- **账户轮换**：设置过期时间，到期自动禁用
-- **故障排查**：错误禁用的账户需检查后再手动启用
-- **429限流**：耐心等待10分钟自动恢复，或检查请求频率
-
-### 4. 账户对话次数统计如何工作？
-
-系统自动统计每个账户的累计对话次数，无需手动操作。
-
-#### 📊 **统计说明**
-
-- **自动计数**：每次聊天请求成功后自动 +1
-- **持久化保存**：保存到 `data/stats.json` 文件，重启不丢失
-- **实时显示**：管理面板账户卡片实时显示累计次数
-- **数据位置**：`data/stats.json` → `account_conversations` 字段
-
-#### 📈 **显示位置**
-
-管理面板账户卡片中，"剩余时长"行下方：
-```
-过期时间: 2025-12-31 23:59:59
-剩余时长: 72.5 小时
-累计对话: 123 次  ← 蓝色加粗显示
-```
-
-#### 💡 **数据说明**
-
-- 统计范围：仅统计成功的对话请求
-- 失败请求：不计入累计次数
-- 数据格式：`{"account_id": conversation_count}`
-- 重置方式：目前需要手动编辑 `data/stats.json` 文件
-
-### 5. 图片生成后在哪里找到文件?
-
-- **临时存储**: 图片保存在 `./data/images/`，可通过 URL 访问
-- **重启后会丢失**，建议使用持久化存储
-
-### 6. 如何设置 BASE_URL?
-
-**自动检测**(推荐):
-- 不设置 `BASE_URL` 环境变量
-- 系统自动从请求头检测域名
-
-**手动设置**:
-```bash
-BASE_URL=https://your-domain.com
-```
-
-**使用反向代理**:
-
-如果你使用自己的域名反向代理到 HuggingFace Space，可以通过以下方式配置：
-
-**Nginx 配置示例**:
-```nginx
-location / {
-    proxy_pass https://your-username-space-name.hf.space;
-    proxy_set_header Host your-username-space-name.hf.space;
-    proxy_ssl_server_name on;
-}
-```
-
-**Deno Deploy 配置示例**:
-```typescript
-async function handler(request: Request): Promise<Response> {
-  const url = new URL(request.url);
-  url.host = 'your-username-space-name.hf.space';
-  return fetch(new Request(url, request));
-}
-
-Deno.serve(handler);
+docker build -t gemini-business2api .
+docker run -d -p 7860:7860 \
+  -e ADMIN_KEY=your_admin_key \
+  gemini-business2api
 ```
 
-配置反向代理后，将 `BASE_URL` 设置为你的自定义域名即可。
-
-### 7. API_KEY 和 ADMIN_KEY 的区别?
+### 访问方式
 
-- **API_KEY**: 保护聊天接口 (`/v1/chat/completions`)
-- **ADMIN_KEY**: 保护管理面板 (`/` 或 `/{PATH_PREFIX}`)
+- 管理面板：`http://localhost:7860/`（使用 `ADMIN_KEY` 登录）
+- OpenAI 兼容接口：`http://localhost:7860/v1/chat/completions`
 
-可以设置相同的值，也可以分开
+### 配置提示
 
-### 8. 如何查看日志?
+- 账号配置优先读取 `ACCOUNTS_CONFIG`，也可在管理面板中录入并保存至 `data/accounts.json`。
+- 如需鉴权，可设置 `API_KEY` 保护 `/v1/chat/completions`。
 
-- **公开日志**: 访问 `/public/log/html` (无需密钥)
-- **管理面板**: 访问 `/?key=YOUR_ADMIN_KEY` 或 `/{PATH_PREFIX}?key=YOUR_ADMIN_KEY`
+### 更多文档
 
-日志系统说明：
-- 内存存储最多 3000 条日志
-- 超过上限自动删除最旧的日志
-- 重启后清空（内存存储）
-- 可通过 API 手动清空日志
+- 支持的文件类型：`docs/SUPPORTED_FILE_TYPES.md`
 
-## 🔧 油猴脚本使用说明
-
-本项目提供油猴脚本辅助获取配置参数，使用前需要配置 TamperMonkey：
-
-### TamperMonkey 设置
-
-1. **配置模式**：改为 `高级`
-2. **安全设置**：允许脚本访问 Cookie 改为 `All`
-
-### Google Chrome 额外设置
-
-1. 打开油猴扩展设置
-2. 启用 **允许运行用户脚本**
-3. 设置 **有权访问的网站** 权限
-
-配置完成后即可使用脚本自动获取 `secure_c_ses`、`csesidx`、`config_id` 等参数。
-
----
-
-## 📁 项目结构
-
-```
-gemini-business2api/
-├── main.py                        # 主程序入口
-├── core/                          # 核心模块
-│   ├── __init__.py
-│   ├── auth.py                    # 认证装饰器
-│   └── templates.py               # HTML模板生成
-├── util/                          # 工具模块
-│   └── streaming_parser.py       # 流式JSON解析器
-├── docs/                         # 文档目录
-│   └── SUPPORTED_FILE_TYPES.md   # 支持的文件类型清单
-├── data/                         # 运行时数据目录
-│   ├── stats.json                # 统计数据（gitignore）
-│   └── images/                   # 生成的图片（gitignore）
-├── script/                       # 辅助脚本
-│   ├── copy-config.js            # 油猴脚本：复制配置到剪贴板
-│   └── download-config.js        # 油猴脚本：下载配置文件
-├── requirements.txt               # Python依赖
-├── Dockerfile                     # Docker构建文件
-├── README.md                      # 项目文档
-├── .env.example                   # 环境变量配置示例
-└── accounts_config.example.json   # 多账户配置示例
-```
-
-**运行时生成的文件和目录**:
-- `accounts.json` - 账户配置持久化文件（Web编辑后保存）
-- `data/stats.json` - 统计数据（访问量、请求数等）
-- `data/images/` - 生成的图片存储目录
-  - HF Pro: `/data/images`（持久化，重启不丢失）
-  - 其他环境: `./data/images`（临时存储，重启会丢失）
-
-**日志系统**:
-- 内存日志缓冲区：最多保存 3000 条日志
-- 自动淘汰机制：超过上限自动删除最旧的日志（FIFO）
-- 重启后清空：日志存储在内存中，重启后丢失
-- 内存占用：约 450KB - 750KB（非常小，不会爆炸）
-
-## 🛠️ 技术栈
+## 📸 功能展示
 
-- **Python 3.11+**
-- **FastAPI** - 现代Web框架
-- **Uvicorn** - ASGI服务器
-- **httpx** - HTTP客户端
-- **Docker** - 容器化部署
+### 管理系统
 
-## 📝 License
+<table>
+  <tr>
+    <td><img src="docs/1.png" alt="管理系统 1" /></td>
+    <td><img src="docs/2.png" alt="管理系统 2" /></td>
+  </tr>
+  <tr>
+    <td><img src="docs/3.png" alt="管理系统 3" /></td>
+    <td><img src="docs/4.png" alt="管理系统 4" /></td>
+  </tr>
+  <tr>
+    <td><img src="docs/5.png" alt="管理系统 5" /></td>
+    <td><img src="docs/6.png" alt="管理系统 6" /></td>
+  </tr>
+</table>
 
-MIT License - 查看 [LICENSE](LICENSE) 文件了解详情
+### 图片效果
 
----
+<table>
+  <tr>
+    <td><img src="docs/img_1.png" alt="图片效果 1" /></td>
+    <td><img src="docs/img_2.png" alt="图片效果 2" /></td>
+  </tr>
+  <tr>
+    <td><img src="docs/img_3.png" alt="图片效果 3" /></td>
+    <td><img src="docs/img_4.png" alt="图片效果 4" /></td>
+  </tr>
+</table>
 
 ## 🙏 致谢
 
 * 源项目：[F佬 Linux.do 讨论](https://linux.do/t/topic/1225645)
 * 源项目：[heixxin/gemini](https://huggingface.co/spaces/heixxin/gemini/tree/main) | [Linux.do 讨论](https://linux.do/t/topic/1226413)
 * 绘图参考：[Gemini-Link-System](https://github.com/qxd-ljy/Gemini-Link-System) | [Linux.do 讨论](https://linux.do/t/topic/1234363)
-* Gemini Business 2API Helper 参考：[Linux.do 讨论](https://linux.do/t/topic/1231008)
-
----
 
 ## ⭐ Star History
 
 [![Star History Chart](https://api.star-history.com/svg?repos=Dreamy-rain/gemini-business2api&type=date&legend=top-left)](https://www.star-history.com/#Dreamy-rain/gemini-business2api&type=date&legend=top-left)
 
----
-
-**如果这个项目对你有帮助，请给个 ⭐ Star!**
+**如果这个项目对你有帮助，请给个 ⭐ Star!**

main.py

@@ -1,4 +1,4 @@
-import json, time, os, asyncio, uuid, ssl, re, yaml, shutil
+import json, time, os, asyncio, uuid, ssl, re, yaml, shutil, base64
 from datetime import datetime, timezone, timedelta
 from typing import List, Optional, Union, Dict, Any
 from pathlib import Path
@@ -8,7 +8,8 @@ from dotenv import load_dotenv
 import httpx
 import aiofiles
 from fastapi import FastAPI, HTTPException, Header, Request, Body, Form
-from fastapi.responses import StreamingResponse, HTMLResponse, JSONResponse, RedirectResponse
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse, JSONResponse, FileResponse
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
 from util.streaming_parser import parse_json_array_stream_async
@@ -69,9 +70,7 @@ from core.account import (
 from core import uptime as uptime_tracker
 
 # 导入配置管理和模板系统
-from fastapi.templating import Jinja2Templates
 from core.config import config_manager, config
-from util.template_helpers import prepare_admin_template_data
 
 # ---------- 日志配置 ----------
 
@@ -83,7 +82,7 @@ log_lock = Lock()
 stats_lock = asyncio.Lock()  # 改为异步锁
 
 async def load_stats():
-    """加载统计数据（异步）"""
+    """加载统计数据（异步）。"""
     try:
         if os.path.exists(STATS_FILE):
             async with aiofiles.open(STATS_FILE, 'r', encoding='utf-8') as f:
@@ -94,9 +93,13 @@ async def load_stats():
     return {
         "total_visitors": 0,
         "total_requests": 0,
-        "request_timestamps": [],  # 最近1小时的请求时间戳
-        "visitor_ips": {},  # {ip: timestamp} 记录访问IP和时间
-        "account_conversations": {}  # {account_id: conversation_count} 账户对话次数
+        "request_timestamps": [],
+        "model_request_timestamps": {},
+        "failure_timestamps": [],
+        "rate_limit_timestamps": [],
+        "visitor_ips": {},
+        "account_conversations": {},
+        "recent_conversations": []
     }
 
 async def save_stats(stats):
@@ -112,10 +115,85 @@ global_stats = {
     "total_visitors": 0,
     "total_requests": 0,
     "request_timestamps": [],
+    "model_request_timestamps": {},
+    "failure_timestamps": [],
+    "rate_limit_timestamps": [],
     "visitor_ips": {},
-    "account_conversations": {}
+    "account_conversations": {},
+    "recent_conversations": []
 }
 
+
+def get_beijing_time_str(ts: Optional[float] = None) -> str:
+    tz = timezone(timedelta(hours=8))
+    current = datetime.fromtimestamp(ts or time.time(), tz=tz)
+    return current.strftime("%Y-%m-%d %H:%M:%S")
+
+
+def build_recent_conversation_entry(
+    request_id: str,
+    model: Optional[str],
+    message_count: Optional[int],
+    start_ts: float,
+    status: str,
+    duration_s: Optional[float] = None,
+    error_detail: Optional[str] = None,
+) -> dict:
+    start_time = get_beijing_time_str(start_ts)
+    if model:
+        start_content = f"{model}"
+        if message_count:
+            start_content = f"{model} | {message_count}条消息"
+    else:
+        start_content = "请求处理中"
+
+    events = [{
+        "time": start_time,
+        "type": "start",
+        "content": start_content,
+    }]
+
+    end_time = get_beijing_time_str(start_ts + duration_s) if duration_s is not None else get_beijing_time_str()
+
+    if status == "success":
+        if duration_s is not None:
+            events.append({
+                "time": end_time,
+                "type": "complete",
+                "status": "success",
+            "content": f"响应完成 | 耗时{duration_s:.2f}s",
+            })
+        else:
+            events.append({
+                "time": end_time,
+                "type": "complete",
+                "status": "success",
+            "content": "响应完成",
+            })
+    elif status == "timeout":
+        events.append({
+            "time": end_time,
+            "type": "complete",
+            "status": "timeout",
+            "content": "请求超时",
+        })
+    else:
+        detail = error_detail or "请求失败"
+        events.append({
+            "time": end_time,
+            "type": "complete",
+            "status": "error",
+            "content": detail[:120],
+        })
+
+    return {
+        "request_id": request_id,
+        "start_time": start_time,
+        "start_ts": start_ts,
+        "status": status,
+        "events": events,
+    }
+
 class MemoryLogHandler(logging.Handler):
     """自定义日志处理器，将日志写入内存缓冲区"""
     def emit(self, record):
@@ -147,7 +225,6 @@ logger.addHandler(memory_handler)
 # 所有配置通过 config_manager 访问，优先级：环境变量 > YAML > 默认值
 TIMEOUT_SECONDS = 600
 API_KEY = config.basic.api_key
-PATH_PREFIX = config.security.path_prefix
 ADMIN_KEY = config.security.admin_key
 PROXY = config.basic.proxy
 BASE_URL = config.basic.base_url
@@ -204,6 +281,8 @@ def get_base_url(request: Request) -> str:
 
     return f"{forwarded_proto}://{forwarded_host}"
 
+
+
 # ---------- 常量定义 ----------
 USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36"
 
@@ -230,15 +309,9 @@ if not ADMIN_KEY:
     sys.exit(1)
 
 # 启动日志
-if PATH_PREFIX:
-    logger.info(f"[SYSTEM] 路径前缀已配置: {PATH_PREFIX[:4]}****")
-    logger.info(f"[SYSTEM] API端点: /{PATH_PREFIX}/v1/chat/completions")
-    logger.info(f"[SYSTEM] 管理端点: /{PATH_PREFIX}/")
-else:
-    logger.info("[SYSTEM] 未配置路径前缀，使用默认路径")
-    logger.info("[SYSTEM] API端点: /v1/chat/completions")
-    logger.info("[SYSTEM] 管理端点: /admin/")
-logger.info("[SYSTEM] 公开端点: /public/log/html, /public/stats, /public/uptime/html")
+logger.info("[SYSTEM] API端点: /v1/chat/completions")
+logger.info("[SYSTEM] Admin API endpoints: /admin/*")
+logger.info("[SYSTEM] Public endpoints: /public/log, /public/stats, /public/uptime")
 logger.info(f"[SYSTEM] Session过期时间: {SESSION_EXPIRE_HOURS}小时")
 logger.info("[SYSTEM] 系统初始化完成")
 
@@ -254,16 +327,44 @@ logger.info("[SYSTEM] 系统初始化完成")
 # ---------- OpenAI 兼容接口 ----------
 app = FastAPI(title="Gemini-Business OpenAI Gateway")
 
-# ---------- 模板系统配置 ----------
-templates = Jinja2Templates(directory="templates")
-
-# 开发模式：支持热更新
-if os.getenv("ENV") == "development":
-    templates.env.auto_reload = True
-    logger.info("[SYSTEM] 模板热更新已启用（开发模式）")
+frontend_origin = os.getenv("FRONTEND_ORIGIN", "").strip()
+allow_all_origins = os.getenv("ALLOW_ALL_ORIGINS", "0") == "1"
+if allow_all_origins and not frontend_origin:
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=False,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+elif frontend_origin:
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=[frontend_origin],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
 
-# 挂载静态文件
 app.mount("/static", StaticFiles(directory="static"), name="static")
+if os.path.exists(os.path.join("static", "assets")):
+    app.mount("/assets", StaticFiles(directory=os.path.join("static", "assets")), name="assets")
+if os.path.exists(os.path.join("static", "vendor")):
+    app.mount("/vendor", StaticFiles(directory=os.path.join("static", "vendor")), name="vendor")
+
+@app.get("/")
+async def serve_frontend_index():
+    index_path = os.path.join("static", "index.html")
+    if os.path.exists(index_path):
+        return FileResponse(index_path)
+    raise HTTPException(404, "Not Found")
+
+@app.get("/logo.svg")
+async def serve_logo():
+    logo_path = os.path.join("static", "logo.svg")
+    if os.path.exists(logo_path):
+        return FileResponse(logo_path)
+    raise HTTPException(404, "Not Found")
 
 # ---------- Session 中间件配置 ----------
 from starlette.middleware.sessions import SessionMiddleware
@@ -278,43 +379,30 @@ app.add_middleware(
 # ---------- Uptime 追踪中间件 ----------
 @app.middleware("http")
 async def track_uptime_middleware(request: Request, call_next):
-    """追踪每个请求的成功/失败状态，用于 Uptime 监控"""
-    # 只追踪 API 请求（排除静态文件、管理端点等）
+    """Uptime 监控：跟踪非对话接口的请求结果。"""
     path = request.url.path
-    if path.startswith("/images/") or path.startswith("/public/") or path.startswith("/favicon"):
+    if (
+        path.startswith("/images/")
+        or path.startswith("/public/")
+        or path.startswith("/favicon")
+        or path.endswith("/v1/chat/completions")
+    ):
         return await call_next(request)
 
     start_time = time.time()
-    success = False
-    model = None
 
     try:
         response = await call_next(request)
+        latency_ms = int((time.time() - start_time) * 1000)
         success = response.status_code < 400
-
-        # 尝试从请求中提取模型信息
-        if hasattr(request.state, "model"):
-            model = request.state.model
-
-        # 记录 API 主服务状态
-        uptime_tracker.record_request("api_service", success)
-
-        # 如果有模型信息，记录模型状态
-        if model and model in uptime_tracker.SUPPORTED_MODELS:
-            uptime_tracker.record_request(model, success)
-
+        uptime_tracker.record_request("api_service", success, latency_ms, response.status_code)
         return response
 
-    except Exception as e:
-        # 请求失败 - 尝试提取模型信息（可能在异常前已设置）
-        if hasattr(request.state, "model"):
-            model = request.state.model
-
+    except Exception:
         uptime_tracker.record_request("api_service", False)
-        if model and model in uptime_tracker.SUPPORTED_MODELS:
-            uptime_tracker.record_request(model, False)
         raise
 
+
 # ---------- 图片静态服务初始化 ----------
 os.makedirs(IMAGE_DIR, exist_ok=True)
 app.mount("/images", StaticFiles(directory=IMAGE_DIR), name="images")
@@ -340,16 +428,19 @@ async def startup_event():
 
     # 加载统计数据
     global_stats = await load_stats()
+    global_stats.setdefault("request_timestamps", [])
+    global_stats.setdefault("model_request_timestamps", {})
+    global_stats.setdefault("failure_timestamps", [])
+    global_stats.setdefault("rate_limit_timestamps", [])
+    global_stats.setdefault("recent_conversations", [])
+    uptime_tracker.configure_storage(os.path.join(DATA_DIR, "uptime.json"))
+    uptime_tracker.load_heartbeats()
     logger.info(f"[SYSTEM] 统计数据已加载: {global_stats['total_requests']} 次请求, {global_stats['total_visitors']} 位访客")
 
     # 启动缓存清理任务
     asyncio.create_task(multi_account_mgr.start_background_cleanup())
     logger.info("[SYSTEM] 后台缓存清理任务已启动（间隔: 5分钟）")
 
-    # 启动 Uptime 数据聚合任务
-    asyncio.create_task(uptime_tracker.uptime_aggregation_task())
-    logger.info("[SYSTEM] Uptime 数据聚合任务已启动（间隔: 240秒）")
-
 # ---------- 日志脱敏函数 ----------
 def get_sanitized_logs(limit: int = 100) -> list:
     """获取脱敏后的日志列表，按请求ID分组并提取关键事件"""
@@ -581,116 +672,129 @@ def create_chunk(id: str, created: int, model: str, delta: dict, finish_reason:
         "system_fingerprint": None  # OpenAI 标准字段（可选）
     }
     return json.dumps(chunk)
-
-# ---------- 辅助函数 ----------
-
-def get_admin_template_data(request: Request):
-    """获取管理页面模板数据（避免重复代码）"""
-    return prepare_admin_template_data(
-        request, multi_account_mgr, log_buffer, log_lock,
-        api_key=API_KEY, base_url=BASE_URL, proxy=PROXY,
-        logo_url=LOGO_URL, chat_url=CHAT_URL, path_prefix=PATH_PREFIX,
-        max_new_session_tries=MAX_NEW_SESSION_TRIES,
-        max_request_retries=MAX_REQUEST_RETRIES,
-        max_account_switch_tries=MAX_ACCOUNT_SWITCH_TRIES,
-        account_failure_threshold=ACCOUNT_FAILURE_THRESHOLD,
-        rate_limit_cooldown_seconds=RATE_LIMIT_COOLDOWN_SECONDS,
-        session_cache_ttl_seconds=SESSION_CACHE_TTL_SECONDS
-    )
-
-# ---------- 路由定义 ----------
-
-@app.get("/")
-async def home(request: Request):
-    """首页 - 根据PATH_PREFIX配置决定行为"""
-    if PATH_PREFIX:
-        # 如果设置了PATH_PREFIX（隐藏模式），首页返回404，不暴露任何信息
-        raise HTTPException(404, "Not Found")
-    else:
-        # 未设置PATH_PREFIX（公开模式），根据登录状态重定向
-        if is_logged_in(request):
-            template_data = get_admin_template_data(request)
-            return templates.TemplateResponse("admin/index.html", template_data)
-        else:
-            return RedirectResponse(url="/login", status_code=302)
-
-# ---------- 登录/登出端点（支持可选PATH_PREFIX） ----------
-
-# 不带PATH_PREFIX的登录端点
-@app.get("/login")
-async def admin_login_get(request: Request, error: str = None):
-    """登录页面"""
-    return templates.TemplateResponse("auth/login.html", {"request": request, "error": error})
+# ---------- Auth endpoints (API) ----------
 
 @app.post("/login")
 async def admin_login_post(request: Request, admin_key: str = Form(...)):
-    """处理登录表单提交"""
+    """Admin login (API)"""
     if admin_key == ADMIN_KEY:
         login_user(request)
-        logger.info(f"[AUTH] 管理员登录成功")
-        return RedirectResponse(url="/", status_code=302)
-    else:
-        logger.warning(f"[AUTH] 登录失败 - 密钥错误")
-        return templates.TemplateResponse("auth/login.html", {"request": request, "error": "密钥错误，请重试"})
+        logger.info("[AUTH] Admin login success")
+        return {"success": True}
+    logger.warning("[AUTH] Login failed - invalid key")
+    raise HTTPException(401, "Invalid key")
+
 
 @app.post("/logout")
 @require_login(redirect_to_login=False)
 async def admin_logout(request: Request):
-    """登出"""
+    """Admin logout (API)"""
     logout_user(request)
-    logger.info(f"[AUTH] 管理员已登出")
-    return RedirectResponse(url="/login", status_code=302)
-
-# 带PATH_PREFIX的登录端点（如果配置了PATH_PREFIX）
-if PATH_PREFIX:
-    @app.get(f"/{PATH_PREFIX}/login")
-    async def admin_login_get_prefixed(request: Request, error: str = None):
-        """登录页面（带前缀）"""
-        return templates.TemplateResponse("auth/login.html", {"request": request, "error": error})
-
-    @app.post(f"/{PATH_PREFIX}/login")
-    async def admin_login_post_prefixed(request: Request, admin_key: str = Form(...)):
-        """处理登录表单提交（带前缀）"""
-        if admin_key == ADMIN_KEY:
-            login_user(request)
-            logger.info(f"[AUTH] 管理员登录成功")
-            return RedirectResponse(url=f"/{PATH_PREFIX}", status_code=302)
+    logger.info("[AUTH] Admin logout")
+    return {"success": True}
+
+@app.get("/admin/health")
+@require_login()
+async def admin_health(request: Request):
+    return {"status": "ok", "time": datetime.utcnow().isoformat()}
+
+@app.get("/admin/stats")
+@require_login()
+async def admin_stats(request: Request):
+    now = time.time()
+    window_seconds = 12 * 3600
+
+    active_accounts = 0
+    failed_accounts = 0
+    rate_limited_accounts = 0
+    idle_accounts = 0
+
+    for account_manager in multi_account_mgr.accounts.values():
+        config = account_manager.config
+        cooldown_seconds, cooldown_reason = account_manager.get_cooldown_info()
+        is_rate_limited = cooldown_seconds > 0 and cooldown_reason and "429" in cooldown_reason
+        is_expired = config.is_expired()
+        is_auto_disabled = (not account_manager.is_available) and (not config.disabled)
+        is_failed = is_auto_disabled or is_expired or cooldown_reason == "错误禁用"
+        is_active = (not is_failed) and (not config.disabled) and (not is_rate_limited)
+
+        if is_rate_limited:
+            rate_limited_accounts += 1
+        elif is_failed:
+            failed_accounts += 1
+        elif is_active:
+            active_accounts += 1
         else:
-            logger.warning(f"[AUTH] 登录失败 - 密钥错误")
-            return templates.TemplateResponse("auth/login.html", {"request": request, "error": "密钥错误，请重试"})
+            idle_accounts += 1
 
-    @app.post(f"/{PATH_PREFIX}/logout")
-    @require_login(redirect_to_login=False)
-    async def admin_logout_prefixed(request: Request):
-        """登出（带前缀）"""
-        logout_user(request)
-        logger.info(f"[AUTH] 管理员已登出")
-        return RedirectResponse(url=f"/{PATH_PREFIX}/login", status_code=302)
+    total_accounts = len(multi_account_mgr.accounts)
 
-# ---------- 管理端点（需要登录） ----------
+    beijing_tz = timezone(timedelta(hours=8))
+    now_dt = datetime.now(beijing_tz)
+    start_dt = (now_dt - timedelta(hours=11)).replace(minute=0, second=0, microsecond=0)
+    start_ts = start_dt.timestamp()
+    labels = [(start_dt + timedelta(hours=i)).strftime("%H:00") for i in range(12)]
 
-# 不带PATH_PREFIX的管理端点
-@app.get("/admin")
-@require_login()
-async def admin_home_no_prefix(request: Request):
-    """管理首页"""
-    template_data = get_admin_template_data(request)
-    return templates.TemplateResponse("admin/index.html", template_data)
+    def bucketize(timestamps: list) -> list:
+        buckets = [0] * 12
+        for ts in timestamps:
+            idx = int((ts - start_ts) // 3600)
+            if 0 <= idx < 12:
+                buckets[idx] += 1
+        return buckets
 
-# 带PATH_PREFIX的管理端点（如果配置了PATH_PREFIX）
-if PATH_PREFIX:
-    @app.get(f"/{PATH_PREFIX}")
-    @require_login()
-    async def admin_home_prefixed(request: Request):
-        """管理首页（带前缀）"""
-        return await admin_home_no_prefix(request=request)
+    async with stats_lock:
+        global_stats.setdefault("request_timestamps", [])
+        global_stats.setdefault("failure_timestamps", [])
+        global_stats.setdefault("rate_limit_timestamps", [])
+        global_stats.setdefault("model_request_timestamps", {})
+        global_stats["request_timestamps"] = [
+            ts for ts in global_stats["request_timestamps"]
+            if now - ts < window_seconds
+        ]
+        global_stats["failure_timestamps"] = [
+            ts for ts in global_stats["failure_timestamps"]
+            if now - ts < window_seconds
+        ]
+        global_stats["rate_limit_timestamps"] = [
+            ts for ts in global_stats["rate_limit_timestamps"]
+            if now - ts < window_seconds
+        ]
+        model_request_timestamps = {}
+        for model, timestamps in global_stats["model_request_timestamps"].items():
+            model_request_timestamps[model] = [
+                ts for ts in timestamps
+                if now - ts < window_seconds
+            ]
+        global_stats["model_request_timestamps"] = model_request_timestamps
 
-# ---------- 管理API端点（需要登录） ----------
+        await save_stats(global_stats)
 
-@app.get("/admin/health")
-@require_login()
-async def admin_health(request: Request):
-    return {"status": "ok", "time": datetime.utcnow().isoformat()}
+        request_timestamps = list(global_stats["request_timestamps"])
+        failure_timestamps = list(global_stats["failure_timestamps"])
+        rate_limit_timestamps = list(global_stats["rate_limit_timestamps"])
+        model_request_timestamps = global_stats.get("model_request_timestamps", {})
+        model_requests = {}
+        for model in MODEL_MAPPING.keys():
+            model_requests[model] = bucketize(model_request_timestamps.get(model, []))
+        for model, timestamps in model_request_timestamps.items():
+            if model not in model_requests:
+                model_requests[model] = bucketize(timestamps)
+
+    return {
+        "total_accounts": total_accounts,
+        "active_accounts": active_accounts,
+        "failed_accounts": failed_accounts,
+        "rate_limited_accounts": rate_limited_accounts,
+        "idle_accounts": idle_accounts,
+        "trend": {
+            "labels": labels,
+            "total_requests": bucketize(request_timestamps),
+            "failed_requests": bucketize(failure_timestamps),
+            "rate_limited_requests": bucketize(rate_limit_timestamps),
+            "model_requests": model_requests,
+        }
+    }
 
 @app.get("/admin/accounts")
 @require_login()
@@ -803,7 +907,7 @@ async def admin_enable_account(request: Request, account_id: str):
         logger.error(f"[CONFIG] 启用账户失败: {str(e)}")
         raise HTTPException(500, f"启用失败: {str(e)}")
 
-# ---------- 系统设置 API ----------
+# ---------- Auth endpoints (API) ----------
 @app.get("/admin/settings")
 @require_login()
 async def admin_get_settings(request: Request):
@@ -975,86 +1079,10 @@ async def admin_clear_logs(request: Request, confirm: str = None):
     logger.info("[LOG] 日志已清空")
     return {"status": "success", "message": "已清空内存日志", "cleared_count": cleared_count}
 
-@app.get("/admin/log/html")
-@require_login()
-async def admin_logs_html_route(request: Request):
-    """返回美化的 HTML 日志查看界面"""
-    return templates.TemplateResponse("admin/logs.html", {"request": request})
-
-# 带PATH_PREFIX的管理API端点（如果配置了PATH_PREFIX）
-if PATH_PREFIX:
-    @app.get(f"/{PATH_PREFIX}/health")
-    @require_login()
-    async def admin_health_prefixed(request: Request):
-        return await admin_health(request=request)
-
-    @app.get(f"/{PATH_PREFIX}/accounts")
-    @require_login()
-    async def admin_get_accounts_prefixed(request: Request):
-        return await admin_get_accounts(request=request)
-
-    @app.get(f"/{PATH_PREFIX}/accounts-config")
-    @require_login()
-    async def admin_get_config_prefixed(request: Request):
-        return await admin_get_config(request=request)
-
-    @app.put(f"/{PATH_PREFIX}/accounts-config")
-    @require_login()
-    async def admin_update_config_prefixed(request: Request, accounts_data: list = Body(...)):
-        return await admin_update_config(request=request, accounts_data=accounts_data)
-
-    @app.delete(f"/{PATH_PREFIX}/accounts/{{account_id}}")
-    @require_login()
-    async def admin_delete_account_prefixed(request: Request, account_id: str):
-        return await admin_delete_account(request=request, account_id=account_id)
-
-    @app.put(f"/{PATH_PREFIX}/accounts/{{account_id}}/disable")
-    @require_login()
-    async def admin_disable_account_prefixed(request: Request, account_id: str):
-        return await admin_disable_account(request=request, account_id=account_id)
-
-    @app.put(f"/{PATH_PREFIX}/accounts/{{account_id}}/enable")
-    @require_login()
-    async def admin_enable_account_prefixed(request: Request, account_id: str):
-        return await admin_enable_account(request=request, account_id=account_id)
-
-    @app.get(f"/{PATH_PREFIX}/log")
-    @require_login()
-    async def admin_get_logs_prefixed(
-        request: Request,
-        limit: int = 1500,
-        level: str = None,
-        search: str = None,
-        start_time: str = None,
-        end_time: str = None
-    ):
-        return await admin_get_logs(request=request, limit=limit, level=level, search=search, start_time=start_time, end_time=end_time)
-
-    @app.delete(f"/{PATH_PREFIX}/log")
-    @require_login()
-    async def admin_clear_logs_prefixed(request: Request, confirm: str = None):
-        return await admin_clear_logs(request=request, confirm=confirm)
-
-    @app.get(f"/{PATH_PREFIX}/log/html")
-    @require_login()
-    async def admin_logs_html_route_prefixed(request: Request):
-        return await admin_logs_html_route(request=request)
-
-    @app.get(f"/{PATH_PREFIX}/settings")
-    @require_login()
-    async def admin_get_settings_prefixed(request: Request):
-        return await admin_get_settings(request=request)
-
-    @app.put(f"/{PATH_PREFIX}/settings")
-    @require_login()
-    async def admin_update_settings_prefixed(request: Request, new_settings: dict = Body(...)):
-        return await admin_update_settings(request=request, new_settings=new_settings)
-
-# ---------- API端点（API Key认证） ----------
+# ---------- Auth endpoints (API) ----------
 
 @app.get("/v1/models")
 async def list_models(authorization: str = Header(None)):
-    verify_api_key(API_KEY, authorization)
     data = []
     now = int(time.time())
     for m in MODEL_MAPPING.keys():
@@ -1063,20 +1091,9 @@ async def list_models(authorization: str = Header(None)):
 
 @app.get("/v1/models/{model_id}")
 async def get_model(model_id: str, authorization: str = Header(None)):
-    verify_api_key(API_KEY, authorization)
     return {"id": model_id, "object": "model"}
 
-# 带PATH_PREFIX的API端点（如果配置了PATH_PREFIX）
-if PATH_PREFIX:
-    @app.get(f"/{PATH_PREFIX}/v1/models")
-    async def list_models_prefixed(authorization: str = Header(None)):
-        return await list_models(authorization)
-
-    @app.get(f"/{PATH_PREFIX}/v1/models/{{model_id}}")
-    async def get_model_prefixed(model_id: str, authorization: str = Header(None)):
-        return await get_model(model_id, authorization)
-
-# ---------- 聊天API端点 ----------
+# ---------- Auth endpoints (API) ----------
 
 @app.post("/v1/chat/completions")
 async def chat(
@@ -1089,15 +1106,6 @@ async def chat(
     # ... (保留原有的chat逻辑)
     return await chat_impl(req, request, authorization)
 
-if PATH_PREFIX:
-    @app.post(f"/{PATH_PREFIX}/v1/chat/completions")
-    async def chat_prefixed(
-        req: ChatRequest,
-        request: Request,
-        authorization: Optional[str] = Header(None)
-    ):
-        return await chat(req, request, authorization)
-
 # chat实现函数
 async def chat_impl(
     req: ChatRequest,
@@ -1107,6 +1115,62 @@ async def chat_impl(
     # 生成请求ID（最优先，用于所有日志追踪）
     request_id = str(uuid.uuid4())[:6]
 
+    start_ts = time.time()
+    request.state.first_response_time = None
+    message_count = len(req.messages)
+
+    monitor_recorded = False
+
+    async def finalize_result(
+        status: str,
+        status_code: Optional[int] = None,
+        error_detail: Optional[str] = None
+    ) -> None:
+        nonlocal monitor_recorded
+        if monitor_recorded:
+            return
+        monitor_recorded = True
+        duration_s = time.time() - start_ts
+        latency_ms = None
+        first_response_time = getattr(request.state, "first_response_time", None)
+        if first_response_time:
+            latency_ms = int((first_response_time - start_ts) * 1000)
+        else:
+            latency_ms = int(duration_s * 1000)
+
+        uptime_tracker.record_request("api_service", status == "success", latency_ms, status_code)
+
+        entry = build_recent_conversation_entry(
+            request_id=request_id,
+            model=req.model if req else None,
+            message_count=message_count,
+            start_ts=start_ts,
+            status=status,
+            duration_s=duration_s if status == "success" else None,
+            error_detail=error_detail,
+        )
+
+        async with stats_lock:
+            global_stats.setdefault("failure_timestamps", [])
+            global_stats.setdefault("rate_limit_timestamps", [])
+            global_stats.setdefault("recent_conversations", [])
+            if status != "success":
+                if status_code == 429:
+                    global_stats["rate_limit_timestamps"].append(time.time())
+                else:
+                    global_stats["failure_timestamps"].append(time.time())
+            global_stats["recent_conversations"].append(entry)
+            global_stats["recent_conversations"] = global_stats["recent_conversations"][-60:]
+            await save_stats(global_stats)
+
+    def classify_error_status(status_code: Optional[int], error: Exception) -> str:
+        if status_code == 504:
+            return "timeout"
+        if isinstance(error, (asyncio.TimeoutError, httpx.TimeoutException)):
+            return "timeout"
+        return "error"
+
+
     # 获取客户端IP（用于会话隔离）
     client_ip = request.headers.get("x-forwarded-for")
     if client_ip:
@@ -1116,13 +1180,17 @@ async def chat_impl(
 
     # 记录请求统计
     async with stats_lock:
+        timestamp = time.time()
         global_stats["total_requests"] += 1
-        global_stats["request_timestamps"].append(time.time())
+        global_stats["request_timestamps"].append(timestamp)
+        global_stats.setdefault("model_request_timestamps", {})
+        global_stats["model_request_timestamps"].setdefault(req.model, []).append(timestamp)
         await save_stats(global_stats)
 
     # 2. 模型校验
     if req.model not in MODEL_MAPPING:
         logger.error(f"[CHAT] [req_{request_id}] 不支持的模型: {req.model}")
+        await finalize_result("error", 404, f"HTTP 404: Model '{req.model}' not found")
         raise HTTPException(
             status_code=404,
             detail=f"Model '{req.model}' not found. Available models: {list(MODEL_MAPPING.keys())}"
@@ -1173,9 +1241,12 @@ async def chat_impl(
                     account_id = account_manager.config.account_id if 'account_manager' in locals() and account_manager else 'unknown'
                     logger.error(f"[CHAT] [req_{request_id}] 账户 {account_id} 创建会话���败 (尝试 {attempt + 1}/{max_account_tries}) - {error_type}: {str(e)}")
                     # 记录账号池状态（单个账户失败）
-                    uptime_tracker.record_request("account_pool", False)
+                    status_code = e.status_code if isinstance(e, HTTPException) else None
+                    uptime_tracker.record_request("account_pool", False, status_code=status_code)
                     if attempt == max_account_tries - 1:
                         logger.error(f"[CHAT] [req_{request_id}] 所有账户均不可用")
+                        status = classify_error_status(503, last_error if isinstance(last_error, Exception) else Exception("account_pool_unavailable"))
+                        await finalize_result(status, 503, f"All accounts unavailable: {str(last_error)[:100]}")
                         raise HTTPException(503, f"All accounts unavailable: {str(last_error)[:100]}")
                     # 继续尝试下一个账户
 
@@ -1200,7 +1271,16 @@ async def chat_impl(
     logger.info(f"[CHAT] [{account_manager.config.account_id}] [req_{request_id}] 用户消息: {preview}")
 
     # 3. 解析请求内容
-    last_text, current_images = await parse_last_message(req.messages, http_client, request_id)
+    try:
+        last_text, current_images = await parse_last_message(req.messages, http_client, request_id)
+    except HTTPException as e:
+        status = classify_error_status(e.status_code, e)
+        await finalize_result(status, e.status_code, f"HTTP {e.status_code}: {e.detail}")
+        raise
+    except Exception as e:
+        status = classify_error_status(None, e)
+        await finalize_result(status, 500, f"{type(e).__name__}: {str(e)[:200]}")
+        raise
 
     # 4. 准备文本内容
     if is_new_conversation:
@@ -1293,14 +1373,24 @@ async def chat_impl(
                     global_stats["account_conversations"][account_manager.config.account_id] = account_manager.conversation_count
                     await save_stats(global_stats)
 
+                await finalize_result("success", 200, None)
+
                 break
 
             except (httpx.HTTPError, ssl.SSLError, HTTPException) as e:
+                status_code = e.status_code if isinstance(e, HTTPException) else None
+                error_detail = (
+                    f"HTTP {e.status_code}: {e.detail}"
+                    if isinstance(e, HTTPException)
+                    else f"{type(e).__name__}: {str(e)[:200]}"
+                )
                 # 记录当前失败的账户
                 failed_accounts.add(account_manager.config.account_id)
 
                 # 记录账号池状态（请求失败）
-                uptime_tracker.record_request("account_pool", False)
+                status_code = e.status_code if isinstance(e, HTTPException) else None
+
+                uptime_tracker.record_request("account_pool", False, status_code=status_code)
 
                 # 检查是否为429错误（Rate Limit）
                 is_rate_limit = isinstance(e, HTTPException) and e.status_code == 429
@@ -1349,7 +1439,8 @@ async def chat_impl(
                                 break
 
                         if not new_account:
-                            logger.error(f"[CHAT] [req_{request_id}] 所有账户均已失败，无可用账户")
+                            logger.error(f"[CHAT] [req_{request_id}] All accounts failed, no available account")
+                            await finalize_result("error", 503, "All Accounts Failed")
                             if req.stream: yield f"data: {json.dumps({'error': {'message': 'All Accounts Failed'}})}\n\n"
                             return
 
@@ -1376,12 +1467,20 @@ async def chat_impl(
                         error_type = type(create_err).__name__
                         logger.error(f"[CHAT] [req_{request_id}] 账户切换失败 ({error_type}): {str(create_err)}")
                         # 记录账号池状态（账户切换失败）
-                        uptime_tracker.record_request("account_pool", False)
+                        status_code = create_err.status_code if isinstance(create_err, HTTPException) else None
+
+                        uptime_tracker.record_request("account_pool", False, status_code=status_code)
+
+                        status = classify_error_status(status_code, create_err)
+
+                        await finalize_result(status, status_code, f"Account Failover Failed: {str(create_err)[:200]}")
                         if req.stream: yield f"data: {json.dumps({'error': {'message': 'Account Failover Failed'}})}\n\n"
                         return
                 else:
                     # 已达到最大重试次数
                     logger.error(f"[CHAT] [req_{request_id}] 已达到最大重试次数 ({max_retries})，请求失败")
+                    status = classify_error_status(status_code, e)
+                    await finalize_result(status, status_code, error_detail)
                     if req.stream: yield f"data: {json.dumps({'error': {'message': f'Max retries ({max_retries}) exceeded: {e}'}})}\n\n"
                     return
 
@@ -1465,6 +1564,8 @@ def parse_images_from_response(data_list: list) -> tuple[list, str]:
 
 async def stream_chat_generator(session: str, text_content: str, file_ids: List[str], model_name: str, chat_id: str, created_time: int, account_manager: AccountManager, is_stream: bool = True, request_id: str = "", request: Request = None):
     start_time = time.time()
+    full_content = ""
+    first_response_time = None
 
     # 记录发送给API的内容
     text_preview = text_content[:500] + "...(已截断)" if len(text_content) > 500 else text_content
@@ -1523,6 +1624,7 @@ async def stream_chat_generator(session: str, text_content: str, file_ids: List[
     ) as r:
         if r.status_code != 200:
             error_text = await r.aread()
+            uptime_tracker.record_request(model_name, False, status_code=r.status_code)
             raise HTTPException(status_code=r.status_code, detail=f"Upstream Error {error_text.decode()}")
 
         # 使用异步解析器处理 JSON 数组流
@@ -1544,7 +1646,10 @@ async def stream_chat_generator(session: str, text_content: str, file_ids: List[
                         chunk = create_chunk(chat_id, created_time, model_name, {"reasoning_content": text}, None)
                         yield f"data: {chunk}\n\n"
                     else:
+                        if first_response_time is None:
+                            first_response_time = time.time()
                         # 正常内容使用 content 字段
+                        full_content += text
                         chunk = create_chunk(chat_id, created_time, model_name, {"content": text}, None)
                         yield f"data: {chunk}\n\n"
 
@@ -1556,9 +1661,11 @@ async def stream_chat_generator(session: str, text_content: str, file_ids: List[
                     logger.info(f"[IMAGE] [{account_manager.config.account_id}] [req_{request_id}] 检测到{len(file_ids)}张生成图片")
 
         except ValueError as e:
+            uptime_tracker.record_request(model_name, False)
             logger.error(f"[API] [{account_manager.config.account_id}] [req_{request_id}] JSON解析失败: {str(e)}")
         except Exception as e:
             error_type = type(e).__name__
+            uptime_tracker.record_request(model_name, False)
             logger.error(f"[API] [{account_manager.config.account_id}] [req_{request_id}] 流处理错误 ({error_type}): {str(e)}")
             raise
 
@@ -1593,16 +1700,26 @@ async def stream_chat_generator(session: str, text_content: str, file_ids: List[
                     continue
 
                 try:
-                    image_url = save_image_to_hf(result, chat_id, fid, mime, base_url, IMAGE_DIR)
-                    logger.info(f"[IMAGE] [{account_manager.config.account_id}] [req_{request_id}] 图片{idx}已保存: {image_url}")
-                    success_count += 1
+                    # 根据配置选择输出格式
+                    output_format = config_manager.image_output_format
+
+                    if output_format == "base64":
+                        # Base64 模式：直接返回 base64 编码
+                        b64 = base64.b64encode(result).decode()
+                        markdown = f"\n\n![生成的图片](data:{mime};base64,{b64})\n\n"
+                        logger.info(f"[IMAGE] [{account_manager.config.account_id}] [req_{request_id}] 图片{idx}已编码为base64")
+                    else:
+                        # URL 模式：保存到本地并返回 URL
+                        image_url = save_image_to_hf(result, chat_id, fid, mime, base_url, IMAGE_DIR)
+                        markdown = f"\n\n![生成的图片]({image_url})\n\n"
+                        logger.info(f"[IMAGE] [{account_manager.config.account_id}] [req_{request_id}] 图片{idx}已保存: {image_url}")
 
-                    markdown = f"\n\n![生成的图片]({image_url})\n\n"
+                    success_count += 1
                     chunk = create_chunk(chat_id, created_time, model_name, {"content": markdown}, None)
                     yield f"data: {chunk}\n\n"
                 except Exception as save_error:
-                    logger.error(f"[IMAGE] [{account_manager.config.account_id}] [req_{request_id}] 图片{idx}保存失败: {str(save_error)[:100]}")
-                    error_msg = f"\n\n⚠️ 图片 {idx} 保存失败\n\n"
+                    logger.error(f"[IMAGE] [{account_manager.config.account_id}] [req_{request_id}] 图片{idx}处理失败: {str(save_error)[:100]}")
+                    error_msg = f"\n\n⚠️ 图片 {idx} 处理失败\n\n"
                     chunk = create_chunk(chat_id, created_time, model_name, {"content": error_msg}, None)
                     yield f"data: {chunk}\n\n"
 
@@ -1615,6 +1732,16 @@ async def stream_chat_generator(session: str, text_content: str, file_ids: List[
             chunk = create_chunk(chat_id, created_time, model_name, {"content": error_msg}, None)
             yield f"data: {chunk}\n\n"
 
+    if full_content:
+        response_preview = full_content[:500] + "...(已截断)" if len(full_content) > 500 else full_content
+        logger.info(f"[CHAT] [{account_manager.config.account_id}] [req_{request_id}] AI响应: {response_preview}")
+
+    if first_response_time:
+        latency_ms = int((first_response_time - start_time) * 1000)
+        uptime_tracker.record_request(model_name, True, latency_ms)
+    else:
+        uptime_tracker.record_request(model_name, True)
+
     total_time = time.time() - start_time
     logger.info(f"[API] [{account_manager.config.account_id}] [req_{request_id}] 响应完成: {total_time:.2f}秒")
     
@@ -1631,10 +1758,6 @@ async def get_public_uptime(days: int = 90):
         days = 90
     return await uptime_tracker.get_uptime_summary(days)
 
-@app.get("/public/uptime/html")
-async def get_public_uptime_html(request: Request):
-    """Uptime 监控页面（类似 status.openai.com）"""
-    return templates.TemplateResponse("public/uptime.html", {"request": request})
 
 @app.get("/public/stats")
 async def get_public_stats():
@@ -1642,14 +1765,14 @@ async def get_public_stats():
     async with stats_lock:
         # 清理1小时前的请求时间戳
         current_time = time.time()
-        global_stats["request_timestamps"] = [
+        recent_requests = [
             ts for ts in global_stats["request_timestamps"]
             if current_time - ts < 3600
         ]
 
         # 计算每分钟请求数
         recent_minute = [
-            ts for ts in global_stats["request_timestamps"]
+            ts for ts in recent_requests
             if current_time - ts < 60
         ]
         requests_per_minute = len(recent_minute)
@@ -1673,59 +1796,74 @@ async def get_public_stats():
             "load_color": load_color
         }
 
+@app.get("/public/display")
+async def get_public_display():
+    """获取公开展示信息"""
+    return {
+        "logo_url": LOGO_URL,
+        "chat_url": CHAT_URL
+    }
+
 @app.get("/public/log")
 async def get_public_logs(request: Request, limit: int = 100):
-    """获取脱敏后的日志（JSON格式）"""
     try:
         # 基于IP的访问统计（24小时内去重）
-        # 优先从 X-Forwarded-For 获取真实IP（处理代理情况）
-        client_ip = request.headers.get("x-forwarded-for")
-        if client_ip:
-            # X-Forwarded-For 可能包含多个IP，取第一个
-            client_ip = client_ip.split(",")[0].strip()
-        else:
-            # 没有代理时使用直连IP
-            client_ip = request.client.host if request.client else "unknown"
-
+        client_ip = request.client.host
         current_time = time.time()
 
         async with stats_lock:
             # 清理24小时前的IP记录
             if "visitor_ips" not in global_stats:
                 global_stats["visitor_ips"] = {}
-
-            expired_ips = [
-                ip for ip, timestamp in global_stats["visitor_ips"].items()
-                if current_time - timestamp > 86400  # 24小时
-            ]
-            for ip in expired_ips:
-                del global_stats["visitor_ips"][ip]
+            global_stats["visitor_ips"] = {
+                ip: timestamp for ip, timestamp in global_stats["visitor_ips"].items()
+                if current_time - timestamp <= 86400
+            }
 
             # 记录新访问（24小时内同一IP只计数一次）
             if client_ip not in global_stats["visitor_ips"]:
                 global_stats["visitor_ips"][client_ip] = current_time
+                global_stats["total_visitors"] = global_stats.get("total_visitors", 0) + 1
 
-            # 同步访问者计数（清理后的实际数量）
-            global_stats["total_visitors"] = len(global_stats["visitor_ips"])
+            global_stats.setdefault("recent_conversations", [])
             await save_stats(global_stats)
 
+            stored_logs = list(global_stats.get("recent_conversations", []))
+
         sanitized_logs = get_sanitized_logs(limit=min(limit, 1000))
+
+        log_map = {log.get("request_id"): log for log in sanitized_logs}
+        for log in stored_logs:
+            request_id = log.get("request_id")
+            if request_id and request_id not in log_map:
+                log_map[request_id] = log
+
+        def get_log_ts(item: dict) -> float:
+            if "start_ts" in item:
+                return float(item["start_ts"])
+            try:
+                return datetime.strptime(item.get("start_time", ""), "%Y-%m-%d %H:%M:%S").timestamp()
+            except Exception:
+                return 0.0
+
+        merged_logs = sorted(log_map.values(), key=get_log_ts, reverse=True)[:min(limit, 1000)]
+        output_logs = []
+        for log in merged_logs:
+            if "start_ts" in log:
+                log = dict(log)
+                log.pop("start_ts", None)
+            output_logs.append(log)
+
         return {
-            "total": len(sanitized_logs),
-            "logs": sanitized_logs
+            "total": len(output_logs),
+            "logs": output_logs
         }
     except Exception as e:
         logger.error(f"[LOG] 获取公开日志失败: {e}")
         return {"total": 0, "logs": [], "error": str(e)}
-
-@app.get("/public/log/html")
-async def get_public_logs_html(request: Request):
-    """公开的脱敏日志查看器"""
-    return templates.TemplateResponse("public/logs.html", {
-        "request": request,
-        "logo_url": LOGO_URL,
-        "chat_url": CHAT_URL
-    })
+    except Exception as e:
+        logger.error(f"[LOG] 获取公开日志失败: {e}")
+        return {"total": 0, "logs": [], "error": str(e)}
 
 # ---------- 全局 404 处理（必须在最后） ----------
 
@@ -1739,4 +1877,5 @@ async def not_found_handler(request: Request, exc: HTTPException):
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    port = int(os.getenv("PORT", "7860"))
+    uvicorn.run(app, host="0.0.0.0", port=port)