Upload 36 files

.gitignore

@@ -0,0 +1,53 @@
+# 确保文本文件在仓库中使用 LF
+* text=auto eol=lf
+# API密钥配置
+api_keys.json
+admin_config.json
+*.key
+
+# 环境变量和配置
+.env
+*.env
+config.local.json
+
+# 生成的图像文件
+src/static/images/*
+!src/static/images/.gitkeep
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+venv/
+.venv/
+
+# 日志文件
+*.log
+logs/
+
+# IDE配置
+.idea/
+.vscode/
+*.swp
+*.swo
+.DS_Store
+
+# Docker
+.dockerignore 

Dockerfile

@@ -0,0 +1,29 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# 设置Python环境
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONIOENCODING=utf-8
+
+# 安装依赖
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 复制应用代码
+COPY . .
+
+# 创建必要的目录
+RUN mkdir -p /app/src/static/images && \
+    chmod -R 777 /app/src/static
+
+# 暴露端口
+EXPOSE 8890
+
+# 设置健康检查
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+  CMD curl -f http://localhost:8890/health || exit 1
+
+# 启动应用
+CMD ["python", "run.py"] 

README.md

@@ -1,11 +1,485 @@
----
-title: Wulingling
-emoji: 🐠
-colorFrom: pink
-colorTo: blue
-sdk: docker
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# OpenAI兼容的Sora API服务
+
+这是一个为Sora提供OpenAI兼容接口的API服务。该服务使用cloudscraper绕过Cloudflare验证，支持多key轮询、并发处理和标准的OpenAI接口格式。
+
+## 功能特点
+
+- **OpenAI兼容接口**：完全兼容OpenAI的`/v1/chat/completions`接口
+- **CF验证绕过**：使用cloudscraper库成功绕过Cloudflare验证
+- **多key轮询**：支持多个Sora认证token，根据权重和速率限制智能选择
+- **并发处理**：支持多个并发请求
+- **流式响应**：支持SSE格式的流式响应
+- **图像处理**：支持文本到图像生成和图像到图像生成（Remix）
+- **异步处理**：支持异步生成图像，返回立即响应，防止请求超时
+- **状态查询**：提供API端点查询异步任务的状态和结果
+- **优化性能**：经过代码优化，提高请求处理速度和资源利用率
+- **健康检查**：支持容器健康检查功能
+
+## 环境要求
+
+- Python 3.8+
+- FastAPI 0.95.0+
+- cloudscraper 1.2.71+
+- 其他依赖见requirements.txt
+
+## 快速部署指南
+
+
+你可以直接运行不指定任何环境变量，所有环境变量都可以在面板里面配置
+
+
+管理员登录密钥默认：sk-123456
+
+
+api请求密钥不设置默认和管理员登录密钥相同
+
+
+docker 一键运行
+   ```bash
+   docker run -d -p 8890:8890 --name sora-api 1hei1/sora-api:latest
+   ```
+
+
+
+### 方法一：直接运行
+
+1. 克隆仓库
+   ```bash
+   git clone https://github.com/1hei1/sora-api.git
+   cd sora-api
+   ```
+
+2. 安装依赖
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. 配置API Keys（两种方式）
+   - **方式1**: 创建api_keys.json文件
+     ```json
+     [
+       {"key": "Bearer your-sora-token-1", "weight": 1, "max_rpm": 60},
+       {"key": "Bearer your-sora-token-2", "weight": 2, "max_rpm": 60}
+     ]
+     ```
+   - **方式2**: 设置环境变量
+     ```bash
+     # Linux/macOS
+     export API_KEYS='[{"key": "Bearer your-sora-token-1", "weight": 1, "max_rpm": 60}, {"key": "Bearer your-sora-token-2", "weight": 2, "max_rpm": 60}]'  
+     
+     # Windows (PowerShell)
+     $env:API_KEYS='[{"key": "Bearer your-sora-token-1", "weight": 1, "max_rpm": 60}, {"key": "Bearer your-sora-token-2", "weight": 2, "max_rpm": 60}]'
+     
+     # Windows (CMD)
+     set API_KEYS=[{"key": "Bearer your-sora-token-1", "weight": 1, "max_rpm": 60}, {"key": "Bearer your-sora-token-2", "weight": 2, "max_rpm": 60}]  
+     ```
+
+4. 配置代理（可选，如果需要）
+   ```bash
+   # Linux/macOS - 基本代理
+   export PROXY_HOST=127.0.0.1
+   export PROXY_PORT=7890
+   
+   # Linux/macOS - 带认证的代理
+   export PROXY_HOST=127.0.0.1
+   export PROXY_PORT=7890
+   export PROXY_USER=username
+   export PROXY_PASS=password
+   
+   # Windows (PowerShell) - 基本代理
+   $env:PROXY_HOST="127.0.0.1"
+   $env:PROXY_PORT="7890"
+   
+   # Windows (PowerShell) - 带认证的代理
+   $env:PROXY_HOST="127.0.0.1"
+   $env:PROXY_PORT="7890"
+   $env:PROXY_USER="username"
+   $env:PROXY_PASS="password"
+   
+   # Windows (CMD) - 基本代理
+   set PROXY_HOST=127.0.0.1
+   set PROXY_PORT=7890
+   
+   # Windows (CMD) - 带认证的代理
+   set PROXY_HOST=127.0.0.1
+   set PROXY_PORT=7890
+   set PROXY_USER=username
+   set PROXY_PASS=password
+   ```
+
+5. 启动服务
+   ```bash
+   python run.py
+   ```
+
+6. 访问服务
+   - API服务地址: http://localhost:8890
+   - 后台管理面板: http://localhost:8890/admin
+
+### 方法二：Docker部署
+
+1. 构建Docker镜像
+   ```bash
+   docker build -t sora-api .
+   ```
+
+2. 运行Docker容器（不同配置选项）
+
+   **基本运行方式**:
+   ```bash
+   docker run -d -p 8890:8890 --name sora-api sora-api
+   ```
+
+   **使用预打包镜像**:
+   ```bash
+   docker run -d -p 8890:8890 --name sora-api 1hei1/sora-api:latest
+   ```
+
+   **使用预打包镜像并配置API密钥**:
+   ```bash
+   docker run -d -p 8890:8890 \
+     -e API_KEYS='[{"key": "Bearer your-sora-token-1", "weight": 1, "max_rpm": 60}, {"key": "Bearer your-sora-token-2", "weight": 2, "max_rpm": 60}]' \
+     --name sora-api \
+     1hei1/sora-api:v0.1
+   ```
+
+   **使用预打包镜像并配置代理**:
+   ```bash
+   docker run -d -p 8890:8890 \
+     -e API_KEYS='[{"key": "Bearer your-sora-token-1", "weight": 1, "max_rpm": 60}]' \
+     -e PROXY_HOST=host.docker.internal \
+     -e PROXY_PORT=7890 \
+     --name sora-api \
+     1hei1/sora-api:v0.1
+   ```
+
+   **带API密钥配置**:
+   ```bash
+   docker run -d -p 8890:8890 \
+     -e API_KEYS='[{"key": "Bearer your-sora-token-1", "weight": 1, "max_rpm": 60}, {"key": "Bearer your-sora-token-2", "weight": 2, "max_rpm": 60}]' \
+     --name sora-api \
+     sora-api
+   ```
+
+   **带基本代理配置**:
+   ```bash
+   docker run -d -p 8890:8890 \
+     -e API_KEYS='[{"key": "Bearer your-sora-token-1", "weight": 1, "max_rpm": 60}]' \
+     -e PROXY_HOST=host.docker.internal \
+     -e PROXY_PORT=7890 \
+     --name sora-api \
+     sora-api
+   ```
+
+   **带认证代理配置**:
+   ```bash
+   docker run -d -p 8890:8890 \
+     -e API_KEYS='[{"key": "Bearer your-sora-token-1", "weight": 1, "max_rpm": 60}]' \
+     -e PROXY_HOST=host.docker.internal \
+     -e PROXY_PORT=7890 \
+     -e PROXY_USER=username \
+     -e PROXY_PASS=password \
+     --name sora-api \
+     sora-api
+   ```
+
+   **使用外部配置文件**:
+   ```bash
+   # 首先确保api_keys.json文件已正确配置
+   docker run -d -p 8890:8890 \
+     -v $(pwd)/api_keys.json:/app/api_keys.json \
+     -e PROXY_HOST=host.docker.internal \
+     -e PROXY_PORT=7890 \
+     --name sora-api \
+     sora-api
+   ```
+
+   **挂载本地目录保存图片**:
+   ```bash
+   docker run -d -p 8890:8890 \
+     -v /your/local/path:/app/src/static/images \
+     --name sora-api \
+     sora-api
+   ```
+
+   **启用详细日志**:
+   ```bash
+   docker run -d -p 8890:8890 \
+     -e API_KEYS='[{"key": "Bearer your-sora-token-1", "weight": 1, "max_rpm": 60}]' \
+     -e VERBOSE_LOGGING=true \
+     --name sora-api \
+     sora-api
+   ```
+
+   **注意**: 在Docker中使用宿主机代理时，请使用`host.docker.internal`而不是`127.0.0.1`作为代理主机地址。
+
+3. 检查容器状态
+   ```bash
+   docker ps
+   docker logs sora-api
+   ```
+
+4. 停止和移除容器
+   ```bash
+   docker stop sora-api
+   docker rm sora-api
+   ```
+
+## 环境变量说明
+
+| 环境变量 | 描述 | 默认值 | 示例 |
+|---------|------|--------|------|
+| `API_HOST` | API服务监听地址 | `0.0.0.0` | `127.0.0.1` |
+| `API_PORT` | API服务端口 | `8890` | `9000` |
+| `BASE_URL` | API基础URL（生成图片的时候需要用到） | `http://0.0.0.0:8890` | `https://api.example.com` |  
+| `PROXY_HOST` | HTTP代理主机 | 空（不使用代理） | `127.0.0.1` |
+| `PROXY_PORT` | HTTP代理端口 | 空（不使用代理） | `7890` |
+| `PROXY_USER` | HTTP代理用户名 | 空（不使用认证） | `username` |
+| `PROXY_PASS` | HTTP代理密码 | 空（不使用认证） | `password` |
+| `IMAGE_SAVE_DIR` | 图片保存目录 | `src/static/images` | `/data/images` |
+| `IMAGE_LOCALIZATION` | 是否启用图片本地化 | `False` | `True` |
+| `ADMIN_KEY` | 管理员API密钥（登录界面输入的密码） | `sk-123456` | `sk-youradminkey` |
+| `API_AUTH_TOKEN` | API认证令牌（使用api服务传入的key） | 空 | `your-auth-token` |
+| `VERBOSE_LOGGING` | 是否启用详细日志 | `False` | `True` |
+
+## API密钥配置说明
+
+API密钥配置采用JSON格式，每个密钥包含以下属性：
+
+- `key`: Sora认证令牌（必须包含Bearer前缀）
+- `weight`: 轮询权重，数字越大被选中概率越高
+- `max_rpm`: 每分钟最大请求数（速率限制）
+
+示例:
+```json
+[
+  {
+    "key": "Bearer eyJhbGciOiJSUzI1NiIsImtpZCI6IjE5MzQ0ZTY1LWJiYzktNDRkMS1hOWQwLWY5NTdiMDc5YmQwZSIsInR5cCI6IkpXVCJ9...",
+    "weight": 1,
+    "max_rpm": 60
+  },
+  {
+    "key": "Bearer eyJhbGciOiJSUzI1NiIsImtpZCI6IjE5MzQ0ZTY1LWJiYzktNDRkMS1hOWQwLWY5NTdiMDc5YmQwZSIsInR5cCI6IkpXVCJ9...",
+    "weight": 2,
+    "max_rpm": 60
+  }
+]
+```
+
+## 使用示例
+
+### 使用curl发送请求
+
+```bash
+# 文本到图像请求（非流式）
+curl -X POST http://localhost:8890/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer your-api-key" \
+  -d '{
+    "model": "sora-1.0",
+    "messages": [
+      {"role": "user", "content": "生成一只在草地上奔跑的金毛犬"}
+    ],
+    "n": 1,
+    "stream": false
+  }'
+
+# 文本到图像请求（流式）
+curl -X POST http://localhost:8890/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer your-api-key" \
+  -d '{
+    "model": "sora-1.0",
+    "messages": [
+      {"role": "user", "content": "生成一只在草地上奔跑的金毛犬"}
+    ],
+    "n": 1,
+    "stream": true
+  }'
+
+# 查询异步任务状态
+curl -X GET http://localhost:8890/v1/generation/chatcmpl-123456789abcdef \
+  -H "Authorization: Bearer your-api-key"
+```
+
+## 常见问题排查
+
+1. **连接超时或无法连接**
+   - 检查代理配置是否正确
+   - 如使用代理认证，确认用户名密码正确
+   - 确认Sora服务器是否可用
+   - 检查本地网络连接
+
+2. **API密钥加载失败**
+   - 确认api_keys.json格式正确
+   - 检查环境变量API_KEYS是否正确设置
+   - 查看日志中的错误信息
+
+3. **图片生成失败**
+   - 确认Sora令牌有效性
+   - 查看日志中的错误信息
+   - 检查是否超出账户额度限制
+
+4. **Docker容器启动失败**
+   - 检查端口是否被占用
+   - 确认环境变量设置正确
+   - 查看Docker日志中的错误信息
+   
+5. **环境变量API_AUTH_TOKEN和ADMIN_KEY的区别**
+   - 环境变量 API_AUTH_TOKEN代表你在cheery studio 或者newapi里调用填写的令牌
+   - 环境变量 ADMIN_KEY 代表你管理面板的登录密码
+   - 当不设置API_AUTH_TOKE时 其值默认等于ADMIN_KEY的值
+   
+6. **环境变量BASE_URL的作用**
+   - 这个是图片本地化时设置的，比如生成了一张图片，获取到图片原始url，由于有的客户端不能访问sora，所以要本地化，这个base_url就是指定本地化图片的url前缀。
+   
+6. **token无效**
+   - 首次使用的token需要设置用户名，可以使用下面的脚本批量设置用户名：
+ ```python
+import random
+import string
+import logging
+import cloudscraper
+
+# Configure logging
+tlogging = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+
+# --- Configuration ---
+PROXY = {
+    "http": "http://127.0.0.1:7890",
+    "https": "http://127.0.0.1:7890"
+}
+PROFILE_API = "https://sora.chatgpt.com/backend/me"
+TOKENS_FILE = "tokens.txt"  # 每行一个 Bearer token
+RESULTS_FILE = "update_results.txt"  # 保存更新结果
+USERNAME_LENGTH = 8  # 随机用户名长度
+
+# --- Utilities ---
+def random_username(length: int = USERNAME_LENGTH) -> str:
+    """生成全小写随机用户名"""
+    return ''.join(random.choices(string.ascii_lowercase, k=length))
+
+
+def sanitize_headers(headers: dict) -> dict:
+    """
+    移除所有非 Latin-1 字符，确保 headers 可以被底层 HTTP 库正确编码。
+    """
+    new = {}
+    for k, v in headers.items():
+        if isinstance(v, str):
+            new[k] = v.encode('latin-1', 'ignore').decode('latin-1')
+        else:
+            new[k] = v
+    return new
+
+
+class SoraBatchUpdater:
+    def __init__(self, proxy: dict = None):
+        self.proxy = proxy or {}
+
+    def update_username_for_token(self, token: str) -> tuple[bool, str]:
+        """
+        针对单个 Bearer token，生成随机用户名并发送更新请求。
+        返回 (success, message)。
+        """
+        scraper = cloudscraper.create_scraper()
+        if self.proxy:
+            scraper.proxies = self.proxy
+
+        headers = {
+            "Accept": "*/*",
+            "Accept-Language": "zh-CN,zh;q=0.9",
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {token}",
+            "sec-ch-ua": '"Chromium";v="136", "Google Chrome";v="136", "Not.A/Brand";v="99"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+        }
+        headers = sanitize_headers(headers)
+
+        new_username = random_username()
+        payload = {"username": new_username}
+
+        try:
+            resp = scraper.post(
+                PROFILE_API,
+                headers=headers,
+                json=payload,
+                allow_redirects=False,
+                timeout=15
+            )
+            status = resp.status_code
+            if resp.ok:
+                msg = f"OK ({new_username})"
+                logging.info("Token %s: updated to %s", token[:6], new_username)
+                return True, msg
+            else:
+                text = resp.text.replace('\n', '')
+                msg = f"Failed {status}: {text}"  # 简要错误信息
+                logging.warning("Token %s: %s", token[:6], msg)
+                return False, msg
+        except Exception as e:
+            msg = str(e)
+            logging.error("Token %s exception: %s", token[:6], msg)
+            return False, msg
+
+    def batch_update(self, tokens: list[str]) -> None:
+        """
+        对一组 Bearer token 批量更新用户名，并将结果写入 RESULTS_FILE。
+        """
+        results = []
+        for token in tokens:
+            success, message = self.update_username_for_token(token)
+            results.append((token, success, message))
+
+        # 写入结果文件
+        with open(RESULTS_FILE, 'w', encoding='utf-8') as f:
+            for token, success, msg in results:
+                status = 'SUCCESS' if success else 'ERROR'
+                f.write(f"{token} ---- {status} ---- {msg}\n")
+        logging.info("Batch update complete. Results saved to %s", RESULTS_FILE)
+
+
+def load_tokens(filepath: str) -> list[str]:
+    """从文件加载每行一个 token 的列表"""
+    try:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            return [line.strip() for line in f if line.strip()]
+    except FileNotFoundError:
+        logging.error("Tokens file not found: %s", filepath)
+        return []
+
+
+if __name__ == '__main__':
+    tokens = load_tokens(TOKENS_FILE)
+    if not tokens:
+        logging.error("No tokens to update. Exiting.")
+    else:
+        updater = SoraBatchUpdater(proxy=PROXY)
+        updater.batch_update(tokens)
+
+```
+
+
+## 性能优化
+
+最新版本包含以下性能优化：
+
+1. **代码重构**：简化了代码结构，提高可读性和可维护性
+2. **内存优化**：减少不必要的内��使用，优化大型图像处理
+3. **异步处理**：全面使用异步处理提高并发性能
+4. **错误处理**：改进了错误处理和日志记录
+5. **密钥管理**：优化了密钥轮询算法，提高了可靠性
+6. **容器优化**：增强了Docker容器配置，支持健康检查
+
+## 贡献
+
+欢迎提交问题报告和改进建议！
+
+## 许可证
+
+MIT 

api_keys.json.example

@@ -0,0 +1,12 @@
+[
+  {
+    "key": "Bearer eyJhbGciOiJSUzI1NiIsImtpZCI6IjE5MzQ0ZTY1LWJiYzktNDRkMS1hOWQwLWY5NTdiMDc5YmQwZSIsInR5cCI6IkpXVCJ9...",
+    "weight": 1,
+    "max_rpm": 60
+  },
+  {
+    "key": "Bearer eyJhbGciOiJSUzI1NiIsImtpZCI6IjE5MzQ0ZTY1LWJiYzktNDRkMS1hOWQwLWY5NTdiMDc5YmQwZSIsInR5cCI6IkpXVCJ9...",
+    "weight": 2,
+    "max_rpm": 60
+  }
+] 

docs/image_localization.md

@@ -0,0 +1 @@
+ 

requirements.txt

@@ -0,0 +1,28 @@
+# Web框架
+fastapi>=0.101.1
+uvicorn>=0.23.2
+pydantic>=2.3.0
+python-multipart==0.0.6
+
+# HTTP请求
+cloudscraper==1.2.71
+aiohttp>=3.8.5
+aiofiles==0.8.0
+
+# 工具
+python-dotenv>=1.0.0
+requests==2.30.0
+pillow==10.0.0
+cryptography==41.0.3
+psutil==5.9.5
+tzdata>=2023.3
+pytz>=2023.3
+retry>=0.9.2
+fuzzywuzzy>=0.18.0
+python-Levenshtein>=0.21.1
+tzlocal>=5.0.1
+humanize>=4.7.0
+prettytable>=3.8.0
+natsort>=8.4.0
+tenacity>=8.2.3
+PyJWT>=2.6.0 

run.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python
+import sys
+import os
+import logging
+
+# 设置日志
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger("sora-api")
+
+# 设置控制台输出编码为UTF-8
+if sys.platform.startswith('win'):
+    os.system("chcp 65001")
+    sys.stdout.reconfigure(encoding='utf-8')
+elif sys.stdout.encoding != 'utf-8':
+    sys.stdout.reconfigure(encoding='utf-8')
+
+# 确保src目录在路径中
+sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
+
+# 提前加载app和key_manager，确保API密钥在启动前已加载
+from src.app import app, key_manager
+from src.main import init_app
+from src.config import Config
+import uvicorn
+
+if __name__ == "__main__":
+    # 设置环境变量确保正确处理UTF-8
+    os.environ["PYTHONIOENCODING"] = "utf-8"
+    
+    # 初始化应用
+    init_app()
+    
+    # 启动服务
+    logger.info(f"启动OpenAI兼容的Sora API服务: {Config.HOST}:{Config.PORT}")
+    logger.info(f"已加载 {len(key_manager.keys)} 个API密钥")
+    uvicorn.run(
+        "src.app:app",
+        host=Config.HOST,
+        port=Config.PORT,
+        reload=False  # 生产环境关闭自动重载
+    ) 

src/__init__.py

@@ -0,0 +1,2 @@
+# Sora API服务包
+# 包含对Sora的API调用封装，提供OpenAI兼容接口 

src/api/__init__.py

@@ -0,0 +1,29 @@
+import logging
+from fastapi import APIRouter
+from .admin import router as admin_router
+from .generation import router as generation_router
+from .chat import router as chat_router
+from .health import router as health_router
+# 添加auth路由
+from .auth import router as auth_router
+
+# 设置日志
+logger = logging.getLogger("sora-api.api")
+
+# 创建v1版本路由（兼容OpenAI API）
+v1_router = APIRouter(prefix="/v1")
+
+# 创建主路由
+main_router = APIRouter()
+
+# 向v1路由注册相关功能路由
+v1_router.include_router(generation_router)
+v1_router.include_router(chat_router)
+
+# 注册所有路由
+main_router.include_router(v1_router) # 保持与OpenAI API兼容的v1前缀路由
+main_router.include_router(admin_router, tags=["admin"])
+main_router.include_router(health_router, tags=["health"])
+main_router.include_router(auth_router, tags=["auth"])
+
+logger.info("API路由已初始化")

src/api/admin.py

@@ -0,0 +1,463 @@
+import os
+import logging
+import dotenv
+from typing import Dict, Any, List
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import FileResponse
+
+from ..models.schemas import ApiKeyCreate, ApiKeyUpdate, ConfigUpdate, LogLevelUpdate, BatchOperation, BatchImportOperation
+from ..api.dependencies import verify_admin, verify_admin_jwt
+from ..config import Config
+from ..key_manager import key_manager
+from ..sora_integration import SoraClient
+
+# 设置日志
+logger = logging.getLogger("sora-api.admin")
+
+# 日志系统配置
+class LogConfig:
+    LEVEL = os.getenv("LOG_LEVEL", "WARNING").upper()
+    FORMAT = "%(asctime)s [%(levelname)s] %(message)s"
+
+# 创建路由
+router = APIRouter(prefix="/api")
+
+# 密钥管理API
+@router.get("/keys")
+async def get_all_keys(admin_token = Depends(verify_admin_jwt)):
+    """获取所有API密钥"""
+    return key_manager.get_all_keys()
+
+@router.get("/keys/{key_id}")
+async def get_key(key_id: str, admin_token = Depends(verify_admin_jwt)):
+    """获取单个API密钥详情"""
+    key = key_manager.get_key_by_id(key_id)
+    if not key:
+        raise HTTPException(status_code=404, detail="密钥不存在")
+    return key
+
+@router.post("/keys")
+async def create_key(key_data: ApiKeyCreate, admin_token = Depends(verify_admin_jwt)):
+    """创建新API密钥"""
+    try:
+        # 确保密钥值包含 Bearer 前缀
+        key_value = key_data.key_value
+        if not key_value.startswith("Bearer "):
+            key_value = f"Bearer {key_value}"
+            
+        new_key = key_manager.add_key(
+            key_value,
+            name=key_data.name,
+            weight=key_data.weight,
+            rate_limit=key_data.rate_limit,
+            is_enabled=key_data.is_enabled,
+            notes=key_data.notes
+        )
+        
+        # 通过Config永久保存所有密钥
+        Config.save_api_keys(key_manager.keys)
+        
+        return new_key
+    except Exception as e:
+        logger.error(f"创建密钥失败: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.put("/keys/{key_id}")
+async def update_key(key_id: str, key_data: ApiKeyUpdate, admin_token = Depends(verify_admin_jwt)):
+    """更新API密钥信息"""
+    try:
+        # 如果提供了新的密钥值，确保包含Bearer前缀
+        key_value = key_data.key_value
+        if key_value and not key_value.startswith("Bearer "):
+            key_value = f"Bearer {key_value}"
+            key_data.key_value = key_value
+            
+        updated_key = key_manager.update_key(
+            key_id,
+            key_value=key_data.key_value,
+            name=key_data.name,
+            weight=key_data.weight,
+            rate_limit=key_data.rate_limit,
+            is_enabled=key_data.is_enabled,
+            notes=key_data.notes
+        )
+        if not updated_key:
+            raise HTTPException(status_code=404, detail="密钥不存在")
+        
+        # 通过Config永久保存所有密钥
+        Config.save_api_keys(key_manager.keys)
+        
+        return updated_key
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"更新密钥失败: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.delete("/keys/{key_id}")
+async def delete_key(key_id: str, admin_token = Depends(verify_admin_jwt)):
+    """删除API密钥"""
+    success = key_manager.delete_key(key_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="密钥不存在")
+    
+    # 通过Config永久保存所有密钥
+    Config.save_api_keys(key_manager.keys)
+    
+    return {"status": "success", "message": "密钥已删除"}
+
+@router.get("/stats")
+async def get_usage_stats(admin_token = Depends(verify_admin_jwt)):
+    """获取API使用统计"""
+    stats = key_manager.get_usage_stats()
+    
+    # 处理daily_usage数据，确保前端能够正确显示
+    daily_usage = {}
+    keys_usage = {}
+    
+    # 从past_7_days数据转换为daily_usage格式
+    for date, counts in stats.get("past_7_days", {}).items():
+        daily_usage[date] = counts.get("successful", 0) + counts.get("failed", 0)
+    
+    # 获取每个密钥的使用情况
+    for key in key_manager.keys:
+        key_id = key.get("id")
+        key_name = key.get("name") or f"密钥_{key_id[:6]}"
+        
+        # 获取该密钥的使用统计
+        if key_id in key_manager.usage_stats:
+            key_stats = key_manager.usage_stats[key_id]
+            total_requests = key_stats.get("total_requests", 0)
+            
+            if total_requests > 0:
+                keys_usage[key_name] = total_requests
+    
+    # 添加到返回数据中
+    stats["daily_usage"] = daily_usage
+    stats["keys_usage"] = keys_usage
+    
+    return stats
+
+@router.post("/keys/test")
+async def test_key(key_data: ApiKeyCreate, admin_token = Depends(verify_admin_jwt)):
+    """测试API密钥是否有效"""
+    try:
+        # 获取密钥值
+        key_value = key_data.key_value.strip()
+        
+        # 确保密钥格式正确
+        if not key_value.startswith("Bearer "):
+            key_value = f"Bearer {key_value}"
+        
+        # 获取代理配置
+        proxy_host = Config.PROXY_HOST if Config.PROXY_HOST and Config.PROXY_HOST.strip() else None
+        proxy_port = Config.PROXY_PORT if Config.PROXY_PORT and Config.PROXY_PORT.strip() else None
+        proxy_user = Config.PROXY_USER if Config.PROXY_USER and Config.PROXY_USER.strip() else None
+        proxy_pass = Config.PROXY_PASS if Config.PROXY_PASS and Config.PROXY_PASS.strip() else None
+        
+        test_client = SoraClient(
+            proxy_host=proxy_host,
+            proxy_port=proxy_port,
+            proxy_user=proxy_user,
+            proxy_pass=proxy_pass,
+            auth_token=key_value
+        )
+        
+        # 执行简单API调用测试连接
+        test_result = await test_client.test_connection()
+        logger.info(f"API密钥测试结果: {test_result}")
+        
+        # 检查底层测试结果的状态
+        if test_result.get("status") == "success":
+            # API连接测试成功
+            return {
+                "status": "success", 
+                "message": "API密钥测试成功", 
+                "details": test_result,
+                "success": True
+            }
+        else:
+            # API连接测试失败
+            return {
+                "status": "error", 
+                "message": f"API密钥测试失败: {test_result.get('message', '连接失败')}", 
+                "details": test_result,
+                "success": False
+            }
+    except Exception as e:
+        logger.error(f"测试密钥失败: {str(e)}", exc_info=True)
+        return {
+            "status": "error", 
+            "message": f"API密钥测试失败: {str(e)}",
+            "success": False
+        }
+
+@router.post("/keys/batch")
+async def batch_operation(operation: Dict[str, Any], admin_token = Depends(verify_admin_jwt)):
+    """批量操作API密钥"""
+    try:
+        action = operation.get("action")
+        logger.info(f"接收到批量操作请求: {action}")
+        
+        if not action:
+            logger.warning("批量操作缺少action参数")
+            raise HTTPException(status_code=400, detail="缺少必要参数: action")
+        
+        logger.info(f"批量操作类型: {action}")
+        
+        if action == "import":
+            # 批量导入API密钥
+            keys_data = operation.get("keys", [])
+            if not keys_data:
+                logger.warning("批量导入缺少keys数据")
+                raise HTTPException(status_code=400, detail="未提供密钥数据")
+            
+            logger.info(f"准备导入 {len(keys_data)} 个密钥")
+            
+            # 对每个密钥处理Bearer前缀
+            for key_data in keys_data:
+                if isinstance(key_data, dict):
+                    key_value = key_data.get("key", "").strip()
+                    if key_value and not key_value.startswith("Bearer "):
+                        key_data["key"] = f"Bearer {key_value}"
+            
+            # 执行批量导入
+            try:
+                result = key_manager.batch_import_keys(keys_data)
+                logger.info(f"导入结果: 成功={result['imported']}, 跳过={result['skipped']}")
+                
+                # 通过Config永久保存所有密钥
+                Config.save_api_keys(key_manager.keys)
+                
+                return {
+                    "success": True,
+                    "message": f"成功导入 {result['imported']} 个密钥，跳过 {result['skipped']} 个重复密钥",
+                    "imported": result["imported"],
+                    "skipped": result["skipped"]
+                }
+            except Exception as e:
+                logger.error(f"批量导入密钥错误: {str(e)}", exc_info=True)
+                raise HTTPException(status_code=500, detail=f"导入密钥失败: {str(e)}")
+                
+        elif action not in ["enable", "disable", "delete"]:
+            logger.warning(f"不支持的批量操作: {action}")
+            raise HTTPException(status_code=400, detail=f"不支持的操作: {action}")
+            
+        # 对于非导入操作，需要提供key_ids
+        key_ids = operation.get("key_ids", [])
+        if not key_ids:
+            logger.warning(f"{action}操作缺少key_ids参数")
+            raise HTTPException(status_code=400, detail="缺少必要参数: key_ids")
+            
+        # 确保key_ids是一个列表
+        if isinstance(key_ids, str):
+            key_ids = [key_ids]
+            
+        logger.info(f"批量{action}操作 {len(key_ids)} 个密钥")
+            
+        if action == "enable":
+            # 批量启用
+            success_count = 0
+            for key_id in key_ids:
+                updated = key_manager.update_key(key_id, is_enabled=True)
+                if updated:
+                    success_count += 1
+            
+            # 通过Config永久保存所有密钥
+            Config.save_api_keys(key_manager.keys)
+            
+            logger.info(f"成功启用 {success_count} 个密钥")
+            return {
+                "success": True,
+                "message": f"已成功启用 {success_count} 个密钥",
+                "affected": success_count
+            }
+        elif action == "disable":
+            # 批量禁用
+            success_count = 0
+            for key_id in key_ids:
+                updated = key_manager.update_key(key_id, is_enabled=False)
+                if updated:
+                    success_count += 1
+            
+            # 通过Config永久保存所有密钥
+            Config.save_api_keys(key_manager.keys)
+            
+            logger.info(f"成功禁用 {success_count} 个密钥")
+            return {
+                "success": True,
+                "message": f"已成功禁用 {success_count} 个密钥",
+                "affected": success_count
+            }
+        elif action == "delete":
+            # 批量删除
+            success_count = 0
+            for key_id in key_ids:
+                if key_manager.delete_key(key_id):
+                    success_count += 1
+            
+            # 通过Config永久保存所有密钥
+            Config.save_api_keys(key_manager.keys)
+            
+            logger.info(f"成功删除 {success_count} 个密钥")
+            return {
+                "success": True,
+                "message": f"已成功删除 {success_count} 个密钥",
+                "affected": success_count
+            }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"批量操作失败: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+# 配置管理API
+@router.get("/config")
+async def get_config(admin_token = Depends(verify_admin_jwt)):
+    """获取当前系统配置"""
+    return {
+        "HOST": Config.HOST,
+        "PORT": Config.PORT,
+        "BASE_URL": Config.BASE_URL,
+        "PROXY_HOST": Config.PROXY_HOST,
+        "PROXY_PORT": Config.PROXY_PORT,
+        "PROXY_USER": Config.PROXY_USER,
+        "PROXY_PASS": "******" if Config.PROXY_PASS else "",
+        "IMAGE_LOCALIZATION": Config.IMAGE_LOCALIZATION,
+        "IMAGE_SAVE_DIR": Config.IMAGE_SAVE_DIR,
+        "API_AUTH_TOKEN": bool(Config.API_AUTH_TOKEN)  # 只返回是否设置，不返回实际值
+    }
+
+@router.post("/config")
+async def update_config(config_data: ConfigUpdate, admin_token = Depends(verify_admin_jwt)):
+    """更新系统配置"""
+    try:
+        changes = []
+        
+        # 更新代理设置
+        if config_data.PROXY_HOST is not None:
+            Config.PROXY_HOST = config_data.PROXY_HOST
+            changes.append("PROXY_HOST")
+            # 更新环境变量
+            os.environ["PROXY_HOST"] = config_data.PROXY_HOST
+            
+        if config_data.PROXY_PORT is not None:
+            Config.PROXY_PORT = config_data.PROXY_PORT
+            changes.append("PROXY_PORT")
+            # 更新环境变量
+            os.environ["PROXY_PORT"] = config_data.PROXY_PORT
+            
+        # 更新代理认证设置
+        if config_data.PROXY_USER is not None:
+            Config.PROXY_USER = config_data.PROXY_USER
+            changes.append("PROXY_USER")
+            # 更新环境变量
+            os.environ["PROXY_USER"] = config_data.PROXY_USER
+            
+        if config_data.PROXY_PASS is not None:
+            Config.PROXY_PASS = config_data.PROXY_PASS
+            changes.append("PROXY_PASS")
+            # 更新环境变量
+            os.environ["PROXY_PASS"] = config_data.PROXY_PASS
+            
+        # 更新基础URL设置
+        if config_data.BASE_URL is not None:
+            Config.BASE_URL = config_data.BASE_URL
+            changes.append("BASE_URL")
+            # 更新环境变量
+            os.environ["BASE_URL"] = config_data.BASE_URL
+            
+        # 更新图片本地化设置
+        if config_data.IMAGE_LOCALIZATION is not None:
+            Config.IMAGE_LOCALIZATION = config_data.IMAGE_LOCALIZATION
+            changes.append("IMAGE_LOCALIZATION")
+            # 更新环境变量
+            os.environ["IMAGE_LOCALIZATION"] = str(config_data.IMAGE_LOCALIZATION)
+            
+        if config_data.IMAGE_SAVE_DIR is not None:
+            Config.IMAGE_SAVE_DIR = config_data.IMAGE_SAVE_DIR
+            changes.append("IMAGE_SAVE_DIR")
+            # 更新环境变量
+            os.environ["IMAGE_SAVE_DIR"] = config_data.IMAGE_SAVE_DIR
+            # 确保目录存在
+            os.makedirs(Config.IMAGE_SAVE_DIR, exist_ok=True)
+            
+        # 保存到.env文件
+        if config_data.save_to_env and changes:
+            env_file = os.path.join(Config.BASE_DIR, '.env')
+            env_data = {}
+            
+            # 先读取现有的.env文件
+            if os.path.exists(env_file):
+                env_data = dotenv.dotenv_values(env_file)
+                
+            # 更新环境变量
+            for field in changes:
+                value = getattr(Config, field)
+                env_data[field] = str(value)
+                
+            # 写入.env文件
+            with open(env_file, 'w') as f:
+                for key, value in env_data.items():
+                    f.write(f"{key}={value}\n")
+                    
+            logger.info(f"已将配置保存到.env文件: {changes}")
+        
+        return {
+            "status": "success", 
+            "message": f"配置已更新: {', '.join(changes) if changes else '无变更'}"
+        }
+    except Exception as e:
+        logger.error(f"更新配置失败: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=400, detail=f"更新配置失败: {str(e)}")
+
+@router.post("/logs/level")
+async def update_log_level(data: LogLevelUpdate, admin_token = Depends(verify_admin_jwt)):
+    """更新日志级别"""
+    try:
+        # 验证日志级别
+        level = data.level.upper()
+        valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+        
+        if level not in valid_levels:
+            raise HTTPException(status_code=400, detail=f"无效的日志级别: {level}")
+        
+        # 更新根日志记录器的级别
+        root_logger = logging.getLogger()
+        root_logger.setLevel(getattr(logging, level))
+        
+        # 同时更新sora-api模块的日志级别
+        sora_logger = logging.getLogger("sora-api")
+        sora_logger.setLevel(getattr(logging, level))
+        
+        # 记录日志级别变更
+        logger.info(f"日志级别已更新为: {level}")
+        
+        # 如果需要，保存到环境变量
+        if data.save_to_env:
+            env_file = os.path.join(Config.BASE_DIR, '.env')
+            env_data = {}
+            
+            # 先读取现有的.env文件
+            if os.path.exists(env_file):
+                env_data = dotenv.dotenv_values(env_file)
+                
+            # 更新LOG_LEVEL环境变量
+            env_data["LOG_LEVEL"] = level
+                
+            # 写入.env文件
+            with open(env_file, 'w') as f:
+                for key, value in env_data.items():
+                    f.write(f"{key}={value}\n")
+            
+            # 记录配置保存
+            logger.info(f"已将日志级别保存到.env文件: LOG_LEVEL={level}")
+        
+        return {"status": "success", "message": f"日志级别已更新为: {level}"}
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"更新日志级别失败: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=400, detail=f"更新日志级别失败: {str(e)}")
+
+# 管理员密钥API - 已移至app.py中

src/api/auth.py

@@ -0,0 +1,96 @@
+import jwt
+import time
+import uuid
+import logging
+from typing import Dict, Any
+from fastapi import APIRouter, HTTPException, Depends
+from pydantic import BaseModel
+
+from ..config import Config
+
+# 设置日志
+logger = logging.getLogger("sora-api.auth")
+
+# 创建路由
+router = APIRouter(prefix="/api/auth")
+
+# JWT配置
+JWT_SECRET = Config.ADMIN_KEY  # 使用管理员密钥作为JWT秘钥
+JWT_ALGORITHM = "HS256"
+JWT_EXPIRATION = 3600  # 令牌有效期1小时
+
+# 认证请求模型
+class LoginRequest(BaseModel):
+    admin_key: str
+
+# 令牌响应模型
+class TokenResponse(BaseModel):
+    token: str
+    expires_in: int
+    token_type: str = "bearer"
+
+# 创建JWT令牌
+def create_jwt_token(data: Dict[str, Any], expires_delta: int = JWT_EXPIRATION) -> str:
+    payload = data.copy()
+    issued_at = int(time.time())
+    expiration = issued_at + expires_delta
+    payload.update({
+        "iat": issued_at,
+        "exp": expiration,
+        "jti": str(uuid.uuid4())
+    })
+    
+    token = jwt.encode(payload, JWT_SECRET, algorithm=JWT_ALGORITHM)
+    return token
+
+# 验证JWT令牌
+def verify_jwt_token(token: str) -> Dict[str, Any]:
+    try:
+        payload = jwt.decode(token, JWT_SECRET, algorithms=[JWT_ALGORITHM])
+        # 检查token是否已过期
+        if payload.get("exp", 0) < time.time():
+            raise HTTPException(status_code=401, detail="令牌已过期")
+        return payload
+    except jwt.PyJWTError as e:
+        logger.warning(f"JWT验证失败: {str(e)}")
+        raise HTTPException(status_code=401, detail="无效的令牌")
+
+# 登录API
+@router.post("/login", response_model=TokenResponse)
+async def login(request: LoginRequest):
+    """管理员登录，返回JWT令牌"""
+    # 验证管理员密钥
+    if request.admin_key != Config.ADMIN_KEY:
+        logger.warning(f"尝试使用无效的管理员密钥登录")
+        # 使用固定延迟以防止计时攻击
+        time.sleep(1)
+        raise HTTPException(status_code=401, detail="管理员密钥错误")
+    
+    # 创建令牌
+    token_data = {
+        "sub": "admin",
+        "role": "admin",
+        "name": "管理员"
+    }
+    
+    token = create_jwt_token(token_data)
+    logger.info(f"管理员登录成功，生成新令牌")
+    
+    return TokenResponse(token=token, expires_in=JWT_EXPIRATION)
+
+# 刷新令牌API
+@router.post("/refresh", response_model=TokenResponse)
+async def refresh_token(token: str = Depends(verify_jwt_token)):
+    """刷新JWT令牌"""
+    # 创建新令牌，保持相同的sub和role
+    token_data = {
+        "sub": token.get("sub"),
+        "role": token.get("role", "admin"),
+        "name": token.get("name", "管理员"),
+        "refresh_count": token.get("refresh_count", 0) + 1
+    }
+    
+    new_token = create_jwt_token(token_data)
+    logger.info(f"令牌刷新成功，生成新令牌")
+    
+    return TokenResponse(token=new_token, expires_in=JWT_EXPIRATION) 

src/api/chat.py

@@ -0,0 +1,168 @@
+import uuid
+import time
+import re
+import logging
+from typing import Dict, Any, List, Optional
+from fastapi import APIRouter, Depends, BackgroundTasks, HTTPException
+from fastapi.responses import StreamingResponse, JSONResponse
+
+from ..models.schemas import ChatCompletionRequest
+from ..api.dependencies import verify_api_key, get_sora_client_dep
+from ..services.image_service import process_image_task, format_think_block
+from ..services.streaming import generate_streaming_response, generate_streaming_remix_response
+from ..key_manager import key_manager
+
+# 设置日志
+logger = logging.getLogger("sora-api.chat")
+
+# 创建路由
+router = APIRouter()
+
+@router.post("/chat/completions")
+async def chat_completions(
+    request: ChatCompletionRequest,
+    background_tasks: BackgroundTasks,
+    client_info = Depends(get_sora_client_dep()),
+    api_key: str = Depends(verify_api_key)
+):
+    """
+    聊天完成端点 - 处理文本到图像和图像到图像的请求
+    兼容OpenAI API格式
+    """
+    # 解析客户端信息
+    sora_client, sora_auth_token = client_info
+    
+    # 记录开始时间
+    start_time = time.time()
+    success = False
+    
+    try:
+        # 分析用户消息
+        user_messages = [m for m in request.messages if m.role == "user"]
+        if not user_messages:
+            raise HTTPException(status_code=400, detail="至少需要一条用户消息")
+        
+        last_user_message = user_messages[-1]
+        prompt = ""
+        image_data = None
+        
+        # 提取提示词和图片数据
+        if isinstance(last_user_message.content, str):
+            # 简单的字符串内容
+            prompt = last_user_message.content
+            
+            # 检查是否包含内嵌的base64图片
+            pattern = r'data:image\/[^;]+;base64,([^"]+)'
+            match = re.search(pattern, prompt)
+            if match:
+                image_data = match.group(1)
+                # 从提示词中删除base64数据
+                prompt = re.sub(pattern, "[已上传图片]", prompt)
+        else:
+            # 多模态内容，提取文本和图片
+            content_items = last_user_message.content
+            text_parts = []
+            
+            for item in content_items:
+                if item.type == "text" and item.text:
+                    text_parts.append(item.text)
+                elif item.type == "image_url" and item.image_url:
+                    # 如果有图片URL包含base64数据
+                    url = item.image_url.get("url", "")
+                    if url.startswith("data:image/"):
+                        pattern = r'data:image\/[^;]+;base64,([^"]+)'
+                        match = re.search(pattern, url)
+                        if match:
+                            image_data = match.group(1)
+                            text_parts.append("[已上传图片]")
+            
+            prompt = " ".join(text_parts)
+        
+        # 检查是否为流式响应
+        if request.stream:
+            # 流式响应处理
+            if image_data:
+                response = StreamingResponse(
+                    generate_streaming_remix_response(sora_client, prompt, image_data, request.n),
+                    media_type="text/event-stream"
+                )
+            else:
+                response = StreamingResponse(
+                    generate_streaming_response(sora_client, prompt, request.n),
+                    media_type="text/event-stream"
+                )
+            success = True
+            
+            # 记录请求结果
+            response_time = time.time() - start_time
+            key_manager.record_request_result(sora_auth_token, success, response_time)
+            
+            return response
+        else:
+            # 非流式响应 - 返回一个即时响应，表示任务已接收
+            request_id = f"chatcmpl-{uuid.uuid4().hex}"
+            
+            # 创建后台任务
+            if image_data:
+                background_tasks.add_task(
+                    process_image_task,
+                    request_id,
+                    sora_client,
+                    "remix",
+                    prompt,
+                    image_data=image_data,
+                    num_images=request.n
+                )
+            else:
+                background_tasks.add_task(
+                    process_image_task,
+                    request_id,
+                    sora_client,
+                    "generation",
+                    prompt,
+                    num_images=request.n,
+                    width=720,
+                    height=480
+                )
+                
+            # 返回正在处理的响应
+            processing_message = "正在准备生成任务，请稍候..."
+            response = {
+                "id": request_id,
+                "object": "chat.completion",
+                "created": int(time.time()),
+                "model": "sora-1.0",
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {
+                            "role": "assistant",
+                            "content": format_think_block(processing_message)
+                        },
+                        "finish_reason": "processing"
+                    }
+                ],
+                "usage": {
+                    "prompt_tokens": len(prompt) // 4,
+                    "completion_tokens": 10,
+                    "total_tokens": len(prompt) // 4 + 10
+                }
+            }
+            
+            success = True
+            
+            # 记录请求结果
+            response_time = time.time() - start_time
+            key_manager.record_request_result(sora_auth_token, success, response_time)
+            
+            return JSONResponse(content=response)
+            
+    except Exception as e:
+        success = False
+        logger.error(f"处理聊天完成请求失败: {str(e)}", exc_info=True)
+        
+        # 记录请求结果
+        response_time = time.time() - start_time
+        key_manager.record_request_result(sora_auth_token, success, response_time)
+        
+        raise HTTPException(status_code=500, detail=f"图像生成失败: {str(e)}") 

src/api/dependencies.py

@@ -0,0 +1,131 @@
+from typing import Optional, Tuple, Dict, Any
+from fastapi import Request, HTTPException, Depends, Header
+import aiohttp
+import logging
+from ..config import Config
+from .auth import verify_jwt_token
+
+logger = logging.getLogger("sora-api.dependencies")
+
+# 全局会话池
+session_pool: Optional[aiohttp.ClientSession] = None
+
+# 获取Sora客户端
+def get_sora_client(auth_token: str):
+    from ..sora_integration import SoraClient
+    
+    # 使用字典缓存客户端实例
+    if not hasattr(get_sora_client, "clients"):
+        get_sora_client.clients = {}
+        
+    if auth_token not in get_sora_client.clients:
+        proxy_host = Config.PROXY_HOST if Config.PROXY_HOST and Config.PROXY_HOST.strip() else None
+        proxy_port = Config.PROXY_PORT if Config.PROXY_PORT and Config.PROXY_PORT.strip() else None
+        proxy_user = Config.PROXY_USER if Config.PROXY_USER and Config.PROXY_USER.strip() else None
+        proxy_pass = Config.PROXY_PASS if Config.PROXY_PASS and Config.PROXY_PASS.strip() else None
+        
+        get_sora_client.clients[auth_token] = SoraClient(
+            proxy_host=proxy_host, 
+            proxy_port=proxy_port,
+            proxy_user=proxy_user,
+            proxy_pass=proxy_pass,
+            auth_token=auth_token
+        )
+    
+    return get_sora_client.clients[auth_token]
+
+# 从请求头中获取并验证认证令牌
+async def get_token_from_header(authorization: Optional[str] = Header(None)) -> str:
+    """从请求头中获取认证令牌"""
+    if not authorization:
+        raise HTTPException(status_code=401, detail="缺少认证头")
+    
+    if not authorization.startswith("Bearer "):
+        raise HTTPException(status_code=401, detail="无效的认证头格式")
+    
+    return authorization.replace("Bearer ", "")
+
+# 验证API key
+async def verify_api_key(request: Request):
+    """检查请求头中的API密钥"""
+    auth_header = request.headers.get("Authorization")
+    if not auth_header or not auth_header.startswith("Bearer "):
+        raise HTTPException(status_code=401, detail="缺少或无效的API key")
+    
+    api_key = auth_header.replace("Bearer ", "")
+    
+    # 验证API认证令牌
+    if Config.API_AUTH_TOKEN:
+        # 如果设置了API_AUTH_TOKEN环境变量，则进行验证
+        if api_key != Config.API_AUTH_TOKEN:
+            logger.warning(f"API认证失败: 提供的令牌不匹配")
+            raise HTTPException(status_code=401, detail="API认证失败，令牌无效")
+    else:
+        # 如果未设置API_AUTH_TOKEN，则验证是否为管理面板的key
+        from ..key_manager import key_manager
+        valid_keys = [k.get("key") for k in key_manager.get_all_keys() if k.get("is_enabled", False)]
+        if api_key not in valid_keys and api_key != Config.ADMIN_KEY:
+            logger.warning(f"API认证失败: 提供的key不在有效列表中")
+            raise HTTPException(status_code=401, detail="API认证失败，key无效")
+    
+    return api_key
+
+# 获取Sora客户端依赖
+def get_sora_client_dep(specific_key=None):
+    """返回一个依赖函数，用于获取Sora客户端
+    
+    Args:
+        specific_key: 指定使用的API密钥，如果不为None，则优先使用此密钥
+    """
+    async def _get_client(auth_token: str = Depends(verify_api_key)):
+        from ..key_manager import key_manager
+        
+        # 如果提供了特定密钥，则使用该密钥
+        if specific_key:
+            sora_auth_token = specific_key
+        else:
+            # 使用密钥管理器获取可用的API密钥
+            sora_auth_token = key_manager.get_key()
+            if not sora_auth_token:
+                raise HTTPException(status_code=429, detail="所有API key都已达到速率限制")
+            
+        # 获取Sora客户端
+        return get_sora_client(sora_auth_token), sora_auth_token
+    
+    return _get_client
+
+# 验证JWT令牌并验证管理员权限
+async def verify_admin_jwt(token: str = Depends(get_token_from_header)) -> Dict[str, Any]:
+    """验证JWT令牌并确认管理员权限"""
+    # 验证JWT令牌
+    payload = verify_jwt_token(token)
+    
+    # 验证是否为管理员角色
+    if payload.get("role") != "admin":
+        raise HTTPException(status_code=403, detail="没有管理员权限")
+    
+    return payload
+
+# 验证管理员权限（传统方法，保留向后兼容性）
+async def verify_admin(request: Request):
+    """验证管理员权限"""
+    auth_header = request.headers.get("Authorization")
+    if not auth_header or not auth_header.startswith("Bearer "):
+        raise HTTPException(status_code=401, detail="未授权")
+    
+    token = auth_header.replace("Bearer ", "")
+    
+    # 尝试JWT验证
+    try:
+        payload = verify_jwt_token(token)
+        if payload.get("role") == "admin":
+            return token
+    except HTTPException:
+        # JWT验证失败，尝试传统验证
+        pass
+    
+    # 传统验证（直接验证管理员密钥）
+    if token != Config.ADMIN_KEY:
+        raise HTTPException(status_code=403, detail="没有管理员权限")
+    
+    return token 

src/api/generation.py

@@ -0,0 +1,159 @@
+import time
+import logging
+from typing import Dict, Any
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import JSONResponse
+
+from ..api.dependencies import verify_api_key, get_sora_client_dep
+from ..services.image_service import get_generation_result, get_task_api_key
+from ..key_manager import key_manager
+
+# 设置日志
+logger = logging.getLogger("sora-api.generation")
+
+# 创建路由
+router = APIRouter()
+
+@router.get("/generation/{request_id}")
+async def check_generation_status(
+    request_id: str,
+    client_info = Depends(get_sora_client_dep()),
+    api_key: str = Depends(verify_api_key)
+):
+    """
+    检查图像生成任务的状态
+    
+    Args:
+        request_id: 要查询的请求ID
+        client_info: Sora客户端信息（由依赖提供）
+        api_key: API密钥（由依赖提供）
+    
+    Returns:
+        包含任务状态和结果的JSON响应
+    """
+    # 获取任务对应的原始API密钥
+    task_api_key = get_task_api_key(request_id)
+    
+    # 如果找到任务对应的API密钥，则使用该密钥获取客户端
+    if task_api_key:
+        # 获取使用特定API密钥的客户端
+        specific_client_dep = get_sora_client_dep(specific_key=task_api_key)
+        client_info = await specific_client_dep(api_key)
+    
+    # 解析客户端信息
+    _, sora_auth_token = client_info
+    
+    # 记录开始时间
+    start_time = time.time()
+    success = False
+    
+    try:
+        # 获取任务结果
+        result = get_generation_result(request_id)
+        
+        if result.get("status") == "not_found":
+            raise HTTPException(status_code=404, detail=f"找不到生成任务: {request_id}")
+        
+        if result.get("status") == "completed":
+            # 任务已完成，返回结果
+            image_urls = result.get("image_urls", [])
+            
+            # 构建OpenAI兼容的响应
+            response = {
+                "id": request_id,
+                "object": "chat.completion",
+                "created": result.get("timestamp", int(time.time())),
+                "model": "sora-1.0",
+                "choices": [
+                    {
+                        "index": i,
+                        "message": {
+                            "role": "assistant",
+                            "content": f"![Generated Image]({url})"
+                        },
+                        "finish_reason": "stop"
+                    }
+                    for i, url in enumerate(image_urls)
+                ],
+                "usage": {
+                    "prompt_tokens": 0,
+                    "completion_tokens": 20,
+                    "total_tokens": 20
+                }
+            }
+            success = True
+            
+        elif result.get("status") == "failed":
+            # 任务失败
+            message = result.get("message", f"```think\n生成失败: {result.get('error', '未知错误')}\n```")
+            
+            response = {
+                "id": request_id,
+                "object": "chat.completion",
+                "created": result.get("timestamp", int(time.time())),
+                "model": "sora-1.0",
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {
+                            "role": "assistant",
+                            "content": message
+                        },
+                        "finish_reason": "error"
+                    }
+                ],
+                "usage": {
+                    "prompt_tokens": 0,
+                    "completion_tokens": 10,
+                    "total_tokens": 10
+                }
+            }
+            success = False
+            
+        else:  # 处理中
+            # 任务仍在处理中
+            message = result.get("message", "```think\n正在生成图像，请稍候...\n```")
+            
+            response = {
+                "id": request_id,
+                "object": "chat.completion",
+                "created": result.get("timestamp", int(time.time())),
+                "model": "sora-1.0",
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {
+                            "role": "assistant",
+                            "content": message
+                        },
+                        "finish_reason": "processing"
+                    }
+                ],
+                "usage": {
+                    "prompt_tokens": 0,
+                    "completion_tokens": 10,
+                    "total_tokens": 10
+                }
+            }
+            success = True
+            
+        # 记录请求结果
+        response_time = time.time() - start_time
+        key_manager.record_request_result(sora_auth_token, success, response_time)
+        
+        # 返回响应
+        return JSONResponse(content=response)
+        
+    except HTTPException:
+        # 直接重新抛出HTTP异常
+        raise
+    except Exception as e:
+        # 处理其他异常
+        success = False
+        logger.error(f"检查任务状态失败: {str(e)}", exc_info=True)
+        
+        # 记录请求结果
+        response_time = time.time() - start_time
+        key_manager.record_request_result(sora_auth_token, success, response_time)
+        
+        raise HTTPException(status_code=500, detail=f"检查任务状态失败: {str(e)}") 

src/api/health.py

@@ -0,0 +1,57 @@
+import time
+import platform
+import os
+import sys
+import psutil
+from fastapi import APIRouter, Depends
+from ..key_manager import key_manager
+
+# 创建路由
+router = APIRouter()
+
+@router.get("/health")
+async def health_check():
+    """
+    API健康检查端点
+    
+    返回:
+        基本的健康状态信息
+    """
+    return {
+        "status": "ok",
+        "timestamp": time.time(),
+        "version": "2.0.0"
+    }
+
+@router.get("/health/extended")
+async def extended_health_check():
+    """
+    扩展的健康检查端点
+    
+    返回:
+        详细的系统和服务状态信息
+    """
+    # 获取系统信息
+    system_info = {
+        "platform": platform.platform(),
+        "python_version": sys.version,
+        "cpu_count": psutil.cpu_count(),
+        "memory_total": psutil.virtual_memory().total,
+        "memory_available": psutil.virtual_memory().available,
+        "disk_usage": psutil.disk_usage('/').percent
+    }
+    
+    # 获取服务信息
+    service_info = {
+        "uptime": time.time() - psutil.Process(os.getpid()).create_time(),
+        "active_keys": sum(1 for k in key_manager.keys if k.get("is_enabled", False)),
+        "total_keys": len(key_manager.keys),
+    }
+    
+    return {
+        "status": "ok",
+        "timestamp": time.time(),
+        "version": "2.0.0",
+        "system": system_info,
+        "service": service_info,
+    } 

src/app.py

@@ -0,0 +1,171 @@
+import os
+import aiohttp
+import logging
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import JSONResponse, FileResponse
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.exceptions import RequestValidationError
+
+from .config import Config
+from .key_manager import key_manager
+from .api import main_router
+from .api.dependencies import session_pool
+
+# 配置日志
+logging.basicConfig(
+    level=getattr(logging, os.getenv("LOG_LEVEL", "INFO").upper()),
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S"
+)
+
+logger = logging.getLogger("sora-api")
+
+# 创建FastAPI应用
+app = FastAPI(
+    title="OpenAI Compatible Sora API",
+    description="为Sora提供OpenAI兼容接口的API服务",
+    version="2.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc",
+)
+
+# 配置CORS中间件
+origins = [
+    "http://localhost",
+    "http://localhost:8890",
+    f"http://{Config.HOST}:{Config.PORT}",
+    Config.BASE_URL,
+]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "PUT", "DELETE"],
+    allow_headers=["Authorization", "Content-Type"],
+)
+
+# 异常处理
+@app.exception_handler(RequestValidationError)
+async def validation_exception_handler(request: Request, exc: RequestValidationError):
+    """处理请求验证错误"""
+    return JSONResponse(
+        status_code=422,
+        content={"detail": f"请求验证错误: {str(exc)}"}
+    )
+
+@app.exception_handler(Exception)
+async def global_exception_handler(request: Request, exc: Exception):
+    """全局异常处理器"""
+    # 记录错误
+    logger.error(f"全局异常: {str(exc)}", exc_info=True)
+    
+    # 如果是已知的HTTPException，保持原始状态码和详情
+    if isinstance(exc, HTTPException):
+        return JSONResponse(
+            status_code=exc.status_code,
+            content={"detail": exc.detail}
+        )
+    
+    # 其他异常返回500状态码
+    return JSONResponse(
+        status_code=500,
+        content={"detail": f"服务器内部错误: {str(exc)}"}
+    )
+
+# 应用启动和关闭事件
+@app.on_event("startup")
+async def startup_event():
+    """应用启动时执行的操作"""
+    global session_pool
+    # 创建共享会话池
+    session_pool = aiohttp.ClientSession()
+    logger.info("应用已启动，创建了全局会话池")
+    
+    # 初始化时保存管理员密钥
+    Config.save_admin_key()
+    
+    # 确保静态文件目录存在
+    os.makedirs(os.path.join(Config.STATIC_DIR, "admin"), exist_ok=True)
+    os.makedirs(os.path.join(Config.STATIC_DIR, "admin/js"), exist_ok=True)
+    os.makedirs(os.path.join(Config.STATIC_DIR, "admin/css"), exist_ok=True)
+    os.makedirs(Config.IMAGE_SAVE_DIR, exist_ok=True)
+    
+    # 输出图片保存目录的信息 
+    logger.info(f"图片保存目录: {Config.IMAGE_SAVE_DIR}")
+    
+    # 图片访问URL
+    base_url = Config.BASE_URL.rstrip('/')
+    if Config.STATIC_PATH_PREFIX:
+        logger.info(f"图片将通过 {base_url}{Config.STATIC_PATH_PREFIX}/images/<filename> 访问")
+    else:
+        logger.info(f"图片将通过 {base_url}/images/<filename> 访问")
+    
+    # 打印配置信息
+    Config.print_config()
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """应用关闭时执行的操作"""
+    # 关闭会话池
+    if session_pool:
+        await session_pool.close()
+    logger.info("应用已关闭，清理了全局会话池")
+
+# 添加根路径路由
+@app.get("/")
+async def root():
+    """根路径，返回系统状态信息"""
+    return {
+        "status": "OK",
+        "message": "系统运行正常",
+        "version": app.version,
+        "name": app.title
+    }
+
+# 挂载静态文件目录
+app.mount("/static", StaticFiles(directory=Config.STATIC_DIR), name="static")
+
+# 通用图片访问路由 - 支持多种路径格式
+@app.get("/images/{filename}")
+@app.get("/static/images/{filename}")
+async def get_image(filename: str):
+    """处理图片请求 - 无论保存在哪里"""
+    # 直接从IMAGE_SAVE_DIR获取图片
+    file_path = os.path.join(Config.IMAGE_SAVE_DIR, filename)
+    if os.path.exists(file_path):
+        return FileResponse(file_path)
+    else:
+        logger.warning(f"请求的图片不存在: {file_path}")
+        raise HTTPException(status_code=404, detail="图片不存在")
+
+# 添加静态文件路径前缀的兼容路由
+if Config.STATIC_PATH_PREFIX:
+    prefix_path = Config.STATIC_PATH_PREFIX.lstrip("/")
+    
+    @app.get(f"/{prefix_path}/images/{{filename}}")
+    async def get_prefixed_image(filename: str):
+        """处理带前缀的图片请求"""
+        return await get_image(filename)
+
+# 管理界面路由
+@app.get("/admin")
+async def admin_panel():
+    """返回管理面板HTML页面"""
+    return FileResponse(os.path.join(Config.STATIC_DIR, "admin/index.html"))
+
+# 现在使用JWT��证，不再需要直接暴露管理员密钥
+
+# 注册所有API路由
+app.include_router(main_router)
+
+# 应用入口点（供uvicorn直接调用）
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(
+        "app:app",
+        host=Config.HOST,
+        port=Config.PORT,
+        reload=Config.VERBOSE_LOGGING
+    ) 

src/app.py.backup

@@ -0,0 +1,1159 @@
+import asyncio
+import json
+import time
+import uuid
+import base64
+import os
+import tempfile
+import threading
+import dotenv
+import logging
+from typing import List, Dict, Any, Optional, Union
+from fastapi import FastAPI, HTTPException, Depends, Request, BackgroundTasks, File, UploadFile, Form
+from fastapi.responses import StreamingResponse, JSONResponse, FileResponse, HTMLResponse
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel, Field
+import uvicorn
+import re
+
+from .key_manager import KeyManager
+from .sora_integration import SoraClient
+from .config import Config
+from .utils import localize_image_urls  # 导入新增的图片本地化功能
+
+# 日志系统配置
+class LogConfig:
+    LEVEL = os.getenv("LOG_LEVEL", "WARNING").upper()
+    FORMAT = "%(asctime)s [%(levelname)s] %(message)s"
+
+# 初始化日志
+logging.basicConfig(
+    level=getattr(logging, LogConfig.LEVEL),
+    format=LogConfig.FORMAT,
+    datefmt="%Y-%m-%d %H:%M:%S"
+)
+logger = logging.getLogger("sora-api")
+
+# 打印日志级别信息
+logger.info(f"日志级别设置为: {LogConfig.LEVEL}")
+logger.info(f"要调整日志级别，请设置环境变量 LOG_LEVEL=DEBUG|INFO|WARNING|ERROR")
+
+# 创建FastAPI应用
+app = FastAPI(title="OpenAI Compatible Sora API")
+
+# 添加CORS支持
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# 确保静态文件目录存在
+os.makedirs(os.path.join(Config.STATIC_DIR, "admin"), exist_ok=True)
+os.makedirs(os.path.join(Config.STATIC_DIR, "admin/js"), exist_ok=True)
+os.makedirs(os.path.join(Config.STATIC_DIR, "admin/css"), exist_ok=True)
+os.makedirs(os.path.join(Config.STATIC_DIR, "images"), exist_ok=True)  # 确保图片目录存在
+
+# 打印配置信息
+Config.print_config()
+
+# 挂载静态文件目录
+app.mount("/static", StaticFiles(directory=Config.STATIC_DIR), name="static")
+
+# 初始化Key管理器
+key_manager = KeyManager(storage_file=Config.KEYS_STORAGE_FILE)
+
+# 初始化时保存管理员密钥
+Config.save_admin_key()
+
+# 创建Sora客户端池
+sora_clients = {}
+
+# 存储生成结果的全局字典
+generation_results = {}
+
+# 请求模型
+class ContentItem(BaseModel):
+    type: str
+    text: Optional[str] = None
+    image_url: Optional[Dict[str, str]] = None
+
+class ChatMessage(BaseModel):
+    role: str
+    content: Union[str, List[ContentItem]]
+
+class ChatCompletionRequest(BaseModel):
+    model: str
+    messages: List[ChatMessage]
+    temperature: Optional[float] = 1.0
+    top_p: Optional[float] = 1.0
+    n: Optional[int] = 1
+    stream: Optional[bool] = False
+    max_tokens: Optional[int] = None
+    presence_penalty: Optional[float] = 0
+    frequency_penalty: Optional[float] = 0
+
+# API密钥管理模型
+class ApiKeyCreate(BaseModel):
+    name: str = Field(..., description="密钥名称")
+    key_value: str = Field(..., description="Bearer Token值")
+    weight: int = Field(default=1, ge=1, le=10, description="权重值")
+    rate_limit: int = Field(default=60, description="每分钟最大请求数")
+    is_enabled: bool = Field(default=True, description="是否启用")
+    notes: Optional[str] = Field(default=None, description="备注信息")
+
+class ApiKeyUpdate(BaseModel):
+    name: Optional[str] = None
+    key_value: Optional[str] = None
+    weight: Optional[int] = None
+    rate_limit: Optional[int] = None
+    is_enabled: Optional[bool] = None
+    notes: Optional[str] = None
+    
+# 获取Sora客户端
+def get_sora_client(auth_token: str) -> SoraClient:
+    if auth_token not in sora_clients:
+        proxy_host = Config.PROXY_HOST if Config.PROXY_HOST and Config.PROXY_HOST.strip() else None
+        proxy_port = Config.PROXY_PORT if Config.PROXY_PORT and Config.PROXY_PORT.strip() else None
+        
+        sora_clients[auth_token] = SoraClient(
+            proxy_host=proxy_host, 
+            proxy_port=proxy_port,
+            auth_token=auth_token
+        )
+    return sora_clients[auth_token]
+
+# 验证API key
+async def verify_api_key(request: Request):
+    auth_header = request.headers.get("Authorization")
+    if not auth_header or not auth_header.startswith("Bearer "):
+        raise HTTPException(status_code=401, detail="缺少或无效的API key")
+    
+    api_key = auth_header.replace("Bearer ", "")
+    # 在实际应用中，这里应该验证key的有效性
+    # 这里简化处理，假设所有key都有效
+    return api_key
+
+# 验证管理员权限
+async def verify_admin(request: Request):
+    auth_header = request.headers.get("Authorization")
+    if not auth_header or not auth_header.startswith("Bearer "):
+        raise HTTPException(status_code=401, detail="未授权")
+    
+    admin_key = auth_header.replace("Bearer ", "")
+    # 这里应该检查是否为管理员密钥
+    # 简化处理，假设admin_key是预设的管理员密钥
+    if admin_key != Config.ADMIN_KEY:
+        raise HTTPException(status_code=403, detail="没有管理员权限")
+    return admin_key
+
+# 将处理中状态消息格式化为think代码块
+def format_think_block(message):
+    """将消息放入```think代码块中"""
+    return f"```think\n{message}\n```"
+
+# 后台任务处理函数 - 文本生成图像
+async def process_image_generation(
+    request_id: str,
+    sora_client: SoraClient,
+    prompt: str,
+    num_images: int = 1,
+    width: int = 720,
+    height: int = 480
+):
+    try:
+        # 更新状态为生成中
+        generation_results[request_id] = {
+            "status": "processing",
+            "message": format_think_block("正在生成图像中，请耐心等待..."),
+            "timestamp": int(time.time())
+        }
+        
+        # 生成图像
+        logger.info(f"[{request_id}] 开始生成图像, 提示词: {prompt}")
+        image_urls = await sora_client.generate_image(
+            prompt=prompt,
+            num_images=num_images,
+            width=width,
+            height=height
+        )
+        
+        # 验证生成结果
+        if isinstance(image_urls, str):
+            logger.warning(f"[{request_id}] 图像生成失败或返回了错误信息: {image_urls}")
+            generation_results[request_id] = {
+                "status": "failed",
+                "error": image_urls,
+                "message": format_think_block(f"图像生成失败: {image_urls}"),
+                "timestamp": int(time.time())
+            }
+            return
+            
+        if not image_urls:
+            logger.warning(f"[{request_id}] 图像生成返回了空列表")
+            generation_results[request_id] = {
+                "status": "failed",
+                "error": "图像生成返回了空结果",
+                "message": format_think_block("图像生成失败: 服务器返回了空结果"),
+                "timestamp": int(time.time())
+            }
+            return
+            
+        logger.info(f"[{request_id}] 成功生成 {len(image_urls)} 张图片")
+        if logger.isEnabledFor(logging.DEBUG):
+            for i, url in enumerate(image_urls):
+                logger.debug(f"[{request_id}] 图片 {i+1}: {url}")
+        
+        # 本地化图片URL
+        if Config.IMAGE_LOCALIZATION:
+            logger.info(f"[{request_id}] 准备进行图片本地化处理")
+            logger.debug(f"[{request_id}] 图片本地化配置: 启用={Config.IMAGE_LOCALIZATION}, 保存目录={Config.IMAGE_SAVE_DIR}")
+            try:
+                localized_urls = await localize_image_urls(image_urls)
+                logger.info(f"[{request_id}] 图片本地化处理完成")
+                
+                # 检查本地化结果
+                if not localized_urls:
+                    logger.warning(f"[{request_id}] 本地化处理返回了空列表，将使用原始URL")
+                    localized_urls = image_urls
+                
+                # 检查是否所有URL都被正确本地化
+                local_count = sum(1 for url in localized_urls if url.startswith("/static/") or "/static/" in url)
+                logger.info(f"[{request_id}] 本地化结果: 总计 {len(localized_urls)} 张图片，成功本地化 {local_count} 张")
+                
+                if local_count == 0:
+                    logger.warning(f"[{request_id}] 警告：没有一个URL被成功本地化，将使用原始URL")
+                    localized_urls = image_urls
+                
+                # 打印结果对比
+                if logger.isEnabledFor(logging.DEBUG):
+                    for i, (orig, local) in enumerate(zip(image_urls, localized_urls)):
+                        logger.debug(f"[{request_id}] 图片 {i+1} 本地化结果: {orig} -> {local}")
+                
+                image_urls = localized_urls
+            except Exception as e:
+                logger.error(f"[{request_id}] 图片本地化过程中发生错误: {str(e)}")
+                if logger.isEnabledFor(logging.DEBUG):
+                    import traceback
+                    logger.debug(traceback.format_exc())
+                logger.info(f"[{request_id}] 由于错误，将使用原始URL")
+        else:
+            logger.info(f"[{request_id}] 图片本地化功能未启用，使用原始URL")
+        
+        # 存储结果
+        generation_results[request_id] = {
+            "status": "completed",
+            "image_urls": image_urls,
+            "timestamp": int(time.time())
+        }
+        
+        # 30分钟后自动清理结果
+        threading.Timer(1800, lambda: generation_results.pop(request_id, None)).start()
+        
+    except Exception as e:
+        error_message = f"图像生成失败: {str(e)}"
+        generation_results[request_id] = {
+            "status": "failed",
+            "error": error_message,
+            "message": format_think_block(error_message),
+            "timestamp": int(time.time())
+        }
+        logger.error(f"图像生成失败 (ID: {request_id}): {str(e)}")
+        if logger.isEnabledFor(logging.DEBUG):
+            import traceback
+            logger.debug(traceback.format_exc())
+
+# 后台任务处理函数 - 带图片的remix
+async def process_image_remix(
+    request_id: str,
+    sora_client: SoraClient,
+    prompt: str,
+    image_data: str,
+    num_images: int = 1
+):
+    try:
+        # 更新状态为处理中
+        generation_results[request_id] = {
+            "status": "processing",
+            "message": format_think_block("正在处理上传的图片..."),
+            "timestamp": int(time.time())
+        }
+        
+        # 保存base64图片到临时文件
+        temp_dir = tempfile.mkdtemp()
+        temp_image_path = os.path.join(temp_dir, f"upload_{uuid.uuid4()}.png")
+        
+        try:
+            # 解码并保存图片
+            with open(temp_image_path, "wb") as f:
+                f.write(base64.b64decode(image_data))
+            
+            # 更新状态为上传中
+            generation_results[request_id] = {
+                "status": "processing",
+                "message": format_think_block("正在上传图片到Sora服务..."),
+                "timestamp": int(time.time())
+            }
+            
+            # 上传图片
+            upload_result = await sora_client.upload_image(temp_image_path)
+            media_id = upload_result['id']
+            
+            # 更新状态为生成中
+            generation_results[request_id] = {
+                "status": "processing",
+                "message": format_think_block("正在基于图片生成新图像..."),
+                "timestamp": int(time.time())
+            }
+            
+            # 执行remix生成
+            logger.info(f"[{request_id}] 开始生成Remix图像, 提示词: {prompt}")
+            image_urls = await sora_client.generate_image_remix(
+                prompt=prompt,
+                media_id=media_id,
+                num_images=num_images
+            )
+            
+            # 本地化图片URL
+            if Config.IMAGE_LOCALIZATION:
+                logger.info(f"[{request_id}] 准备进行图片本地化处理")
+                localized_urls = await localize_image_urls(image_urls)
+                image_urls = localized_urls
+                logger.info(f"[{request_id}] Remix图片本地化处理完成")
+            
+            # 存储结果
+            generation_results[request_id] = {
+                "status": "completed",
+                "image_urls": image_urls,
+                "timestamp": int(time.time())
+            }
+            
+            # 30分钟后自动清理结果
+            threading.Timer(1800, lambda: generation_results.pop(request_id, None)).start()
+            
+        finally:
+            # 清理临时文件
+            if os.path.exists(temp_image_path):
+                os.remove(temp_image_path)
+            if os.path.exists(temp_dir):
+                os.rmdir(temp_dir)
+                
+    except Exception as e:
+        error_message = f"图像Remix失败: {str(e)}"
+        generation_results[request_id] = {
+            "status": "failed",
+            "error": error_message,
+            "message": format_think_block(error_message),
+            "timestamp": int(time.time())
+        }
+        logger.error(f"图像Remix失败 (ID: {request_id}): {str(e)}")
+
+# 添加一个新端点用于检查生成状态
+@app.get("/v1/generation/{request_id}")
+async def check_generation_status(request_id: str, api_key: str = Depends(verify_api_key)):
+    """
+    检查图像生成任务的状态
+    """
+    # 获取一个可用的key并记录开始时间
+    sora_auth_token = key_manager.get_key()
+    if not sora_auth_token:
+        raise HTTPException(status_code=429, detail="所有API key都已达到速率限制")
+        
+    start_time = time.time()
+    success = False
+    
+    try:
+        if request_id not in generation_results:
+            raise HTTPException(status_code=404, detail=f"找不到生成任务: {request_id}")
+        
+        result = generation_results[request_id]
+        
+        if result["status"] == "completed":
+            image_urls = result["image_urls"]
+            
+            # 构建OpenAI兼容的响应
+            response = {
+                "id": request_id,
+                "object": "chat.completion",
+                "created": result["timestamp"],
+                "model": "sora-1.0",
+                "choices": [
+                    {
+                        "index": i,
+                        "message": {
+                            "role": "assistant",
+                            "content": f"![Generated Image]({url})"
+                        },
+                        "finish_reason": "stop"
+                    }
+                    for i, url in enumerate(image_urls)
+                ],
+                "usage": {
+                    "prompt_tokens": 0,  # 简化的令牌计算
+                    "completion_tokens": 20,
+                    "total_tokens": 20
+                }
+            }
+            success = True
+            return JSONResponse(content=response)
+        
+        elif result["status"] == "failed":
+            if "message" in result:
+                # 返回带有格式化错误消息的响应
+                response = {
+                    "id": request_id,
+                    "object": "chat.completion",
+                    "created": result["timestamp"],
+                    "model": "sora-1.0",
+                    "choices": [
+                        {
+                            "index": 0,
+                            "message": {
+                                "role": "assistant",
+                                "content": result["message"]
+                            },
+                            "finish_reason": "error"
+                        }
+                    ],
+                    "usage": {
+                        "prompt_tokens": 0,
+                        "completion_tokens": 10,
+                        "total_tokens": 10
+                    }
+                }
+                success = False
+                return JSONResponse(content=response)
+            else:
+                # 向后兼容，使用老的方式
+                raise HTTPException(status_code=500, detail=f"生成失败: {result['error']}")
+        
+        else:  # 处理中
+            message = result.get("message", "```think\n正在生成图像，请稍候...\n```")
+            response = {
+                "id": request_id,
+                "object": "chat.completion",
+                "created": result["timestamp"],
+                "model": "sora-1.0",
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {
+                            "role": "assistant",
+                            "content": message
+                        },
+                        "finish_reason": "processing"
+                    }
+                ],
+                "usage": {
+                    "prompt_tokens": 0,
+                    "completion_tokens": 10,
+                    "total_tokens": 10
+                }
+            }
+            success = True
+            return JSONResponse(content=response)
+    except Exception as e:
+        success = False
+        raise HTTPException(status_code=500, detail=f"检查任务状态失败: {str(e)}")
+    finally:
+        # 记录请求结果
+        response_time = time.time() - start_time
+        key_manager.record_request_result(sora_auth_token, success, response_time)
+
+# 聊天完成端点
+@app.post("/v1/chat/completions")
+async def chat_completions(
+    request: ChatCompletionRequest,
+    api_key: str = Depends(verify_api_key),
+    background_tasks: BackgroundTasks = None
+):
+    # 获取一个可用的key
+    sora_auth_token = key_manager.get_key()
+    if not sora_auth_token:
+        raise HTTPException(status_code=429, detail="所有API key都已达到速率限制")
+    
+    # 获取Sora客户端
+    sora_client = get_sora_client(sora_auth_token)
+    
+    # 分析最后一条用户消息以提取内容
+    user_messages = [m for m in request.messages if m.role == "user"]
+    if not user_messages:
+        raise HTTPException(status_code=400, detail="至少需要一条用户消息")
+    
+    last_user_message = user_messages[-1]
+    prompt = ""
+    image_data = None
+    
+    # 提取提示词和图片数据
+    if isinstance(last_user_message.content, str):
+        # 简单的字符串内容
+        prompt = last_user_message.content
+        
+        # 检查是否包含内嵌的base64图片
+        pattern = r'data:image\/[^;]+;base64,([^"]+)'
+        match = re.search(pattern, prompt)
+        if match:
+            image_data = match.group(1)
+            # 从提示词中删除base64数据，以保持提示词的可读性
+            prompt = re.sub(pattern, "[已上传图片]", prompt)
+    else:
+        # 多模态内容，提取文本和图片
+        content_items = last_user_message.content
+        text_parts = []
+        
+        for item in content_items:
+            if item.type == "text" and item.text:
+                text_parts.append(item.text)
+            elif item.type == "image_url" and item.image_url:
+                # 如果有图片URL包含base64数据
+                url = item.image_url.get("url", "")
+                if url.startswith("data:image/"):
+                    pattern = r'data:image\/[^;]+;base64,([^"]+)'
+                    match = re.search(pattern, url)
+                    if match:
+                        image_data = match.group(1)
+                        text_parts.append("[已上传图片]")
+        
+        prompt = " ".join(text_parts)
+    
+    # 记录开始时间
+    start_time = time.time()
+    success = False
+    
+    # 处理图片生成
+    try:
+        # 检查是否为流式响应
+        if request.stream:
+            # 流式响应特殊处理文本+图片的情况
+            if image_data:
+                response = StreamingResponse(
+                    generate_streaming_remix_response(sora_client, prompt, image_data, request.n),
+                    media_type="text/event-stream"
+                )
+            else:
+                response = StreamingResponse(
+                    generate_streaming_response(sora_client, prompt, request.n),
+                    media_type="text/event-stream"
+                )
+            success = True
+            
+            # 记录请求结果（流式响应立即记录）
+            response_time = time.time() - start_time
+            key_manager.record_request_result(sora_auth_token, success, response_time)
+            
+            return response
+        else:
+            # 对于非流式响应，返回一个即时响应，表示任务已接收
+            # 创建一个唯一ID
+            request_id = f"chatcmpl-{uuid.uuid4().hex}"
+            
+            # 在结果字典中创建初始状态
+            processing_message = "正在准备生成任务，请稍候..."
+            generation_results[request_id] = {
+                "status": "processing",
+                "message": format_think_block(processing_message),
+                "timestamp": int(time.time())
+            }
+            
+            # 添加后台任务
+            if image_data:
+                background_tasks.add_task(
+                    process_image_remix,
+                    request_id,
+                    sora_client,
+                    prompt,
+                    image_data,
+                    request.n
+                )
+            else:
+                background_tasks.add_task(
+                    process_image_generation,
+                    request_id,
+                    sora_client,
+                    prompt,
+                    request.n,
+                    720,  # width
+                    480   # height
+                )
+                
+            # 立即返回一个"正在处理中"的响应
+            response = {
+                "id": request_id,
+                "object": "chat.completion",
+                "created": int(time.time()),
+                "model": "sora-1.0",
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {
+                            "role": "assistant",
+                            "content": format_think_block(processing_message)
+                        },
+                        "finish_reason": "processing"
+                    }
+                ],
+                "usage": {
+                    "prompt_tokens": len(prompt) // 4,
+                    "completion_tokens": 10,
+                    "total_tokens": len(prompt) // 4 + 10
+                }
+            }
+            
+            success = True
+            
+            # 记录请求结果（非流式响应立即记录）
+            response_time = time.time() - start_time
+            key_manager.record_request_result(sora_auth_token, success, response_time)
+            
+            return JSONResponse(content=response)            
+    except Exception as e:
+        success = False
+        
+        # 记录请求结果（异常情况也记录）
+        response_time = time.time() - start_time
+        key_manager.record_request_result(sora_auth_token, success, response_time)
+        
+        raise HTTPException(status_code=500, detail=f"图像生成失败: {str(e)}")
+
+# 流式响应生成器 - 普通文本到图像
+async def generate_streaming_response(
+    sora_client: SoraClient,
+    prompt: str,
+    n_images: int = 1
+):
+    request_id = f"chatcmpl-{uuid.uuid4().hex}"
+    
+    # 发送开始事件
+    yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'role': 'assistant'}, 'finish_reason': None}]})}\n\n"
+    
+    # 发送处理中的消息（放在代码块中）
+    start_msg = "```think\n正在生成图像，请稍候...\n"
+    yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': start_msg}, 'finish_reason': None}]})}\n\n"
+    
+    # 创建一个后台任务来生成图像
+    logger.info(f"[流式响应 {request_id}] 开始生成图像, 提示词: {prompt}")
+    generation_task = asyncio.create_task(sora_client.generate_image(
+        prompt=prompt,
+        num_images=n_images,
+        width=720,
+        height=480
+    ))
+    
+    # 每5秒发送一条"仍在生成中"的消息，防止连接超时
+    progress_messages = [
+        "正在处理您的请求...",
+        "仍在生成图像中，请继续等待...",
+        "Sora正在创作您的图像作品...",
+        "图像生成需要一点时间，感谢您的耐心等待...",
+        "我们正在努力为您创作高质量图像..."
+    ]
+    
+    i = 0
+    while not generation_task.done():
+        # 每5秒发送一次进度消息
+        await asyncio.sleep(5)
+        progress_msg = progress_messages[i % len(progress_messages)]
+        i += 1
+        content = "\n" + progress_msg + "\n"
+        yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': content}, 'finish_reason': None}]})}\n\n"
+    
+    try:
+        # 获取生成结果
+        image_urls = await generation_task
+        logger.info(f"[流式响应 {request_id}] 图像生成完成，获取到 {len(image_urls) if isinstance(image_urls, list) else '非列表'} 个URL")
+        
+        # 本地化图片URL
+        if Config.IMAGE_LOCALIZATION and isinstance(image_urls, list) and image_urls:
+            logger.info(f"[流式响应 {request_id}] 准备进行图片本地化处理")
+            try:
+                localized_urls = await localize_image_urls(image_urls)
+                logger.info(f"[流式响应 {request_id}] 图片本地化处理完成")
+                
+                # 检查本地化结果
+                if not localized_urls:
+                    logger.warning(f"[流式响应 {request_id}] 本地化处理返回了空列表，将使用原始URL")
+                    localized_urls = image_urls
+                
+                # 检查是否所有URL都被正确本地化
+                local_count = sum(1 for url in localized_urls if url.startswith("/static/") or "/static/" in url)
+                if local_count == 0:
+                    logger.warning(f"[流式响应 {request_id}] 警告：没有一个URL被成功本地化，将使用原始URL")
+                    localized_urls = image_urls
+                else:
+                    logger.info(f"[流式响应 {request_id}] 成功本地化 {local_count}/{len(localized_urls)} 张图片")
+                
+                # 打印本地化对比结果
+                if logger.isEnabledFor(logging.DEBUG):
+                    for i, (orig, local) in enumerate(zip(image_urls, localized_urls)):
+                        logger.debug(f"[流式响应 {request_id}] 图片 {i+1}: {orig} -> {local}")
+                
+                image_urls = localized_urls
+            except Exception as e:
+                logger.error(f"[流式响应 {request_id}] 图片本地化过程中发生错误: {str(e)}")
+                if logger.isEnabledFor(logging.DEBUG):
+                    import traceback
+                    logger.debug(traceback.format_exc())
+                logger.info(f"[流式响应 {request_id}] 由于错误，将使用原始URL")
+        elif not Config.IMAGE_LOCALIZATION:
+            logger.info(f"[流式响应 {request_id}] 图片本地化功能未启用")
+        elif not isinstance(image_urls, list) or not image_urls:
+            logger.warning(f"[流式响应 {request_id}] 无法进行本地化: 图像结果不是有效的URL列表")
+        
+        # 结束代码块
+        content_str = "\n```\n\n"
+        yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': content_str}, 'finish_reason': None}]})}\n\n"
+        
+        # 添加生成的图片URLs
+        for i, url in enumerate(image_urls):
+            if i > 0:
+                content_str = "\n\n"
+                yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': content_str}, 'finish_reason': None}]})}\n\n"
+            
+            image_markdown = f"![Generated Image]({url})"
+            yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': image_markdown}, 'finish_reason': None}]})}\n\n"
+        
+        # 发送完成事件
+        yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {}, 'finish_reason': 'stop'}]})}\n\n"
+        
+        # 发送结束标志
+        yield "data: [DONE]\n\n"
+    except Exception as e:
+        error_msg = f"图像生成失败: {str(e)}"
+        logger.error(f"[流式响应 {request_id}] 错误: {error_msg}")
+        if logger.isEnabledFor(logging.DEBUG):
+            import traceback
+            logger.debug(traceback.format_exc())
+        error_content = f"\n{error_msg}\n```"
+        yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': error_content}, 'finish_reason': 'error'}]})}\n\n"
+        yield "data: [DONE]\n\n"
+
+# 流式响应生成器 - 带图片的remix
+async def generate_streaming_remix_response(
+    sora_client: SoraClient,
+    prompt: str,
+    image_data: str,
+    n_images: int = 1
+):
+    request_id = f"chatcmpl-{uuid.uuid4().hex}"
+    
+    # 发送开始事件
+    yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'role': 'assistant'}, 'finish_reason': None}]})}\n\n"
+    
+    try:
+        # 保存base64图片到临时文件
+        temp_dir = tempfile.mkdtemp()
+        temp_image_path = os.path.join(temp_dir, f"upload_{uuid.uuid4()}.png")
+        
+        try:
+            # 解码并保存图片
+            with open(temp_image_path, "wb") as f:
+                f.write(base64.b64decode(image_data))
+            
+            # 上传图片
+            upload_msg = "```think\n上传图片中...\n"
+            yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': upload_msg}, 'finish_reason': None}]})}\n\n"
+            
+            logger.info(f"[流式响应Remix {request_id}] 上传图片中")
+            upload_result = await sora_client.upload_image(temp_image_path)
+            media_id = upload_result['id']
+            
+            # 发送生成中消息
+            generate_msg = "\n基于图片生成新图像中...\n"
+            yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': generate_msg}, 'finish_reason': None}]})}\n\n"
+            
+            # 创建一个后台任务来生成图像
+            logger.info(f"[流式响应Remix {request_id}] 开始生成图像，提示词: {prompt}")
+            generation_task = asyncio.create_task(sora_client.generate_image_remix(
+                prompt=prompt,
+                media_id=media_id,
+                num_images=n_images
+            ))
+            
+            # 每5秒发送一条"仍在生成中"的消息，防止连接超时
+            progress_messages = [
+                "正在处理您的请求...",
+                "仍在生成图像中，请继续等待...",
+                "Sora正在基于您的图片创作新作品...",
+                "图像生成需要一点时间，感谢您的耐心等待...",
+                "正在努力融合您的风格和提示词，打造专属图像..."
+            ]
+            
+            i = 0
+            while not generation_task.done():
+                # 每5秒发送一次进度消息
+                await asyncio.sleep(5)
+                progress_msg = progress_messages[i % len(progress_messages)]
+                i += 1
+                content = "\n" + progress_msg + "\n"
+                yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': content}, 'finish_reason': None}]})}\n\n"
+            
+            # 获取生成结果
+            image_urls = await generation_task
+            logger.info(f"[流式响应Remix {request_id}] 图像生成完成")
+            
+            # 本地化图片URL
+            if Config.IMAGE_LOCALIZATION:
+                logger.info(f"[流式响应Remix {request_id}] 进行图片本地化处理")
+                localized_urls = await localize_image_urls(image_urls)
+                image_urls = localized_urls
+                logger.info(f"[流式响应Remix {request_id}] 图片本地化处理完成")
+            else:
+                logger.info(f"[流式响应Remix {request_id}] 图片本地化功能未启用")
+            
+            # 结束代码块
+            content_str = "\n```\n\n"
+            yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': content_str}, 'finish_reason': None}]})}\n\n"
+            
+            # 发送图片URL作为Markdown
+            for i, url in enumerate(image_urls):
+                if i > 0:
+                    newline_str = "\n\n"
+                    yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': newline_str}, 'finish_reason': None}]})}\n\n"
+                
+                image_markdown = f"![Generated Image]({url})"
+                yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': image_markdown}, 'finish_reason': None}]})}\n\n"
+            
+            # 发送完成事件
+            yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {}, 'finish_reason': 'stop'}]})}\n\n"
+            
+            # 发送结束标志
+            yield "data: [DONE]\n\n"
+            
+        finally:
+            # 清理临时文件
+            if os.path.exists(temp_image_path):
+                os.remove(temp_image_path)
+            if os.path.exists(temp_dir):
+                os.rmdir(temp_dir)
+                
+    except Exception as e:
+        error_msg = f"图像Remix失败: {str(e)}"
+        logger.error(f"[流式响应Remix {request_id}] 错误: {error_msg}")
+        if logger.isEnabledFor(logging.DEBUG):
+            import traceback
+            logger.debug(traceback.format_exc())
+        error_content = f"\n{error_msg}\n```"
+        yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': error_content}, 'finish_reason': 'error'}]})}\n\n"
+    
+    # 结束流
+    yield "data: [DONE]\n\n"
+
+# API密钥管理端点
+@app.get("/api/keys")
+async def get_all_keys(admin_key: str = Depends(verify_admin)):
+    """获取所有API密钥"""
+    return key_manager.get_all_keys()
+
+@app.get("/api/keys/{key_id}")
+async def get_key(key_id: str, admin_key: str = Depends(verify_admin)):
+    """获取单个API密钥详情"""
+    key = key_manager.get_key_by_id(key_id)
+    if not key:
+        raise HTTPException(status_code=404, detail="密钥不存在")
+    return key
+
+@app.post("/api/keys")
+async def create_key(key_data: ApiKeyCreate, admin_key: str = Depends(verify_admin)):
+    """创建新API密钥"""
+    try:
+        # 确保密钥值包含 Bearer 前缀
+        key_value = key_data.key_value
+        if not key_value.startswith("Bearer "):
+            key_value = f"Bearer {key_value}"
+            
+        new_key = key_manager.add_key(
+            key_value,
+            name=key_data.name,
+            weight=key_data.weight,
+            rate_limit=key_data.rate_limit,
+            is_enabled=key_data.is_enabled,
+            notes=key_data.notes
+        )
+        
+        # 通过Config永久保存所有密钥
+        Config.save_api_keys(key_manager.keys)
+        
+        return new_key
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@app.put("/api/keys/{key_id}")
+async def update_key(key_id: str, key_data: ApiKeyUpdate, admin_key: str = Depends(verify_admin)):
+    """更新API密钥信息"""
+    try:
+        # 如果提供了新的密钥值，确保包含Bearer前缀
+        key_value = key_data.key_value
+        if key_value and not key_value.startswith("Bearer "):
+            key_value = f"Bearer {key_value}"
+            key_data.key_value = key_value
+            
+        updated_key = key_manager.update_key(
+            key_id,
+            key_value=key_data.key_value,
+            name=key_data.name,
+            weight=key_data.weight,
+            rate_limit=key_data.rate_limit,
+            is_enabled=key_data.is_enabled,
+            notes=key_data.notes
+        )
+        if not updated_key:
+            raise HTTPException(status_code=404, detail="密钥不存在")
+        
+        # 通过Config永久保存所有密钥
+        Config.save_api_keys(key_manager.keys)
+        
+        return updated_key
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@app.delete("/api/keys/{key_id}")
+async def delete_key(key_id: str, admin_key: str = Depends(verify_admin)):
+    """删除API密钥"""
+    success = key_manager.delete_key(key_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="密钥不存在")
+    
+    # 通过Config永久保存所有密钥
+    Config.save_api_keys(key_manager.keys)
+    
+    return {"status": "success", "message": "密钥已删除"}
+
+@app.get("/api/stats")
+async def get_usage_stats(admin_key: str = Depends(verify_admin)):
+    """获取API使用统计"""
+    return key_manager.get_usage_stats()
+
+@app.post("/api/keys/test")
+async def test_key(key_data: ApiKeyCreate, admin_key: str = Depends(verify_admin)):
+    """测试API密钥是否有效"""
+    try:
+        # 确保密钥值包含 Bearer 前缀
+        key_value = key_data.key_value
+        if not key_value.startswith("Bearer "):
+            key_value = f"Bearer {key_value}"
+        
+        # 获取代理配置
+        proxy_host = Config.PROXY_HOST if Config.PROXY_HOST and Config.PROXY_HOST.strip() else None
+        proxy_port = Config.PROXY_PORT if Config.PROXY_PORT and Config.PROXY_PORT.strip() else None
+        
+        # 创建临时客户端测试连接
+        test_client = SoraClient(
+            proxy_host=proxy_host,
+            proxy_port=proxy_port,
+            auth_token=key_value
+        )
+        # 执行简单API调用测试连接
+        test_result = await test_client.test_connection()
+        return {"status": "success", "message": "API密钥测试成功", "details": test_result}
+    except Exception as e:
+        return {"status": "error", "message": f"API密钥测试失败: {str(e)}"}
+
+@app.post("/api/keys/batch")
+async def batch_operation(operation: Dict[str, Any], admin_key: str = Depends(verify_admin)):
+    """批量操作API密钥"""
+    action = operation.get("action")
+    key_ids = operation.get("key_ids", [])
+    
+    if not action or not key_ids:
+        raise HTTPException(status_code=400, detail="无效的请求参数")
+    
+    # 确保key_ids是一个列表
+    if isinstance(key_ids, str):
+        key_ids = [key_ids]
+    
+    results = {}
+    
+    if action == "enable":
+        for key_id in key_ids:
+            success = key_manager.update_key(key_id, is_enabled=True)
+            results[key_id] = "success" if success else "failed"
+    elif action == "disable":
+        for key_id in key_ids:
+            success = key_manager.update_key(key_id, is_enabled=False)
+            results[key_id] = "success" if success else "failed"
+    elif action == "delete":
+        for key_id in key_ids:
+            success = key_manager.delete_key(key_id)
+            results[key_id] = "success" if success else "failed"
+    else:
+        raise HTTPException(status_code=400, detail="不支持的操作类型")
+    
+    # 通过Config永久保存所有密钥
+    Config.save_api_keys(key_manager.keys)
+    
+    return {"status": "success", "results": results}
+
+# 健康检查端点
+@app.get("/health")
+async def health_check():
+    return {"status": "ok", "timestamp": time.time()}
+
+# 管理界面路由
+@app.get("/admin")
+async def admin_panel():
+    return FileResponse(os.path.join(Config.STATIC_DIR, "admin/index.html"))
+
+# 管理员密钥API
+@app.get("/admin/key")
+async def admin_key():
+    return {"admin_key": Config.ADMIN_KEY}
+
+# 挂载静态文件
+app.mount("/admin", StaticFiles(directory=os.path.join(Config.STATIC_DIR, "admin"), html=True), name="admin")
+
+# 配置管理模型
+class ConfigUpdate(BaseModel):
+    IMAGE_LOCALIZATION: Optional[bool] = None
+    IMAGE_SAVE_DIR: Optional[str] = None
+    LOG_LEVEL: Optional[str] = None
+
+# 配置管理页面
+@app.get("/admin/config")
+async def config_panel():
+    return FileResponse("src/static/admin/config.html")
+
+# 获取当前配置
+@app.get("/api/config")
+async def get_config(admin_key: str = Depends(verify_admin)):
+    """获取当前系统配置"""
+    return {
+        "IMAGE_LOCALIZATION": Config.IMAGE_LOCALIZATION,
+        "IMAGE_SAVE_DIR": Config.IMAGE_SAVE_DIR,
+        "LOG_LEVEL": LogConfig.LEVEL
+    }
+
+# 更新配置
+@app.post("/api/config")
+async def update_config(config_data: ConfigUpdate, admin_key: str = Depends(verify_admin)):
+    """更新系统配置"""
+    changes = {}
+    
+    if config_data.IMAGE_LOCALIZATION is not None:
+        old_value = Config.IMAGE_LOCALIZATION
+        Config.IMAGE_LOCALIZATION = config_data.IMAGE_LOCALIZATION
+        os.environ["IMAGE_LOCALIZATION"] = str(config_data.IMAGE_LOCALIZATION)
+        changes["IMAGE_LOCALIZATION"] = {
+            "old": old_value,
+            "new": Config.IMAGE_LOCALIZATION
+        }
+    
+    if config_data.IMAGE_SAVE_DIR is not None:
+        old_value = Config.IMAGE_SAVE_DIR
+        Config.IMAGE_SAVE_DIR = config_data.IMAGE_SAVE_DIR
+        os.environ["IMAGE_SAVE_DIR"] = config_data.IMAGE_SAVE_DIR
+        
+        # 确保目录存在
+        os.makedirs(Config.IMAGE_SAVE_DIR, exist_ok=True)
+        
+        changes["IMAGE_SAVE_DIR"] = {
+            "old": old_value,
+            "new": Config.IMAGE_SAVE_DIR
+        }
+    
+    if config_data.LOG_LEVEL is not None:
+        old_value = LogConfig.LEVEL
+        level = config_data.LOG_LEVEL.upper()
+        # 验证日志级别是否有效
+        valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+        if level not in valid_levels:
+            raise HTTPException(status_code=400, detail=f"无效的日志级别，有效值：{', '.join(valid_levels)}")
+            
+        # 更新日志级别
+        LogConfig.LEVEL = level
+        logging.getLogger("sora-api").setLevel(getattr(logging, level))
+        os.environ["LOG_LEVEL"] = level
+        
+        changes["LOG_LEVEL"] = {
+            "old": old_value,
+            "new": level
+        }
+        
+        logger.info(f"日志级别已更改为: {level}")
+    
+    # 保存到.env文件以持久化配置
+    try:
+        dotenv_file = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), ".env")
+        
+        # 读取现有.env文件
+        env_vars = {}
+        if os.path.exists(dotenv_file):
+            with open(dotenv_file, "r") as f:
+                for line in f:
+                    if line.strip() and not line.startswith("#"):
+                        key, value = line.strip().split("=", 1)
+                        env_vars[key] = value
+        
+        # 更新值
+        if config_data.IMAGE_LOCALIZATION is not None:
+            env_vars["IMAGE_LOCALIZATION"] = str(config_data.IMAGE_LOCALIZATION)
+        if config_data.IMAGE_SAVE_DIR is not None:
+            env_vars["IMAGE_SAVE_DIR"] = config_data.IMAGE_SAVE_DIR
+        if config_data.LOG_LEVEL is not None:
+            env_vars["LOG_LEVEL"] = config_data.LOG_LEVEL.upper()
+        
+        # 写回文件
+        with open(dotenv_file, "w") as f:
+            for key, value in env_vars.items():
+                f.write(f"{key}={value}\n")
+    except Exception as e:
+        logger.error(f"保存配置到.env文件失败: {str(e)}")
+    
+    return {
+        "success": True,
+        "message": "配置已更新",
+        "changes": changes
+    }
+
+# 日志级别控制
+class LogLevelUpdate(BaseModel):
+    level: str = Field(..., description="日志级别")
+
+@app.post("/api/logs/level")
+async def update_log_level(data: LogLevelUpdate, admin_key: str = Depends(verify_admin)):
+    """更新系统日志级别"""
+    level = data.level.upper()
+    
+    # 验证日志级别是否有效
+    valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+    if level not in valid_levels:
+        raise HTTPException(status_code=400, detail=f"无效的日志级别，有效值：{', '.join(valid_levels)}")
+        
+    # 更新日志级别
+    old_level = LogConfig.LEVEL
+    LogConfig.LEVEL = level
+    logging.getLogger("sora-api").setLevel(getattr(logging, level))
+    os.environ["LOG_LEVEL"] = level
+    
+    # 记录变更
+    logger.info(f"日志级别已更改为: {level}")
+    
+    # 更新.env文件
+    try:
+        dotenv_file = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), ".env")
+        
+        # 读取现有.env文件
+        env_vars = {}
+        if os.path.exists(dotenv_file):
+            with open(dotenv_file, "r") as f:
+                for line in f:
+                    if line.strip() and not line.startswith("#"):
+                        key, value = line.strip().split("=", 1)
+                        env_vars[key] = value
+                        
+        # 更新日志级别
+        env_vars["LOG_LEVEL"] = level
+        
+        # 写回文件
+        with open(dotenv_file, "w") as f:
+            for key, value in env_vars.items():
+                f.write(f"{key}={value}\n")
+    except Exception as e:
+        logger.warning(f"保存日志级别到.env文件失败: {str(e)}")
+    
+    return {
+        "success": True,
+        "message": f"日志级别已更改: {old_level} -> {level}"
+    } 

src/app.py.optimized

@@ -0,0 +1,129 @@
+import os
+import aiohttp
+import logging
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import JSONResponse, FileResponse
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.exceptions import RequestValidationError
+
+from .config import Config
+from .key_manager import KeyManager
+from .api import main_router
+from .api.dependencies import session_pool
+
+# 配置日志
+logging.basicConfig(
+    level=getattr(logging, os.getenv("LOG_LEVEL", "INFO").upper()),
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S"
+)
+
+logger = logging.getLogger("sora-api")
+
+# 全局键管理器
+key_manager = KeyManager(storage_file=Config.KEYS_STORAGE_FILE)
+
+# 创建FastAPI应用
+app = FastAPI(
+    title="OpenAI Compatible Sora API",
+    description="为Sora提供OpenAI兼容接口的API服务",
+    version="2.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc",
+)
+
+# 配置CORS中间件
+origins = [
+    "http://localhost",
+    "http://localhost:8890",
+    f"http://{Config.HOST}:{Config.PORT}",
+    Config.BASE_URL,
+]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "PUT", "DELETE"],
+    allow_headers=["Authorization", "Content-Type"],
+)
+
+# 异常处理
+@app.exception_handler(RequestValidationError)
+async def validation_exception_handler(request: Request, exc: RequestValidationError):
+    """处理请求验证错误"""
+    return JSONResponse(
+        status_code=422,
+        content={"detail": f"请求验证错误: {str(exc)}"}
+    )
+
+@app.exception_handler(Exception)
+async def global_exception_handler(request: Request, exc: Exception):
+    """全局异常处理器"""
+    # 记录错误
+    logger.error(f"全局异常: {str(exc)}", exc_info=True)
+    
+    # 如果是已知的HTTPException，保持原始状态码和详情
+    if isinstance(exc, HTTPException):
+        return JSONResponse(
+            status_code=exc.status_code,
+            content={"detail": exc.detail}
+        )
+    
+    # 其他异常返回500状态码
+    return JSONResponse(
+        status_code=500,
+        content={"detail": f"服务器内部错误: {str(exc)}"}
+    )
+
+# 应用启动和关闭事件
+@app.on_event("startup")
+async def startup_event():
+    """应用启动时执行的操作"""
+    global session_pool
+    # 创建共享会话池
+    session_pool = aiohttp.ClientSession()
+    logger.info("应用已启动，创建了全局会话池")
+    
+    # 初始化时保存管理员密钥
+    Config.save_admin_key()
+    
+    # 确保静态文件目录存在
+    os.makedirs(os.path.join(Config.STATIC_DIR, "admin"), exist_ok=True)
+    os.makedirs(os.path.join(Config.STATIC_DIR, "admin/js"), exist_ok=True)
+    os.makedirs(os.path.join(Config.STATIC_DIR, "admin/css"), exist_ok=True)
+    os.makedirs(os.path.join(Config.STATIC_DIR, "images"), exist_ok=True)
+    
+    # 打印配置信息
+    Config.print_config()
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """应用关闭时执行的操作"""
+    # 关闭会话池
+    if session_pool:
+        await session_pool.close()
+    logger.info("应用已关闭，清理了全局会话池")
+
+# 挂载静态文件目录
+app.mount("/static", StaticFiles(directory=Config.STATIC_DIR), name="static")
+
+# 管理界面路由
+@app.get("/admin")
+async def admin_panel():
+    """返回管理面板HTML页面"""
+    return FileResponse(os.path.join(Config.STATIC_DIR, "admin/index.html"))
+
+# 注册所有API路由
+app.include_router(main_router)
+
+# 应用入口点（供uvicorn直接调用）
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(
+        "app:app",
+        host=Config.HOST,
+        port=Config.PORT,
+        reload=Config.VERBOSE_LOGGING
+    ) 

src/config.py

@@ -0,0 +1,179 @@
+import os
+import json
+import uuid
+from typing import List, Dict
+import logging
+
+logger = logging.getLogger("sora-api.config")
+
+class Config:
+    # API服务配置
+    HOST = os.getenv("API_HOST", "0.0.0.0")
+    PORT = int(os.getenv("API_PORT", "8890"))
+    
+    # 基础URL配置
+    BASE_URL = os.getenv("BASE_URL", f"http://0.0.0.0:{PORT}")
+    
+    # 静态文件路径前缀，用于处理应用部署在子路径的情况
+    # 例如: /sora-api 表示应用部署在 /sora-api 下
+    STATIC_PATH_PREFIX = os.getenv("STATIC_PATH_PREFIX", "")
+    
+    # 代理配置
+    PROXY_HOST = os.getenv("PROXY_HOST", "")
+    PROXY_PORT = os.getenv("PROXY_PORT", "")
+    PROXY_USER = os.getenv("PROXY_USER", "")
+    PROXY_PASS = os.getenv("PROXY_PASS", "")
+    
+    # 目录配置
+    ROOT_DIR = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
+    BASE_DIR = ROOT_DIR
+    STATIC_DIR = os.getenv("STATIC_DIR", os.path.join(BASE_DIR, "src/static"))
+    
+    # 图片保存目录 - 用户只需设置这一项
+    IMAGE_SAVE_DIR = os.getenv("IMAGE_SAVE_DIR", os.path.join(STATIC_DIR, "images"))
+    
+    # 图片本地化配置
+    IMAGE_LOCALIZATION = os.getenv("IMAGE_LOCALIZATION", "False").lower() in ("true", "1", "yes")
+    
+    # 当外部访问地址与服务器地址不同时，可通过BASE_URL覆盖图片访问地址
+    # 例如：当服务器在内网，但通过反向代理从外网访问时
+    
+    # API Keys配置
+    API_KEYS = []
+    
+    # 管理员配置
+    ADMIN_KEY = os.getenv("ADMIN_KEY", "sk-123456")
+    KEYS_STORAGE_FILE = os.getenv("KEYS_STORAGE_FILE", "api_keys.json")
+    
+    # API认证令牌
+    API_AUTH_TOKEN = os.getenv("API_AUTH_TOKEN", "")
+    
+    # 日志配置
+    VERBOSE_LOGGING = os.getenv("VERBOSE_LOGGING", "False").lower() in ("true", "1", "yes")
+    
+    @classmethod
+    def print_config(cls):
+        """打印当前配置信息"""
+        print("\n==== Sora API 配置信息 ====")
+        print(f"基础目录: {cls.BASE_DIR}")
+        print(f"API服务地址: {cls.HOST}:{cls.PORT}")
+        print(f"基础URL: {cls.BASE_URL}")
+        
+        # API认证信息
+        if cls.API_AUTH_TOKEN:
+            print(f"API认证令牌: 已设置 (长度: {len(cls.API_AUTH_TOKEN)})")
+        else:
+            print(f"API认证令牌: 未设置 (将使用管理面板的key)")
+        
+        # 详细日志
+        if cls.VERBOSE_LOGGING:
+            print(f"静态文件目录: {cls.STATIC_DIR}")
+            print(f"图片保存目录: {cls.IMAGE_SAVE_DIR}")
+            print(f"图片本地化: {'启用' if cls.IMAGE_LOCALIZATION else '禁用'}")
+            
+            # 代理配置信息
+            if cls.PROXY_HOST:
+                proxy_info = f"{cls.PROXY_HOST}:{cls.PROXY_PORT}"
+                if cls.PROXY_USER:
+                    proxy_info = f"{cls.PROXY_USER}:****@{proxy_info}"
+                print(f"代理配置: {proxy_info}")
+            else:
+                print(f"代理配置: (未配置)")
+        
+        # 确保必要目录存在
+        cls._ensure_directories()
+        
+    @classmethod
+    def _ensure_directories(cls):
+        """确保必要的目录存在"""
+        # 检查静态文件目录
+        if not os.path.exists(cls.STATIC_DIR):
+            print(f"⚠️ 警告: 静态文件目录不存在: {cls.STATIC_DIR}")
+        elif cls.VERBOSE_LOGGING:
+            print(f"✅ 静态文件目录存在")
+            
+        # 检查并创建图片保存目录
+        if not os.path.exists(cls.IMAGE_SAVE_DIR):
+            try:
+                os.makedirs(cls.IMAGE_SAVE_DIR, exist_ok=True)
+                if cls.VERBOSE_LOGGING:
+                    print(f"✅ 已创建图片保存目录: {cls.IMAGE_SAVE_DIR}")
+            except Exception as e:
+                print(f"❌ 创建图片保存目录失败: {str(e)}")
+        elif cls.VERBOSE_LOGGING:
+            print(f"✅ 图片保存目录存在")
+            
+            # 测试写入权限
+            try:
+                test_file = os.path.join(cls.IMAGE_SAVE_DIR, '.test_write')
+                with open(test_file, 'w') as f:
+                    f.write('test')
+                os.remove(test_file)
+                print(f"✅ 图片保存目录有写入权限")
+            except Exception as e:
+                print(f"❌ 图片保存目录没有写入权限: {str(e)}")
+    
+    @classmethod
+    def load_api_keys(cls):
+        """加载API密钥"""
+        # 先从环境变量加载
+        api_keys_str = os.getenv("API_KEYS", "")
+        if api_keys_str:
+            try:
+                cls.API_KEYS = json.loads(api_keys_str)
+                if cls.VERBOSE_LOGGING:
+                    logger.info(f"已从环境变量加载 {len(cls.API_KEYS)} 个API keys")
+                return
+            except json.JSONDecodeError as e:
+                logger.error(f"解析环境变量API keys失败: {e}")
+                
+        # 再从文件加载
+        try:
+            if os.path.exists(cls.KEYS_STORAGE_FILE):
+                with open(cls.KEYS_STORAGE_FILE, "r", encoding="utf-8") as f:
+                    keys_data = json.load(f)
+                    if isinstance(keys_data, dict) and "keys" in keys_data:
+                        cls.API_KEYS = [k for k in keys_data["keys"] if k.get("key")]
+                    else:
+                        cls.API_KEYS = keys_data
+                    
+                    if cls.VERBOSE_LOGGING:
+                        logger.info(f"已从文件加载 {len(cls.API_KEYS)} 个API keys")
+        except Exception as e:
+            logger.error(f"从文件加载API keys失败: {e}") 
+    
+    @classmethod
+    def save_api_keys(cls, keys_data):
+        """保存API密钥到文件"""
+        try:
+            keys_storage_file = os.path.join(cls.BASE_DIR, cls.KEYS_STORAGE_FILE)
+            
+            with open(keys_storage_file, "w", encoding="utf-8") as f:
+                if isinstance(keys_data, list):
+                    json.dump({"keys": keys_data}, f, ensure_ascii=False, indent=2)
+                else:
+                    json.dump(keys_data, f, ensure_ascii=False, indent=2)
+            
+            # 更新内存中的keys
+            if isinstance(keys_data, dict) and "keys" in keys_data:
+                cls.API_KEYS = [k for k in keys_data["keys"] if k.get("key")]
+            else:
+                cls.API_KEYS = keys_data
+                
+            if cls.VERBOSE_LOGGING:
+                logger.info(f"API keys已保存至 {keys_storage_file}")
+        except Exception as e:
+            logger.error(f"保存API keys失败: {e}")
+    
+    @classmethod
+    def save_admin_key(cls):
+        """保存管理员密钥到文件"""
+        try:
+            admin_config_file = os.path.join(cls.BASE_DIR, "admin_config.json")
+            with open(admin_config_file, "w", encoding="utf-8") as f:
+                json.dump({"admin_key": cls.ADMIN_KEY}, f, indent=2)
+            
+            if cls.VERBOSE_LOGGING:
+                logger.info(f"管理员密钥已保存至 {admin_config_file}")
+        except Exception as e:
+            logger.error(f"保存管理员密钥失败: {e}") 

src/key_manager.py

@@ -0,0 +1,777 @@
+import time
+import random
+import uuid
+import json
+import os
+import logging
+import threading
+from typing import Dict, List, Optional, Any, Union, Tuple, Callable
+
+# 初始化日志
+logger = logging.getLogger("sora-api.key_manager")
+
+class KeyManager:
+    def __init__(self, storage_file: str = "api_keys.json"):
+        """
+        初始化密钥管理器
+        
+        Args:
+            storage_file: 密钥存储文件路径
+        """
+        self.keys = []  # 密钥列表
+        self.storage_file = storage_file
+        self.usage_stats = {}  # 使用统计
+        self._lock = threading.RLock()  # 添加可重入锁以支持并发访问
+        self._working_keys = {}  # 新增：记录正在工作中的密钥 {key_value: task_id}
+        self._load_keys()
+        
+    def _load_keys(self) -> None:
+        """从环境变量或文件加载密钥"""
+        keys_loaded = False
+        
+        # 先尝试从环境变量加载
+        api_keys_str = os.getenv("API_KEYS", "")
+        if api_keys_str:
+            try:
+                env_data = json.loads(api_keys_str)
+                self._process_keys_data(env_data)
+                if len(self.keys) > 0:
+                    logger.info(f"已从环境变量加载 {len(self.keys)} 个密钥")
+                    keys_loaded = True
+                else:
+                    logger.warning("环境变量API_KEYS存在但未包含有效密钥")
+            except json.JSONDecodeError as e:
+                logger.error(f"解析环境变量API keys失败: {str(e)}")
+        
+            # 如果环境变量未设置、解析失败或未加载到密钥，从文件加载
+        if not keys_loaded:
+            try:
+                if os.path.exists(self.storage_file):
+                    logger.info(f"尝试从文件加载密钥: {self.storage_file}")
+                    with open(self.storage_file, 'r', encoding='utf-8') as f:
+                        data = json.load(f)
+                        keys_before = len(self.keys)
+                        self._process_keys_data(data)
+                        keys_loaded = len(self.keys) > keys_before
+                        logger.info(f"已从文件加载 {len(self.keys) - keys_before} 个密钥")
+                else:
+                    logger.warning(f"密钥文件不存在: {self.storage_file}")
+            except Exception as e:
+                logger.error(f"加载密钥失败: {str(e)}")
+                
+        if len(self.keys) == 0:
+            logger.warning("未能从环境变量或文件加载任何密钥")
+
+        
+    def _process_keys_data(self, data):
+        """处理不同格式的密钥数据"""
+        # 处理不同的数据格式
+        if isinstance(data, list):
+            # 旧版格式：直接是密钥列表
+            raw_keys = data
+            self.keys = []
+            self.usage_stats = {}
+            
+            # 为每个密钥创建完整的记录
+            for key_info in raw_keys:
+                if isinstance(key_info, dict):
+                    key_value = key_info.get("key")
+                    if not key_value:
+                        logger.warning(f"忽略无效密钥配置: {key_info}")
+                        continue
+                        
+                    # 确保有ID
+                    key_id = key_info.get("id") or str(uuid.uuid4())
+                    
+                    # 构建完整的密钥记录
+                    key_record = {
+                        "id": key_id,
+                        "name": key_info.get("name", ""),
+                        "key": key_value,
+                        "weight": key_info.get("weight", 1),
+                        "max_rpm": key_info.get("max_rpm", 60),
+                        "requests": 0,
+                        "last_reset": time.time(),
+                        "available": key_info.get("is_enabled", True),
+                        "is_enabled": key_info.get("is_enabled", True),
+                        "created_at": key_info.get("created_at", time.time()),
+                        "last_used": key_info.get("last_used"),
+                        "notes": key_info.get("notes")
+                    }
+                    
+                    self.keys.append(key_record)
+                    
+                    # 初始化使用统计
+                    self.usage_stats[key_id] = {
+                        "total_requests": 0,
+                        "successful_requests": 0,
+                        "failed_requests": 0,
+                        "daily_usage": {},
+                        "average_response_time": 0
+                    }
+                elif isinstance(key_info, str):
+                    # 如果是字符串，直接作为密钥值
+                    key_id = str(uuid.uuid4())
+                    self.keys.append({
+                        "id": key_id,
+                        "name": "",
+                        "key": key_info,
+                        "weight": 1,
+                        "max_rpm": 60,
+                        "requests": 0,
+                        "last_reset": time.time(),
+                        "available": True,
+                        "is_enabled": True,
+                        "created_at": time.time(),
+                        "last_used": None,
+                        "notes": None
+                    })
+                    
+                    # 初始化使用统计
+                    self.usage_stats[key_id] = {
+                        "total_requests": 0,
+                        "successful_requests": 0,
+                        "failed_requests": 0,
+                        "daily_usage": {},
+                        "average_response_time": 0
+                    }
+        else:
+            # 新版格式：包含keys和usage_stats的字典
+            self.keys = data.get('keys', [])
+            self.usage_stats = data.get('usage_stats', {})
+    
+    def _save_keys(self) -> None:
+        """保存密钥到文件"""
+        try:
+            with open(self.storage_file, 'w', encoding='utf-8') as f:
+                json.dump({
+                    'keys': self.keys,
+                    'usage_stats': self.usage_stats
+                }, f, ensure_ascii=False, indent=2)
+                
+            # 同时更新Config中的API_KEYS
+            try:
+                from .config import Config
+                Config.API_KEYS = self.keys
+            except (ImportError, AttributeError):
+                logger.debug("无法更新Config中的API_KEYS")
+        except Exception as e:
+            logger.error(f"保存密钥失败: {str(e)}")
+            
+    def add_key(self, key_value: str, name: str = "", weight: int = 1, 
+                rate_limit: int = 60, is_enabled: bool = True, notes: str = None) -> Dict[str, Any]:
+        """
+        添加密钥
+        
+        Args:
+            key_value: 密钥值
+            name: 密钥名称
+            weight: 权重
+            rate_limit: 速率限制(每分钟请求数)
+            is_enabled: 是否启用
+            notes: 备注
+            
+        Returns:
+            添加的密钥信息
+        """
+        with self._lock:  # 使用锁保护添加过程
+            # 检查密钥是否已存在
+            for key in self.keys:
+                if key.get("key") == key_value:
+                    return key
+            
+            key_id = str(uuid.uuid4())
+            new_key = {
+                "id": key_id,
+                "name": name,
+                "key": key_value,
+                "weight": weight,
+                "max_rpm": rate_limit,
+                "requests": 0,
+                "last_reset": time.time(),
+                "available": is_enabled,
+                "is_enabled": is_enabled,
+                "created_at": time.time(),
+                "last_used": None,
+                "notes": notes
+            }
+            self.keys.append(new_key)
+            
+            # 初始化使用统计
+            self.usage_stats[key_id] = {
+                "total_requests": 0,
+                "successful_requests": 0,
+                "failed_requests": 0,
+                "daily_usage": {},
+                "average_response_time": 0
+            }
+            
+            self._save_keys()
+            logger.info(f"已添加密钥: {name or key_id}")
+            return new_key
+    
+    def get_all_keys(self) -> List[Dict[str, Any]]:
+        """获取所有密钥信息（已隐藏完整密钥值）"""
+        with self._lock:  # 使用锁保护读取过程
+            result = []
+            for key in self.keys:
+                key_copy = key.copy()
+                if "key" in key_copy:
+                    # 只显示密钥前6位和后4位
+                    full_key = key_copy["key"]
+                    if len(full_key) > 10:
+                        key_copy["key"] = full_key[:6] + "..." + full_key[-4:]
+                
+                # 增加临时禁用信息的处理
+                if key_copy.get("temp_disabled_until"):
+                    temp_disabled_until = key_copy["temp_disabled_until"]
+                    # 确保temp_disabled_until是时间戳格式
+                    if isinstance(temp_disabled_until, (int, float)):
+                        # 转换为可读格式，但保留原始时间戳，让前端可以自行处理
+                        disabled_until_date = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(temp_disabled_until))
+                        key_copy["temp_disabled_until_formatted"] = disabled_until_date
+                        key_copy["temp_disabled_remaining"] = int(temp_disabled_until - time.time())
+                
+                result.append(key_copy)
+            return result
+    
+    def get_key_by_id(self, key_id: str) -> Optional[Dict[str, Any]]:
+        """根据ID获取密钥信息"""
+        with self._lock:  # 使用锁保护读取过程
+            for key in self.keys:
+                if key.get("id") == key_id:
+                    return key
+            return None
+    
+    def update_key(self, key_id: str, **kwargs) -> Optional[Dict[str, Any]]:
+        """
+        更新密钥信息
+        
+        Args:
+            key_id: 密钥ID
+            **kwargs: 要更新的字段
+            
+        Returns:
+            更新后的密钥信息，未找到则返回None
+        """
+        with self._lock:  # 使用锁保护更新过程
+            for key in self.keys:
+                if key.get("id") == key_id:
+                    # 更新提供的字段
+                    for field, value in kwargs.items():
+                        if value is not None:
+                            if field == "is_enabled":
+                                key["available"] = value  # 同步更新available字段
+                            key[field] = value
+                    
+                    self._save_keys()
+                    logger.info(f"已更新密钥: {key.get('name') or key_id}")
+                    return key
+            
+            logger.warning(f"未找到密钥: {key_id}")
+            return None
+    
+    def delete_key(self, key_id: str) -> bool:
+        """
+        删除密钥
+        
+        Args:
+            key_id: 密钥ID
+            
+        Returns:
+            是否成功删除
+        """
+        with self._lock:  # 使用锁保护删除过程
+            original_length = len(self.keys)
+            self.keys = [key for key in self.keys if key.get("id") != key_id]
+            
+            # 如果成功删除，保存密钥
+            if len(self.keys) < original_length:
+                self._save_keys()
+                return True
+                
+            return False
+    
+    def batch_import_keys(self, keys_data: List[Dict[str, Any]]) -> Dict[str, int]:
+        """
+        批量导入密钥
+        
+        Args:
+            keys_data: 密钥数据列表，每个元素为包含密钥信息的字典
+            
+        Returns:
+            导入结果统计
+        """
+        with self._lock:  # 使用锁保护导入过程
+            imported_count = 0
+            skipped_count = 0
+            
+            # 获取现有密钥值
+            existing_keys = {key.get("key") for key in self.keys}
+            
+            for key_data in keys_data:
+                key_value = key_data.get("key")
+                if not key_value:
+                    continue
+                    
+                # 检查密钥是否已存在
+                if key_value in existing_keys:
+                    skipped_count += 1
+                    continue
+                    
+                # 添加新密钥
+                key_id = str(uuid.uuid4())
+                new_key = {
+                    "id": key_id,
+                    "name": key_data.get("name", ""),
+                    "key": key_value,
+                    "weight": key_data.get("weight", 1),
+                    "max_rpm": key_data.get("rate_limit", 60),
+                    "requests": 0,
+                    "last_reset": time.time(),
+                    "available": key_data.get("enabled", True),
+                    "is_enabled": key_data.get("enabled", True),
+                    "created_at": time.time(),
+                    "last_used": None,
+                    "notes": key_data.get("notes")
+                }
+                self.keys.append(new_key)
+                existing_keys.add(key_value)  # 添加到已存在集合中
+                
+                # 初始化使用统计
+                self.usage_stats[key_id] = {
+                    "total_requests": 0,
+                    "successful_requests": 0,
+                    "failed_requests": 0,
+                    "daily_usage": {},
+                    "average_response_time": 0
+                }
+                
+                imported_count += 1
+                
+            # 保存密钥
+            if imported_count > 0:
+                self._save_keys()
+                
+            return {
+                "imported": imported_count,
+                "skipped": skipped_count
+            }
+    
+    def get_key(self) -> Optional[str]:
+        """获取下一个可用的密钥"""
+        with self._lock:  # 使用锁保护整个获取密钥过程
+            if not self.keys:
+                logger.warning("没有可用的密钥")
+                return None
+                
+            # 重置计数器（如果需要）
+            current_time = time.time()
+            temporary_disabled_updated = False
+            
+            for key in self.keys:
+                # 检查是否有被临时禁用的密钥需要重新启用
+                if key.get("temp_disabled_until") and current_time > key.get("temp_disabled_until"):
+                    key["is_enabled"] = True
+                    key["available"] = True
+                    key["temp_disabled_until"] = None
+                    temporary_disabled_updated = True
+                    logger.info(f"密钥 {key.get('name') or key.get('id')} 的临时禁用已��除")
+                    
+                if current_time - key["last_reset"] >= 60:
+                    key["requests"] = 0
+                    key["last_reset"] = current_time
+                    if not key.get("temp_disabled_until"):  # 只有未被临时禁用的密钥才会被重新激活
+                        key["available"] = key.get("is_enabled", True)
+            
+            # 如果有任何临时禁用的密钥被更新，保存变更
+            if temporary_disabled_updated:
+                self._save_keys()
+            
+            # 筛选可用的密钥，排除工作中的密钥
+            available_keys = []
+            for k in self.keys:
+                key_value = k.get("key", "")
+                clean_key = key_value.replace("Bearer ", "") if key_value.startswith("Bearer ") else key_value
+                
+                # 检查此密钥是否在工作中
+                is_working = clean_key in self._working_keys
+                
+                if k.get("available", False) and not is_working:
+                    available_keys.append(k)
+            
+            if not available_keys:
+                logger.warning("没有可用的密钥（所有密钥都达到速率限制、被禁用或正在工作中）")
+                return None
+                
+            # 根据权重选择密钥
+            weights = [k.get("weight", 1) for k in available_keys]
+            selected_idx = random.choices(range(len(available_keys)), weights=weights, k=1)[0]
+            selected_key = available_keys[selected_idx]
+            
+            # 更新使用统计
+            selected_key["requests"] += 1
+            selected_key["last_used"] = current_time
+            
+            # 检查是否达到速率限制
+            if selected_key["requests"] >= selected_key.get("max_rpm", 60):
+                selected_key["available"] = False
+            
+            # 保存数据 - 并发环境下调整为每次都保存，避免状态不一致
+            # 原来是随机保存（10%的概率）
+            self._save_keys()
+            
+            # 确保返回的密钥包含"Bearer "前缀
+            key_value = selected_key["key"]
+            if not key_value.startswith("Bearer "):
+                key_value = f"Bearer {key_value}"
+            
+            return key_value
+    
+    def record_request_result(self, key: str, success: bool, response_time: float = 0) -> None:
+        """
+        记录请求结果
+        
+        Args:
+            key: 密钥值
+            success: 请求是否成功
+            response_time: 响应时间(秒)
+        """
+        if not key:
+            logger.warning("记录请求结果失败：密钥为空")
+            return
+            
+        with self._lock:  # 使用锁保护记录过程
+            # 去掉可能的Bearer前缀
+            key_for_search = key.replace("Bearer ", "") if key.startswith("Bearer ") else key
+            
+            # 查找对应的密钥ID
+            key_id = None
+            key_info = None
+            for k in self.keys:
+                stored_key = k.get("key", "").replace("Bearer ", "") if k.get("key", "").startswith("Bearer ") else k.get("key", "")
+                if stored_key == key_for_search:
+                    key_id = k.get("id")
+                    key_info = k
+                    break
+                    
+            if not key_id:
+                logger.warning(f"记录请求结果失败：未找到密钥 {key_for_search[:6]}...")
+                return
+                
+            # 初始化usage_stats如果该密钥还没有统计数据
+            if key_id not in self.usage_stats:
+                self.usage_stats[key_id] = {
+                    "total_requests": 0,
+                    "successful_requests": 0,
+                    "failed_requests": 0,
+                    "daily_usage": {},
+                    "average_response_time": 0
+                }
+                
+            # 记录请求结果
+            stats = self.usage_stats[key_id]
+            stats["total_requests"] += 1
+            
+            if success:
+                stats["successful_requests"] += 1
+            else:
+                stats["failed_requests"] += 1
+                
+            # 记录响应时间
+            if response_time > 0:
+                if stats["average_response_time"] == 0:
+                    stats["average_response_time"] = response_time
+                else:
+                    # 使用加权平均
+                    old_avg = stats["average_response_time"]
+                    total = stats["total_requests"]
+                    # 避免 total 为0或1时产生问题，尽管前面 total_requests 已经增加了
+                    if total > 0:
+                        stats["average_response_time"] = ((old_avg * (total - 1)) + response_time) / total
+                    else: # 理论上不应该发生，因为 total_requests 已经增加了
+                        stats["average_response_time"] = response_time
+                    
+            # 记录每日使用情况
+            today = time.strftime("%Y-%m-%d")
+            if today not in stats["daily_usage"]:
+                stats["daily_usage"][today] = {"successful": 0, "failed": 0} # 初始化每日统计
+            
+            # 根据成功与否更新每日统计
+            if success:
+                stats["daily_usage"][today]["successful"] += 1
+            else:
+                stats["daily_usage"][today]["failed"] += 1
+                
+            # 保留最近30天的数据
+            if len(stats["daily_usage"]) > 30:
+                # 获取所有日期并排序，然后删除最早的
+                sorted_dates = sorted(stats["daily_usage"].keys())
+                if sorted_dates: # 确保列表不为空
+                    oldest_date = sorted_dates[0]
+                    del stats["daily_usage"][oldest_date]
+                    
+            # 更新密钥的最后使用时间
+            if key_info and "last_used" in key_info:
+                key_info["last_used"] = time.time()
+                
+            # 并发环境下每次都保存，确保统计准确性
+            self._save_keys()
+    
+    def get_usage_stats(self) -> Dict[str, Any]:
+        """获取使用统计信息"""
+        with self._lock:  # 使用锁保护读取过程
+            total_keys = len(self.keys)
+            active_keys = sum(1 for k in self.keys if k.get("is_enabled", False))
+            available_keys = sum(1 for k in self.keys if k.get("available", False))
+            
+            total_requests = sum(stats.get("total_requests", 0) for stats in self.usage_stats.values())
+            successful_requests = sum(stats.get("successful_requests", 0) for stats in self.usage_stats.values())
+            
+            # 计算成功率
+            success_rate = (successful_requests / total_requests * 100) if total_requests > 0 else 0
+            
+            # 计算每个密钥的平均响应时间
+            avg_response_times = [stats.get("average_response_time", 0) for stats in self.usage_stats.values() if stats.get("average_response_time", 0) > 0]
+            overall_avg_response_time = sum(avg_response_times) / len(avg_response_times) if avg_response_times else 0
+            
+            # 获取过去7天的使用情况
+            past_7_days = {}
+            for key_id, stats in self.usage_stats.items():
+                daily_usage = stats.get("daily_usage", {})
+                for date, count_data in daily_usage.items():
+                    if date not in past_7_days:
+                        past_7_days[date] = {"successful": 0, "failed": 0}
+                    # 正确处理字典类型的count_data
+                    past_7_days[date]["successful"] += count_data.get("successful", 0)
+                    past_7_days[date]["failed"] += count_data.get("failed", 0)
+                    
+            # 只保留最近7天
+            dates = sorted(past_7_days.keys(), reverse=True)[:7]
+            past_7_days = {date: past_7_days[date] for date in dates}
+            
+            return {
+                "total_keys": total_keys,
+                "active_keys": active_keys,
+                "available_keys": available_keys,
+                "total_requests": total_requests,
+                "successful_requests": successful_requests,
+                "failed_requests": total_requests - successful_requests,
+                "success_rate": success_rate,
+                "average_response_time": overall_avg_response_time,
+                "past_7_days": past_7_days
+            } 
+
+    def mark_key_as_working(self, key: str, task_id: str) -> None:
+        """
+        将密钥标记为工作中状态
+        
+        Args:
+            key: API密钥值（可能包含Bearer前缀）
+            task_id: 关联的任务ID
+        """
+        with self._lock:
+            clean_key = key.replace("Bearer ", "") if key.startswith("Bearer ") else key
+            self._working_keys[clean_key] = task_id
+            logger.debug(f"密钥已标记为工作中，关联任务ID: {task_id}")
+    
+    def release_key(self, key: str) -> None:
+        """
+        释放工作中的密钥
+        
+        Args:
+            key: API密钥值（可能包含Bearer前缀）
+        """
+        with self._lock:
+            clean_key = key.replace("Bearer ", "") if key.startswith("Bearer ") else key
+            if clean_key in self._working_keys:
+                del self._working_keys[clean_key]
+                logger.debug(f"密钥已释放")
+    
+    def is_key_working(self, key: str) -> bool:
+        """
+        检查密钥是否正在工作中
+        
+        Args:
+            key: API密钥值（可能包含Bearer前缀）
+            
+        Returns:
+            bool: 是否在工作中
+        """
+        with self._lock:
+            clean_key = key.replace("Bearer ", "") if key.startswith("Bearer ") else key
+            return clean_key in self._working_keys
+
+    def mark_key_invalid(self, key: str) -> Optional[str]:
+        """
+        将指定的密钥标记为无效（临时禁用而不是永久禁用），并返回一个新的可用密钥
+        
+        Args:
+            key: API密钥值（可能包含Bearer前缀）
+            
+        Returns:
+            Optional[str]: 新的可用密钥，如果没有可用密钥则返回None
+        """
+        # 调用临时禁用方法，设置24小时禁用时间
+        return self.mark_key_temp_disabled(key, hours=24.0)
+        
+    def mark_key_temp_disabled(self, key: str, hours: float = 12.0) -> Optional[str]:
+        """
+        将指定的密钥临时禁用指定小时数，并返回一个新的可用密钥
+        
+        Args:
+            key: API密钥值（可能包含Bearer前缀）
+            hours: 禁用小时数
+            
+        Returns:
+            Optional[str]: 新的可用密钥，如果没有可用密钥则返回None
+        """
+        with self._lock:  # 使用锁保护临时禁用过程
+            # 去掉可能的Bearer前缀
+            key_for_search = key.replace("Bearer ", "") if key.startswith("Bearer ") else key
+            
+            # 检查是否是因为密钥在工作中导致的错误
+            if key_for_search in self._working_keys:
+                logger.warning(f"尝试禁用正在工作中的密钥（任务ID: {self._working_keys[key_for_search]}），跳过禁用操作")
+                # 获取一个新密钥返回，但不禁用当前密钥
+                new_key = self.get_key()
+                if new_key:
+                    logger.info(f"已返回新密钥，但未禁用工作中的密钥")
+                    return new_key
+                else:
+                    logger.warning("没有可用的备用密钥")
+                    return None
+            
+            # 查找对应的密钥
+            key_found = False
+            disabled_key_id = None
+            for key_info in self.keys:
+                stored_key = key_info.get("key", "").replace("Bearer ", "") if key_info.get("key", "").startswith("Bearer ") else key_info.get("key", "")
+                if stored_key == key_for_search:
+                    # 标记密钥为临时禁用
+                    disabled_until = time.time() + (hours * 3600)  # 当前时间加上禁用小时数
+                    key_info["available"] = False
+                    key_info["temp_disabled_until"] = disabled_until
+                    key_info["notes"] = (key_info.get("notes") or "") + f"\n[自动] 在 {time.strftime('%Y-%m-%d %H:%M:%S')} 被临时禁用{hours}小时"
+                    key_found = True
+                    disabled_key_id = key_info.get("id")
+                    logger.warning(f"密钥 {key_info.get('name') or key_info.get('id')} 被临时禁用{hours}小时")
+                    break
+            
+            if key_found:
+                # 保存更改
+                self._save_keys()
+                
+                # 获取新的密钥，排除已禁用的
+                new_key = self.get_key()
+                if new_key:
+                    logger.info(f"已自动切换到新的密钥")
+                    return new_key
+                else:
+                    logger.warning("没有可用的备用密钥")
+                    return None
+            else:
+                logger.warning(f"未找到要临时禁用的密钥")
+                return None
+            
+    def retry_request(self, original_key: str, request_func: Callable, max_retries: int = 1, 
+                     max_key_switches: int = 3) -> Tuple[bool, Any, str]:
+        """
+        出错时自动重试请求，并在需要时切换密钥
+        
+        Args:
+            original_key: 原始API密钥（可能包含Bearer前缀）
+            request_func: 执行请求的函数，接受一个参数(密钥)并返回(成功标志, 结果)
+            max_retries: 使用同一密钥的最大重试次数
+            max_key_switches: 最大密钥切换次数
+            
+        Returns:
+            Tuple[bool, Any, str]: (是否成功, 请求结果, 使用的密钥)
+        """
+        current_key = original_key
+        current_key_switches = 0
+        
+        # 首先用原始密钥尝试
+        for attempt in range(max_retries + 1):  # +1是因为第一次不算重试
+            try:
+                success, result = request_func(current_key)
+                # 成功的请求不应该导致密钥被禁用
+                if success:
+                    # 记录请求成功，避免不必要的密钥禁用
+                    with self._lock:
+                        self.record_request_result(current_key, True)
+                    return True, result, current_key
+                logger.warning(f"请求失败(尝试 {attempt+1}/{max_retries+1}): {result}")
+            except Exception as e:
+                logger.error(f"请求异常(尝试 {attempt+1}/{max_retries+1}): {str(e)}")
+            
+            # 如果这不是最后一次尝试，等���一秒后重试
+            if attempt < max_retries:
+                time.sleep(1)
+                
+        # 如果原始密钥的所有重试都失败，尝试切换密钥
+        tried_keys = set([current_key.replace("Bearer ", "") if current_key.startswith("Bearer ") else current_key])
+        
+        while current_key_switches < max_key_switches:
+            # 获取新的密钥
+            with self._lock:
+                new_key = self.get_key()
+            if not new_key:
+                logger.warning("没有更多可用的密钥")
+                break
+                
+            # 确保不使用已经尝试过的密钥
+            clean_new_key = new_key.replace("Bearer ", "") if new_key.startswith("Bearer ") else new_key
+            if clean_new_key in tried_keys:
+                continue
+                
+            tried_keys.add(clean_new_key)
+            current_key = new_key
+            current_key_switches += 1
+            
+            logger.info(f"切换到新密钥 (切换 {current_key_switches}/{max_key_switches})")
+            
+            # 用新密钥尝试
+            for attempt in range(max_retries + 1):
+                try:
+                    success, result = request_func(current_key)
+                    if success:
+                        # 记录请求成功
+                        with self._lock:
+                            self.record_request_result(current_key, True)
+                        return True, result, current_key
+                    logger.warning(f"使用新密钥请求失败(尝试 {attempt+1}/{max_retries+1}): {result}")
+                except Exception as e:
+                    logger.error(f"使用新密钥请求异常(尝试 {attempt+1}/{max_retries+1}): {str(e)}")
+                
+                # 如果这不是最后一次尝试，等待一秒后重试
+                if attempt < max_retries:
+                    time.sleep(1)
+        
+        # 所有尝试都失败，临时禁用原始密钥
+        # 但是在并发环境下，这可能是因为网络或服务问题，而非密钥问题
+        # 增加额外检查以减少不必要的密钥禁用
+        should_disable = True
+        
+        # 在临时禁用前，确认是否是密钥问题而非服务或网络问题
+        # 此处可以添加额外逻辑来判断是否应该禁用密钥
+        
+        if should_disable:
+            logger.error(f"所有重试和密钥切换尝试都失败，临时禁用原始密钥")
+            with self._lock:
+                self.mark_key_temp_disabled(original_key, hours=6.0)  # 减少禁用时间，避免资源浪费
+        else:
+            logger.warning(f"所有重试和密钥切换尝试都失败，但可能是服务问题而非密钥问题，不禁用密钥")
+        
+        # 返回最后一次尝试的结果
+        return False, result, current_key
+
+# 创建全局密钥管理器实例
+storage_file = os.getenv("KEYS_STORAGE_FILE", "api_keys.json")
+# 如果提供了绝对路径则直接使用，否则使用相对路径
+if not os.path.isabs(storage_file):
+    base_dir = os.getenv("BASE_DIR", os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    storage_file = os.path.join(base_dir, storage_file)
+
+key_manager = KeyManager(storage_file=storage_file)
+logger.info(f"初始化全局密钥管理器，存储文件: {storage_file}") 

src/main.py

@@ -0,0 +1,44 @@
+import uvicorn
+import logging
+from .app import app, key_manager
+from .config import Config
+
+# 获取日志记录器
+logger = logging.getLogger("sora-api.main")
+
+def init_app():
+    """初始化应用程序"""
+    try:
+        # 密钥管理器已在app.py中初始化并加载完成
+        # 检查是否有可用的密钥
+        if not key_manager.keys:
+            logger.warning("未配置API key，将使用测试密钥")
+            key_manager.add_key(
+                key_value="Bearer eyJhbGciOiJSUzI1NiIsImtpZCI6IjE5MzQ0ZTY1LWJiYzktNDRkMS1hOWQwLWY5NTdiMDc5YmQwZSIsInR5cCI6IkpXVCJ9...",
+                name="默认测试密钥"
+            )
+        
+        logger.info(f"API服务初始化完成，已加载 {len(key_manager.keys)} 个API key")
+    except Exception as e:
+        logger.error(f"API服务初始化失败: {str(e)}")
+        raise
+
+def start():
+    """启动API服务"""
+    # 初始化应用
+    init_app()
+    
+    # 打印配置信息
+    Config.print_config()
+    
+    # 启动服务
+    logger.info(f"启动服务: {Config.HOST}:{Config.PORT}")
+    uvicorn.run(
+        "src.app:app",
+        host=Config.HOST,
+        port=Config.PORT,
+        reload=Config.VERBOSE_LOGGING  # 仅在调试模式下开启自动重载
+    )
+
+if __name__ == "__main__":
+    start()

src/models/__init__.py

@@ -0,0 +1 @@
+

src/models/schemas.py

@@ -0,0 +1,86 @@
+from typing import List, Dict, Any, Optional, Union
+from pydantic import BaseModel, Field
+
+# 聊天完成请求模型
+class ContentItem(BaseModel):
+    type: str
+    text: Optional[str] = None
+    image_url: Optional[Dict[str, str]] = None
+
+class ChatMessage(BaseModel):
+    role: str
+    content: Union[str, List[ContentItem]]
+
+class ChatCompletionRequest(BaseModel):
+    model: str
+    messages: List[ChatMessage]
+    temperature: Optional[float] = 1.0
+    top_p: Optional[float] = 1.0
+    n: Optional[int] = 1
+    stream: Optional[bool] = False
+    max_tokens: Optional[int] = None
+    presence_penalty: Optional[float] = 0
+    frequency_penalty: Optional[float] = 0
+
+# API密钥创建模型
+class ApiKeyCreate(BaseModel):
+    name: str = Field(..., description="密钥名称")
+    key_value: str = Field(..., description="密钥值")
+    weight: int = Field(1, description="权重")
+    rate_limit: int = Field(60, description="速率限制(每分钟请求数)")
+    is_enabled: bool = Field(True, description="是否启用")
+    notes: Optional[str] = Field(None, description="备注")
+
+# API密钥更新模型
+class ApiKeyUpdate(BaseModel):
+    name: Optional[str] = Field(None, description="密钥名称")
+    key_value: Optional[str] = Field(None, description="密钥值")
+    weight: Optional[int] = Field(None, description="权重")
+    rate_limit: Optional[int] = Field(None, description="速率限制(每分钟请求数)")
+    is_enabled: Optional[bool] = Field(None, description="是否启用")
+    notes: Optional[str] = Field(None, description="备注")
+
+# 批量操作基础模型
+class BatchOperation(BaseModel):
+    action: str = Field(..., description="操作类型：import, enable, disable, delete")
+    key_ids: Optional[List[str]] = Field(None, description="要操作的密钥ID列表")
+
+# 批量导入的密钥项模型
+class ImportKeyItem(BaseModel):
+    name: str = Field(..., description="密钥名称")
+    key: str = Field(..., description="密钥值")
+    weight: int = Field(1, description="权重")
+    rate_limit: int = Field(60, description="速率限制(每分钟请求数)")
+    enabled: bool = Field(True, description="是否启用")
+    notes: Optional[str] = Field(None, description="备注")
+
+# 批量导入模型
+class BatchImportOperation(BatchOperation):
+    keys: List[ImportKeyItem] = Field(..., description="要导入的密钥列表")
+    key_ids: Optional[List[str]] = None
+
+# 系统配置更新模型
+class ConfigUpdate(BaseModel):
+    PROXY_HOST: Optional[str] = Field(None, description="代理服务器主机")
+    PROXY_PORT: Optional[str] = Field(None, description="代理服务器端口")
+    PROXY_USER: Optional[str] = Field(None, description="代理服务器用户名")
+    PROXY_PASS: Optional[str] = Field(None, description="代理服务器密码")
+    BASE_URL: Optional[str] = Field(None, description="基础URL，用于图片访问地址")
+    IMAGE_LOCALIZATION: Optional[bool] = Field(None, description="是否启用图片本地化存储")
+    IMAGE_SAVE_DIR: Optional[str] = Field(None, description="图片保存目录")
+    save_to_env: bool = Field(True, description="是否保存到环境变量文件")
+
+# 日志级别更新模型
+class LogLevelUpdate(BaseModel):
+    level: str = Field(..., description="日志级别: DEBUG, INFO, WARNING, ERROR, CRITICAL")
+    save_to_env: bool = Field(True, description="是否保存到环境变量文件")
+
+# JWT认证请求模型
+class LoginRequest(BaseModel):
+    admin_key: str = Field(..., description="管理员密钥")
+
+# JWT令牌响应模型
+class TokenResponse(BaseModel):
+    token: str = Field(..., description="JWT令牌")
+    expires_in: int = Field(..., description="有效期(秒)")
+    token_type: str = Field("bearer", description="令牌类型") 

src/services/__init__.py

@@ -0,0 +1 @@
+

src/services/image_service.py

@@ -0,0 +1,235 @@
+import asyncio
+import base64
+import os
+import tempfile
+import time
+import uuid
+import logging
+import threading
+from typing import List, Dict, Any, Optional, Union, Tuple
+
+from ..sora_integration import SoraClient
+from ..config import Config
+from ..utils import localize_image_urls
+
+logger = logging.getLogger("sora-api.image_service")
+
+# 存储生成结果的全局字典
+generation_results = {}
+
+# 存储任务与API密钥的映射关系
+task_to_api_key = {}
+
+# 将处理中状态消息格式化为think代码块
+def format_think_block(message: str) -> str:
+    """将消息放入```think代码块中"""
+    return f"```think\n{message}\n```"
+
+async def process_image_task(
+    request_id: str,
+    sora_client: SoraClient,
+    task_type: str,
+    prompt: str,
+    **kwargs
+) -> None:
+    """
+    统一的图像处理任务函数
+    
+    Args:
+        request_id: 请求ID
+        sora_client: Sora客户端实例
+        task_type: 任务类型 ("generation" 或 "remix")
+        prompt: 提示词
+        **kwargs: 其他参数，取决于任务类型
+    """
+    try:
+        # 保存当前任务使用的API密钥，以便后续使用同一密钥进行操作
+        current_api_key = sora_client.auth_token
+        task_to_api_key[request_id] = current_api_key
+        
+        # 更新状态为处理中
+        generation_results[request_id] = {
+            "status": "processing",
+            "message": format_think_block("正在准备生成任务，请稍候..."),
+            "timestamp": int(time.time()),
+            "api_key": current_api_key  # 记录使用的API密钥
+        }
+        
+        # 根据任务类型执行不同操作
+        if task_type == "generation":
+            # 文本到图像生成
+            num_images = kwargs.get("num_images", 1)
+            width = kwargs.get("width", 720)
+            height = kwargs.get("height", 480)
+            
+            # 更新状态
+            generation_results[request_id] = {
+                "status": "processing",
+                "message": format_think_block("正在生成图像，请耐心等待..."),
+                "timestamp": int(time.time()),
+                "api_key": current_api_key
+            }
+            
+            # 生成图像
+            logger.info(f"[{request_id}] 开始生成图像, 提示词: {prompt}")
+            image_urls = await sora_client.generate_image(
+                prompt=prompt,
+                num_images=num_images,
+                width=width,
+                height=height
+            )
+            
+        elif task_type == "remix":
+            # 图像到图像生成（Remix）
+            image_data = kwargs.get("image_data")
+            num_images = kwargs.get("num_images", 1)
+            
+            if not image_data:
+                raise ValueError("缺少图像数据")
+                
+            # 更新状态
+            generation_results[request_id] = {
+                "status": "processing",
+                "message": format_think_block("正在处理上传的图片..."),
+                "timestamp": int(time.time()),
+                "api_key": current_api_key
+            }
+            
+            # 保存base64图片到临时文件
+            temp_dir = tempfile.mkdtemp()
+            temp_image_path = os.path.join(temp_dir, f"upload_{uuid.uuid4()}.png")
+            
+            try:
+                # 解码并保存图片
+                with open(temp_image_path, "wb") as f:
+                    f.write(base64.b64decode(image_data))
+                
+                # 更新状态
+                generation_results[request_id] = {
+                    "status": "processing",
+                    "message": format_think_block("正在上传图片到Sora服务..."),
+                    "timestamp": int(time.time()),
+                    "api_key": current_api_key
+                }
+                
+                # 上传图片 - 确保使用与初始请求相同的API密钥
+                upload_result = await sora_client.upload_image(temp_image_path)
+                media_id = upload_result['id']
+                
+                # 更新状态
+                generation_results[request_id] = {
+                    "status": "processing",
+                    "message": format_think_block("正在基于图片生成新图像..."),
+                    "timestamp": int(time.time()),
+                    "api_key": current_api_key
+                }
+                
+                # 执行remix生成
+                logger.info(f"[{request_id}] 开始生成Remix图像, 提示词: {prompt}")
+                image_urls = await sora_client.generate_image_remix(
+                    prompt=prompt,
+                    media_id=media_id,
+                    num_images=num_images
+                )
+                
+            finally:
+                # 清理临时文件
+                if os.path.exists(temp_image_path):
+                    os.remove(temp_image_path)
+                if os.path.exists(temp_dir):
+                    os.rmdir(temp_dir)
+        else:
+            raise ValueError(f"未知的任务类型: {task_type}")
+        
+        # 验证生成结果
+        if isinstance(image_urls, str):
+            logger.warning(f"[{request_id}] 图像生成失败或返回了错误信息: {image_urls}")
+            generation_results[request_id] = {
+                "status": "failed",
+                "error": image_urls,
+                "message": format_think_block(f"图像生成失败: {image_urls}"),
+                "timestamp": int(time.time()),
+                "api_key": current_api_key
+            }
+            return
+            
+        if not image_urls:
+            logger.warning(f"[{request_id}] 图像生成返回了空列表")
+            generation_results[request_id] = {
+                "status": "failed",
+                "error": "图像生成返回了空结果",
+                "message": format_think_block("图像生成失败: 服务器返回了空结果"),
+                "timestamp": int(time.time()),
+                "api_key": current_api_key
+            }
+            return
+            
+        logger.info(f"[{request_id}] 成功生成 {len(image_urls)} 张图片")
+        
+        # 本地化图片URL
+        if Config.IMAGE_LOCALIZATION:
+            logger.info(f"[{request_id}] 准备进行图片本地化处理")
+            try:
+                localized_urls = await localize_image_urls(image_urls)
+                logger.info(f"[{request_id}] 图片本地化处理完成")
+                
+                # 检查本地化结果
+                if not localized_urls:
+                    logger.warning(f"[{request_id}] 本地化处理返回了空列表，将使用原始URL")
+                    localized_urls = image_urls
+                
+                # 检查是否所有URL都被正确本地化
+                local_count = sum(1 for url in localized_urls if url.startswith("/static/") or "/static/" in url)
+                logger.info(f"[{request_id}] 本地化结果: 总计 {len(localized_urls)} 张图片，成功本地化 {local_count} 张")
+                
+                if local_count == 0:
+                    logger.warning(f"[{request_id}] 警告：没有一个URL被成功本地化，将使用原始URL")
+                    localized_urls = image_urls
+                
+                image_urls = localized_urls
+            except Exception as e:
+                logger.error(f"[{request_id}] 图片本地化过程中发生错误: {str(e)}", exc_info=True)
+                logger.info(f"[{request_id}] 由于错误，将使用原始URL")
+        else:
+            logger.info(f"[{request_id}] 图片本地化功能未启用，使用原始URL")
+        
+        # 存储结果
+        generation_results[request_id] = {
+            "status": "completed",
+            "image_urls": image_urls,
+            "timestamp": int(time.time()),
+            "api_key": current_api_key
+        }
+        
+        # 30分钟后自动清理结果
+        def cleanup_task():
+            generation_results.pop(request_id, None)
+            task_to_api_key.pop(request_id, None)
+            
+        threading.Timer(1800, cleanup_task).start()
+        
+    except Exception as e:
+        error_message = f"图像生成失败: {str(e)}"
+        generation_results[request_id] = {
+            "status": "failed",
+            "error": error_message,
+            "message": format_think_block(error_message),
+            "timestamp": int(time.time()),
+            "api_key": sora_client.auth_token  # 记录当前API密钥
+        }
+        logger.error(f"图像生成失败 (ID: {request_id}): {str(e)}", exc_info=True)
+
+def get_generation_result(request_id: str) -> Dict[str, Any]:
+    """获取生成结果"""
+    if request_id not in generation_results:
+        return {
+            "status": "not_found",
+            "error": f"找不到生成任务: {request_id}",
+            "timestamp": int(time.time())
+        }
+    
+    return generation_results[request_id]
+
+def get_task_api_key(request_id: str) -> Optional[str]:
+    """获取任务对应的API密钥"""
+    return task_to_api_key.get(request_id) 

src/services/streaming.py

@@ -0,0 +1,231 @@
+import json
+import time
+import asyncio
+import logging
+from typing import AsyncGenerator, List, Dict, Any
+
+from ..sora_integration import SoraClient
+from ..config import Config
+from ..utils import localize_image_urls
+from .image_service import format_think_block
+
+logger = logging.getLogger("sora-api.streaming")
+
+async def generate_streaming_response(
+    sora_client: SoraClient,
+    prompt: str,
+    n_images: int = 1
+) -> AsyncGenerator[str, None]:
+    """
+    文本到图像的流式响应生成器
+    
+    Args:
+        sora_client: Sora客户端
+        prompt: 提示词
+        n_images: 生成图像数量
+    
+    Yields:
+        SSE格式的响应数据
+    """
+    request_id = f"chatcmpl-stream-{time.time()}-{hash(prompt) % 10000}"
+    
+    # 发送开始事件
+    yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'role': 'assistant'}, 'finish_reason': None}]})}\n\n"
+    
+    # 发送处理中的消息（放在代码块中）
+    start_msg = "```think\n正在生成图像，请稍候...\n"
+    yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': start_msg}, 'finish_reason': None}]})}\n\n"
+    
+    # 创建一个后台任务来生成图像
+    logger.info(f"[流式响应 {request_id}] 开始生成图像, 提示词: {prompt}")
+    generation_task = asyncio.create_task(sora_client.generate_image(
+        prompt=prompt,
+        num_images=n_images,
+        width=720,
+        height=480
+    ))
+    
+    # 每5秒发送一条"仍在生成中"的消息，防止连接超时
+    progress_messages = [
+        "正在处理您的请求...",
+        "仍在生成图像中，请继续等待...",
+        "Sora正在创作您的图像作品...",
+        "图像生成需要一点时间，感谢您的耐心等待...",
+        "我们正在努力为您创作高质量图像..."
+    ]
+    
+    i = 0
+    while not generation_task.done():
+        # 每5秒发送一次进度消息
+        await asyncio.sleep(5)
+        progress_msg = progress_messages[i % len(progress_messages)]
+        i += 1
+        content = "\n" + progress_msg + "\n"
+        yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': content}, 'finish_reason': None}]})}\n\n"
+    
+    try:
+        # 获取生成结果
+        image_urls = await generation_task
+        logger.info(f"[流式响应 {request_id}] 图像生成完成，获取到 {len(image_urls) if isinstance(image_urls, list) else '非列表'} 个URL")
+        
+        # 本地化图片URL
+        if Config.IMAGE_LOCALIZATION and isinstance(image_urls, list) and image_urls:
+            logger.info(f"[流式响应 {request_id}] 准备进行图片本地化处理")
+            try:
+                localized_urls = await localize_image_urls(image_urls)
+                image_urls = localized_urls
+                logger.info(f"[流式响应 {request_id}] 图片本地化处理完成")
+            except Exception as e:
+                logger.error(f"[流式响应 {request_id}] 图片本地化过程中发生错误: {str(e)}", exc_info=True)
+                logger.info(f"[流式响应 {request_id}] 由于错误，将使用原始URL")
+        elif not Config.IMAGE_LOCALIZATION:
+            logger.info(f"[流式响应 {request_id}] 图片本地化功能未启用")
+        
+        # 结束代码块
+        content_str = "\n```\n\n"
+        yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': content_str}, 'finish_reason': None}]})}\n\n"
+        
+        # 添加生成的图片URLs
+        for i, url in enumerate(image_urls):
+            if i > 0:
+                content_str = "\n\n"
+                yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': content_str}, 'finish_reason': None}]})}\n\n"
+            
+            image_markdown = f"![Generated Image]({url})"
+            yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': image_markdown}, 'finish_reason': None}]})}\n\n"
+        
+        # 发送完成事件
+        yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {}, 'finish_reason': 'stop'}]})}\n\n"
+        
+        # 发送结束标志
+        yield "data: [DONE]\n\n"
+        
+    except Exception as e:
+        error_msg = f"图像生成失败: {str(e)}"
+        logger.error(f"[流式响应 {request_id}] 错误: {error_msg}", exc_info=True)
+        error_content = f"\n{error_msg}\n```"
+        yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': error_content}, 'finish_reason': 'error'}]})}\n\n"
+        yield "data: [DONE]\n\n"
+
+async def generate_streaming_remix_response(
+    sora_client: SoraClient,
+    prompt: str,
+    image_data: str,
+    n_images: int = 1
+) -> AsyncGenerator[str, None]:
+    """
+    图像到图像的流式响应生成器
+    
+    Args:
+        sora_client: Sora客户端
+        prompt: 提示词
+        image_data: Base64编码的图像数据
+        n_images: 生成图像数量
+    
+    Yields:
+        SSE格式的响应数据
+    """
+    import os
+    import tempfile
+    import uuid
+    import base64
+    
+    request_id = f"chatcmpl-stream-remix-{time.time()}-{hash(prompt) % 10000}"
+    
+    # 发送开始事件
+    yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'role': 'assistant'}, 'finish_reason': None}]})}\n\n"
+    
+    try:
+        # 保存base64图片到临时文件
+        temp_dir = tempfile.mkdtemp()
+        temp_image_path = os.path.join(temp_dir, f"upload_{uuid.uuid4()}.png")
+        
+        try:
+            # 解码并保存图片
+            with open(temp_image_path, "wb") as f:
+                f.write(base64.b64decode(image_data))
+            
+            # 上传图片
+            upload_msg = "```think\n上传图片中...\n"
+            yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': upload_msg}, 'finish_reason': None}]})}\n\n"
+            
+            logger.info(f"[流式响应Remix {request_id}] 上传图片中")
+            upload_result = await sora_client.upload_image(temp_image_path)
+            media_id = upload_result['id']
+            
+            # 发送生成中消息
+            generate_msg = "\n基于图片生成新图像中...\n"
+            yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': generate_msg}, 'finish_reason': None}]})}\n\n"
+            
+            # 创建后台任务生成图像
+            logger.info(f"[流式响应Remix {request_id}] 开始生成图像，提示词: {prompt}")
+            generation_task = asyncio.create_task(sora_client.generate_image_remix(
+                prompt=prompt,
+                media_id=media_id,
+                num_images=n_images
+            ))
+            
+            # 每5秒发送一条"仍在生成中"的消息
+            progress_messages = [
+                "正在处理您的请求...",
+                "仍在生成图像中，请继续等待...",
+                "Sora正在基于您的图片创作新作品...",
+                "图像生成需要一点时间，感谢您的耐心等待...",
+                "正在融合您的风格和提示词，打造专属图像..."
+            ]
+            
+            i = 0
+            while not generation_task.done():
+                await asyncio.sleep(5)
+                progress_msg = progress_messages[i % len(progress_messages)]
+                i += 1
+                content = "\n" + progress_msg + "\n"
+                yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': content}, 'finish_reason': None}]})}\n\n"
+            
+            # 获取生成结果
+            image_urls = await generation_task
+            logger.info(f"[流式响应Remix {request_id}] 图像生成完成")
+            
+            # 本地化图片URL
+            if Config.IMAGE_LOCALIZATION:
+                logger.info(f"[流式响应Remix {request_id}] 进行图片本地化处理")
+                localized_urls = await localize_image_urls(image_urls)
+                image_urls = localized_urls
+                logger.info(f"[流式响应Remix {request_id}] 图片本地化处理完成")
+            else:
+                logger.info(f"[流式响应Remix {request_id}] 图片本地化功能未启用")
+            
+            # 结束代码块
+            content_str = "\n```\n\n"
+            yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': content_str}, 'finish_reason': None}]})}\n\n"
+            
+            # 发送图片URL作为Markdown
+            for i, url in enumerate(image_urls):
+                if i > 0:
+                    newline_str = "\n\n"
+                    yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': newline_str}, 'finish_reason': None}]})}\n\n"
+                
+                image_markdown = f"![Generated Image]({url})"
+                yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': image_markdown}, 'finish_reason': None}]})}\n\n"
+            
+            # 发送完成事件
+            yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {}, 'finish_reason': 'stop'}]})}\n\n"
+            
+            # 发送结束标志
+            yield "data: [DONE]\n\n"
+            
+        finally:
+            # 清理临时文件
+            if os.path.exists(temp_image_path):
+                os.remove(temp_image_path)
+            if os.path.exists(temp_dir):
+                os.rmdir(temp_dir)
+                
+    except Exception as e:
+        error_msg = f"图像Remix失败: {str(e)}"
+        logger.error(f"[流式响应Remix {request_id}] 错误: {error_msg}", exc_info=True)
+        error_content = f"\n{error_msg}\n```"
+        yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': error_content}, 'finish_reason': 'error'}]})}\n\n"
+    
+    # 结束流
+    yield "data: [DONE]\n\n" 

src/sora_generator.py

@@ -0,0 +1,1145 @@
+import cloudscraper
+import time
+import json
+import random
+import string
+import os
+import mimetypes # To guess file mime type
+import argparse # For better command-line arguments
+import asyncio
+from .utils import localize_image_urls
+from .config import Config
+
+class SoraImageGenerator:
+    def __init__(self, proxy_host=None, proxy_port=None, proxy_user=None, proxy_pass=None, auth_token=None):
+        # 使用Config.VERBOSE_LOGGING替代直接从环境变量读取SORA_DEBUG
+        self.DEBUG = Config.VERBOSE_LOGGING
+        
+        # 设置代理
+        if proxy_host and proxy_port:
+            # 如果有认证信息，添加到代理URL中
+            if proxy_user and proxy_pass:
+                proxy_auth = f"{proxy_user}:{proxy_pass}@"
+                self.proxies = {
+                    "http": f"http://{proxy_auth}{proxy_host}:{proxy_port}",
+                    "https": f"http://{proxy_auth}{proxy_host}:{proxy_port}"
+                }
+                if self.DEBUG:
+                    print(f"已配置带认证的代理: {proxy_user}:****@{proxy_host}:{proxy_port}")
+            else:
+                self.proxies = {
+                    "http": f"http://{proxy_host}:{proxy_port}",
+                    "https": f"http://{proxy_host}:{proxy_port}"
+                }
+                if self.DEBUG:
+                    print(f"已配置代理: {proxy_host}:{proxy_port}")
+        else:
+            self.proxies = None
+            if self.DEBUG:
+                print("代理未配置。请求将直接发送。")
+        # 创建 cloudscraper 实例
+        self.scraper = cloudscraper.create_scraper(
+            browser={
+                'browser': 'chrome',
+                'platform': 'windows',
+                'mobile': False
+            }
+        )
+        # 设置通用请求头 - 移除 Content-Type 和 openai-sentinel-token (会动态添加)
+        self.base_headers = {
+            "accept": "*/*",
+            "accept-language": "zh-CN,zh;q=0.9",
+            "cache-control": "no-cache",
+            "pragma": "no-cache",
+            "priority": "u=1, i",
+            "sec-ch-ua": "\"Chromium\";v=\"136\", \"Google Chrome\";v=\"136\", \"Not.A/Brand\";v=\"99\"",
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": "\"Windows\"",
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+            # Referer 会根据操作不同设置
+        }
+        # 设置认证Token (从外部传入或硬编码)
+        self.auth_token = auth_token or "Bearer eyJhbGciOiJSUzI1NiIsImtpZCI6IjE5MzQ0ZTY1LWJiYzktNDRkMS1hOWQwLWY5NTdiMDc5YmQwZSIsInR5cCI6IkpXVCJ9.eyJhdWQiOlsiaHR0cHM6Ly9hcGkub3BlbmFpLmNvbS92MSJdLCJjbGllbnRfaWQiOiJhcHBfWDh6WTZ2VzJwUTl0UjNkRTduSzFqTDVnSCIsImV4cCI6MTc0Nzk3MDExMSwiaHR0cHM6Ly9hcGkub3BlbmFpLmNvbS9hdXRoIjp7InVzZXJfaWQiOiJ1c2VyLWdNeGM0QmVoVXhmTW1iTDdpeUtqengxYiJ9LCJodHRwczovL2FwaS5vcGVuYWkuY29tL3Byb2ZpbGUiOnsiZW1haWwiOiIzajVtOTFud3VtckBmcmVlLnViby5lZHUuZ24iLCJlbWFpbF92ZXJpZmllZCI6dHJ1ZX0sImlhdCI6MTc0NzEwNjExMSwiaXNzIjoiaHR0cHM6Ly9hdXRoLm9wZW5haS5jb20iLCJqdGkiOiIzMGM4ZDJhOS0yNzkxLTRhNjQtODI2OS0yMzU3OGFhMmI0MTEiLCJuYmYiOjE3NDcxMDYxMTEsInB3ZF9hdXRoX3RpbWUiOjE3NDcxMDYxMDkxMDksInNjcCI6WyJvcGVuaWQiLCJlbWFpbCIsInByb2ZpbGUiLCJvZmZsaW5lX2FjY2VzcyIsIm1vZGVsLnJlcXVlc3QiLCJtb2RlbC5yZWFkIiwib3JnYW5pemF0aW9uLnJlYWQiLCJvcmdhbml6YXRpb24ud3JpdGUiXSwic2Vzc2lvbl9pZCI6ImF1dGhzZXNzX21yWFRwZlVENU51TDFsV05xNUhSOW9lYiIsInN1YiI6ImF1dGgwfDY4MjFkYWYyNjhiYjgxMzFkMDRkYTAwNCJ9.V4ZqYJuf_f7F_DrMMRrt-ymul5HUrqENVkiFyEwfYmzMFWthEGS6Ryia100QRlprw8jjGscHZXlUFaOcRNIarcBig8fBY6n_AB3J34MlcBv6peS-3_EJlIiH_N7j_mu-8lNpJbxk9lSlFaGpKU1IOO7kBuaAmLH-iErM-wqBfSlnnAq8h4iqBDxi4CMTcAhVm2-qG7u7f0Ho1TCGa7wrdchWtZxyfHIqNWkC88qBlUwTH5g2vRL419_zIKEWKyAtV2WNI68vpyBLrRVhtnpDh0jcrm2WqCj2X2LQqNFkFKoui3wCdG9Vskpl39l9sV54HuV7w6stQIausR1F4Y9NbjsBAyLIimZOllCwYAefTC2BOpIHfOA3_D58G3SEiRADVK7pK7ip6QsEI__GteoeCuRvZA9b5jLmhVS0SUlDYSOoNwlJ_ejfEpPJcmHUchFa7bUkS-XVrEUgr1yP5FxPwWUyn7UWrW_dZ3lVW1EU4Bp6Kp6JuwyOFf2Mj-V3_9tc8qJRClI8WHUf6In0hiO_pGbFCI2opkF3XusAQKmTB12nPBsmSlwewigTPhAj3nf-8Ze3O-etnBrV5pz_woIwQsQ54T-wgEdrLWDE6dSqNDulfpldF6Cok62212kW8w3SY3V7VSq5Tr1KRyWXJEH-haVb6qmAE2ldDjeHvJossWg" # 替换成你的有效Token或从环境变量读取
+        if not self.auth_token or not self.auth_token.startswith("Bearer "):
+            raise ValueError("无效或缺失的认证Token (应以 'Bearer ' 开头)")
+        self.gen_url = "https://sora.chatgpt.com/backend/video_gen"
+        self.check_url = "https://sora.chatgpt.com/backend/video_gen"
+        self.upload_url = "https://sora.chatgpt.com/backend/uploads"
+        
+        # 显示是否启用了图片本地化功能
+        if Config.IMAGE_LOCALIZATION:
+            if self.DEBUG:
+                print(f"图片本地化功能已启用，图片将保存到：{Config.IMAGE_SAVE_DIR}")
+            os.makedirs(Config.IMAGE_SAVE_DIR, exist_ok=True)
+    
+    def _get_dynamic_headers(self, content_type="application/json", referer="https://sora.chatgpt.com/explore"):
+        """为每个请求生成包含动态sentinel token的headers"""
+        headers = self.base_headers.copy()
+        headers["authorization"] = self.auth_token
+        headers["openai-sentinel-token"] = self._generate_sentinel_token()
+        headers["referer"] = referer
+        if content_type: # multipart/form-data 时 Content-Type 由 requests 自动设置
+            headers["content-type"] = content_type
+        return headers
+    
+    def _generate_sentinel_token(self):
+        """生成一个随机修改的sentinel-token"""
+        base_token = {
+            "p": "gAAAAABWzIxMjksIk1vbiBNYXkgMTIgMjAyNSAxODo1ODowOSBHTVQrMDgwMCAo5Lit5Zu95qCH5YeG5pe26Ze0KSIsMjI0ODE0Njk0NCw5LCJNb3ppbGxhLzUuMCAoV2luZG93cyBOVCAxMC4wOyBXaW42NDsgeDY0KSBBcHBsZVdlYktpdC81MzcuMzYgKEtIVE1MLCBsaWtlIEdlY2tvKSBDaHJvbWUvMTM2LjAuMC4wIFNhZmFyaS81MzcuMzYiLCJodHRwczovL3NvcmEtY2RuLm9haXN0YXRpYy5jb20vX25leHQvc3RhdGljL2NodW5rcy93ZWJwYWNrLWU1MDllMDk0N2RlZWM0Y2YuanMiLG51bGwsInpoLUNOIiwiemgtQ04semgiLDEwLCJwcm9kdWN0U3Vi4oiSMjAwMzAxMDciLCJfcmVhY3RMaXN0ZW5pbmd2cXAzdWtpNmh6IiwiX19zZW50aW5lbF9pbml0X3BlbmRpbmciLDEyMDczMzEuNSwiN2M4OTMxM2EtZTY0Mi00MjI4LTk5ZDQtNTRlZDRjYzQ3MGZiIiwiIiwxNl0=",
+            "t": "SBYdBBoGFhQRdVtbdxEYEQEaHQAAFhQRYwN2T2IEUH5pRHJyYx51YnJybFBhWHZkYgRyUHgDclZzH2l5a1gXUWVlcRMRGBEBHR0HBBYUEXpnfVt9YFAJDB8WAAIAAgYRDgxpYltjSl55SWJEZV9mXx4KFh8WGAAaBxYUEXVydW9ydXJ1b3J1cnVvcnVydW9ydXJ1b3J1b3J1b3J1b3J1DgkMHxYBAgALAxEOHh0BBwIXCwwEBx8FAwADGwAAHxYcBxoFDQwJFnFDEw4WHxYXBxoCBwwJFmB2dGRxYgBqdHVLf2hUX3VySWpVcVNNa3ZiYW13dgtyb3J5cHxvam12YWB7YgN2THVcYnxsSwR7fH9mfHJlZ1F3VARtcVwLcGpiV2pwaEdmZFhgdGZLbWRxXAdQbHJ5dHNvanlwQ29Xd1QEZnFmXFJoWFBRbEZ2e3JTWVF8YnFvd2ZUd2xiR3Vzb1BxcWV3UXxLbmxrYV9Wf3FxfHNJclVydU1qdXJtaHJmUH9sYnF1fElcdXtMdH5sdnZmZAR+ZmpUcXZzVgN2cUN3UHZyZWhyXAd8bHJ5cnVGdW1lWGRScWIAamBlDgkMHxYKBgADDREODHZjcWx/AnIBZkJLV2FTRWZWZX5Pa2JHVWsDbmRie1xgYXFoUWxfbmlhBQJ4f3FmUGFJBnNkWEphZ3VET2VYcntpA25kYntDVWRYf2Z3ZXZ9Vl9hXXZ1RGZseENzZnJ3Z3YCdn1WX2FddnVEZmx4Q3NmcndkFh8WFwAaBAUMCRZrcnh7fF92T2Z1eXx2dW5pZ1YKXGIFRnFhX3ZAZmJLUXwAfmtgeGlxYQVoeFdYdU1iYgJjfFsBAVJ7YUxrB1ZDVUR+fGthcXN4ZkRrbH9lWmtsG0FiAkdIZHFXZnxffnRiVgZsa3JeUmVlQEhhQ31ybFsNZ2VCS2NmWEZFZlhMWWQEcWJ2ZWZdZx5XdWRYXnllcVxJanMKWnQARElXdgoDUHx4WlZ0UEBWB0tNTQBuQW4dAlNXWXRUV11cXWkHQwx0XW5BUW9QbWVyRnFhZWJIVwR1UHtfRGdSeGl1YQUfcmJ2V0h3Zgd4bFR9cWdCUHFmZU1qd199amVDeQx5X3JRYB51ZWRYXnlSZHJcdAVHdXtmcWlWaXFwV1hGXlB0Q2hlX1dQf2V+fWB7cndqcl5YUF92TXRxV3V3AkBXY0JpbWRfSlJ8AgVLZGFHdnwCRHBnHFdzZlheV2wCYmZmbAZjfF9iUWxoBmJrYkp/UAJiZmVleXB4ZWZhdR9HYmJ2Qn5iX3JKdGFbV3xfdmF1HnVmZWF0f2V1THlmdXlTd3t+VFJ2Q05RfEZbV3tiAVIHAlpLAXICVXZpRmpzbEVXa1wcUgZXBwxO",
+            "c": "gAAAAABoIdRAZEk6qAnDRqdimKxPhXtA_xBkiDXhKF4LUmlNY6CZmfNxZiabjPHk_DCEUnnyq-y6JPj-D46YPk-6r7zR6qS64hEwGYt9Hh_8vUIod-7PLh9qPKqdYl4TBCVUgtrbhTWfse7s6NHCSy1T0Nzj2C6vAUPhzAx4LAMIrl2YbElkUVPgwELyYF_inh3zliwZL-zp4zR3LOABcrGqlrLoP7_kNrwcIZwlVD1RNlnHy9TEFsRzYOMQo_DbagZAK1h87arrMonZHBi9ukfiGuvCQP-y76j61b4qaQPMA19EoURLwnotVBWUIBpHEEoH9vmPb817sGwQ2R8XHoAVR4dwYs_7EoS8H8kAlUVZDjAKGq5x48nvZrarLBjYJXXsfJLuxhibNYXG1hKNbOdi1w-Xl1NgqSPAb-MuwnyDLPGE5MeLkwM2Dl3jD7G6B2Z2F993cvW7mOOs0OebZ6NMgIrZnTG4mMI7PirPY95JWmztDfeuFLJ_V_kyaSP--BZCIIAB4074RBVitIrJEwceWVW3zXOOHWJoDax7E0nfa5abvLGCjdEeJfNx4Fcp7iYFN_E8iR0f797DLlFh4uFLv1DPhipYtQFpPPUlbxKu9H9W4IDr7Hv_LgfvFo0VwLzV6ANZPGmdza67dAsKXrWtXlCrVNfqFoVO4wI4n-zrE3lcUPzI_ZJebF2HGlzerTvqgU5R0i4fzUGY4-UqpWlVurP-rCJY2ARcSMSyPXnPGetl5Z2m-f9k7K3n7txrfv2293jyyRTVAZLC9aLrBOFWHD4cf0aiwisgJ9IKnhhnoJ-WF8NuvFS7l1Z0d2zTnndjuryb0M36Og4b_Ku3aJKS0_Eqbns8_bUXdEPh5_15T_92_1yf5jy-amrgolgcO_7yJqX5aU9-PUUiaP3WzeyidMSH4Vtls63tQ5evUlDkEHfNKoyCYaSxpzA_FsNmPbMmcv3g1wNKg_W8V0Yh7ZrtW1L8229SpZFWc96Sg3CRPplk-dnVzV93lP7cN5o5ubGWZMkkz5UASjE5XLn8h5dx6neuOemKVHAj29QxOWmdGEehNvmeMec0k8uL9X-7yYBJSTnI066OR38JUUTFqTH3RSXI9M4ggals32P56bwUmawvZ-bu02qc3kCVI3oK9bnP8oTk0xTK5_bMrlevGYKG0qdPXamgdDfVg7hlNA2OTCnw6iRP6DJiPm_zKVdQa4z6SPJsdt_Q",
+            "id": self._generate_random_id(),
+            "flow": "sora_create_task" # This might need changing for uploads? Let's try keeping it.
+        }
+        # Simple randomization (can be improved if needed)
+        p_chars = list(base_token["p"])
+        for _ in range(random.randint(3, 7)):
+            pos = random.randint(10, len(p_chars) - 10)
+            p_chars[pos] = random.choice(string.ascii_letters + string.digits + "+/=")
+        base_token["p"] = "".join(p_chars)
+        c_chars = list(base_token["c"])
+        for _ in range(random.randint(3, 7)):
+            pos = random.randint(10, len(c_chars) - 10)
+            c_chars[pos] = random.choice(string.ascii_letters + string.digits + "+/=_-")
+        base_token["c"] = "".join(c_chars)
+        return json.dumps(base_token)
+    
+    def _generate_random_id(self):
+        """生成一个随机ID，格式类似于UUID"""
+        return f"{self._random_hex(8)}-{self._random_hex(4)}-{self._random_hex(4)}-{self._random_hex(4)}-{self._random_hex(12)}"
+    
+    def _random_hex(self, length):
+        """生成指定长度的随机十六进制字符串"""
+        return ''.join(random.choice(string.hexdigits.lower()) for _ in range(length))
+    
+    def generate_image(self, prompt, num_images=1, width=720, height=480):
+        """
+        生成一张或多张图片并返回图片URL列表
+        参数:
+        prompt (str): 图片生成提示词
+        num_images (int): 要生成的图片数量 (对应 n_variants)
+        width (int): 图片宽度
+        height (int): 图片高度
+        返回:
+        list[str] or str: 成功时返回包含图片URL的列表，失败时返回错误信息字符串
+        """
+        # 确保提示词是正确的UTF-8格式
+        if isinstance(prompt, bytes):
+            prompt = prompt.decode('utf-8')
+        
+        # 打印提示词，并处理可能的编码问题
+        try:
+            if self.DEBUG:
+                print(f"开始生成 {num_images} 张图片，提示词: '{prompt}'")
+        except UnicodeEncodeError:
+            if self.DEBUG:
+                print(f"开始生成 {num_images} 张图片，提示词: [编码显示问题，但数据正确]")
+        
+        payload = {
+            "type": "image_gen",
+            "operation": "simple_compose",
+            "prompt": prompt,
+            "n_variants": num_images, # 使用传入的数量
+            "width": width,
+            "height": height,
+            "n_frames": 1,
+            "inpaint_items": []
+        }
+        try:
+            task_id = self._submit_task(payload, referer="https://sora.chatgpt.com/explore")
+            if not task_id:
+                # 任务提交失败，尝试切换密钥后重试
+                if self.DEBUG:
+                    print(f"任务提交失败，尝试切换API密钥后重试")
+                
+                try:
+                    # 导入在这里进行以避免循环导入
+                    from .key_manager import key_manager
+                    # 标记当前密钥为无效并获取新密钥
+                    new_key = key_manager.mark_key_invalid(self.auth_token)
+                    if new_key:
+                        self.auth_token = new_key
+                        if self.DEBUG:
+                            print(f"已切换到新的API密钥，重试任务")
+                        # 使用新密钥重试提交任务
+                        task_id = self._submit_task(payload, referer="https://sora.chatgpt.com/explore")
+                        if not task_id:
+                            return "任务提交失败（已尝试切换密钥）"
+                    else:
+                        return "任务提交失败（无可用的备用密钥）"
+                except ImportError:
+                    if self.DEBUG:
+                        print(f"无法导入key_manager，无法自动切换密钥")
+                    return "任务提交失败"
+                except Exception as e:
+                    if self.DEBUG:
+                        print(f"切换API密钥时发生错误: {str(e)}")
+                    return f"任务提交失败: {str(e)}"
+            
+            if self.DEBUG:
+                print(f"任务已提交，ID: {task_id}")
+            # 轮询检查任务状态，直到完成
+            image_urls = self._poll_task_status(task_id)
+            
+            # 如果轮询返回错误信息，也尝试切换密钥重试
+            if isinstance(image_urls, str) and ("失败" in image_urls or "错误" in image_urls or "error" in image_urls.lower()):
+                if self.DEBUG:
+                    print(f"任务执行失败，尝试切换API密钥后重试")
+                
+                try:
+                    from .key_manager import key_manager
+                    new_key = key_manager.mark_key_invalid(self.auth_token)
+                    if new_key:
+                        self.auth_token = new_key
+                        if self.DEBUG:
+                            print(f"已切换到新的API密钥，重试整个生成过程")
+                        # 使用新密钥重试整个生成过程
+                        return self.generate_image(prompt, num_images, width, height)
+                except (ImportError, Exception) as e:
+                    if self.DEBUG:
+                        print(f"切换API密钥失败或重试失败: {str(e)}")
+            
+            # 图片本地化处理
+            if Config.IMAGE_LOCALIZATION and isinstance(image_urls, list) and image_urls:
+                if self.DEBUG:
+                    print(f"\n================================")
+                    print(f"开始图片本地化处理")
+                    print(f"图片本地化配置: 启用={Config.IMAGE_LOCALIZATION}, 保存目录={Config.IMAGE_SAVE_DIR}")
+                    print(f"需要本地化的图片数量: {len(image_urls)}")
+                    print(f"原始图片URLs: {image_urls}")
+                    print(f"================================\n")
+                
+                try:
+                    # 创建事件循环并运行图片本地化
+                    if self.DEBUG:
+                        print(f"创建异步事件循环处理图片下载...")
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                    
+                    if self.DEBUG:
+                        print(f"调用localize_image_urls函数...")
+                    localized_urls = loop.run_until_complete(localize_image_urls(image_urls))
+                    loop.close()
+                    if self.DEBUG:
+                        print(f"异步事件循环已关闭")
+                    
+                    if self.DEBUG:
+                        print(f"\n================================")
+                        print(f"图片本地化完成")
+                        print(f"原始URLs: {image_urls}")
+                        print(f"本地化后的URLs: {localized_urls}")
+                        print(f"================================\n")
+                    
+                    # 检查结果是否有效
+                    if not localized_urls:
+                        if self.DEBUG:
+                            print(f"❌ 警告：本地化后的URL列表为空，将使用原始URL")
+                        return image_urls
+                        
+                    # 检查是否所有URL都被正确本地化
+                    local_count = sum(1 for url in localized_urls if url.startswith("/static/") or "/static/" in url)
+                    if local_count == 0:
+                        if self.DEBUG:
+                            print(f"❌ 警告：没有一个URL被成功本地化，将使用原始URL")
+                        return image_urls
+                    elif local_count < len(localized_urls):
+                        if self.DEBUG:
+                            print(f"⚠️ 注意：部分URL未成功本地化 ({local_count}/{len(localized_urls)})")
+                        
+                    return localized_urls
+                except Exception as e:
+                    if self.DEBUG:
+                        print(f"❌ 图片本地化过程中发生错误: {str(e)}")
+                    import traceback
+                    traceback.print_exc()
+                    if self.DEBUG:
+                        print(f"由于错误，将返回原始URL")
+                    return image_urls
+            elif not Config.IMAGE_LOCALIZATION:
+                if self.DEBUG:
+                    print(f"图片本地化功能未启用，返回原始URLs")
+            elif not isinstance(image_urls, list):
+                if self.DEBUG:
+                    print(f"图片生成返回了非列表结果: {image_urls}，无法进行本地化")
+            elif not image_urls:
+                if self.DEBUG:
+                    print(f"图片生成返回了空列表，没有可本地化的内容")
+            
+            return image_urls
+        except Exception as e:
+            if self.DEBUG:
+                print(f"❌ 生成图片时出错: {str(e)}")
+            import traceback
+            traceback.print_exc()
+            return f"生成图片时出错: {str(e)}"
+    
+    def upload_image(self, file_path):
+        """
+        上传本地图片文件到Sora后端
+        参数:
+        file_path (str): 本地图片文件的路径
+        返回:
+        dict or str: 成功时返回包含上传信息的字典，失败时返回错误信息字符串
+        """
+        if not os.path.exists(file_path):
+            return f"错误：文件未找到 '{file_path}'"
+        file_name = os.path.basename(file_path)
+        mime_type, _ = mimetypes.guess_type(file_path)
+        if not mime_type or not mime_type.startswith('image/'):
+            return f"错误：无法确定文件类型或文件不是图片 '{file_path}' (Mime: {mime_type})"
+        if self.DEBUG:
+            print(f"开始上传图片: {file_name} (Type: {mime_type})")
+        # multipart/form-data 请求不需要手动设置 Content-Type header
+        # requests 会根据 files 参数自动处理 boundary 和 Content-Type
+        headers = self._get_dynamic_headers(content_type=None, referer="https://sora.chatgpt.com/library") # Referer from example
+        
+        # 尝试上传
+        return self._try_upload_with_retry(file_path, file_name, mime_type, headers)
+    
+    def _try_upload_with_retry(self, file_path, file_name, mime_type, headers, is_retry=False):
+        """尝试上传图片，失败时可能尝试切换密钥重试"""
+        # 保存当前的API密钥，确保整个上传过程使用相同的密钥
+        current_auth_token = self.auth_token
+        
+        files = {
+            'file': (file_name, open(file_path, 'rb'), mime_type),
+            'file_name': (None, file_name) # 第二个字段是文件名
+        }
+        try:
+            response = self.scraper.post(
+                self.upload_url,
+                headers=headers,
+                files=files, # 使用 files 参数上传文件
+                proxies=self.proxies,
+                timeout=60 # 上传可能需要更长时间
+            )
+            if response.status_code == 200:
+                result = response.json()
+                if self.DEBUG:
+                    print(f"图片上传成功! Media ID: {result.get('id')}")
+                # 确保返回的结果中包含上传时使用的API密钥信息
+                result['used_auth_token'] = current_auth_token
+                # print(f"上传响应: {json.dumps(result, indent=2)}") # 可选：打印完整响应
+                return result # 返回包含id, url等信息的字典
+            else:
+                error_msg = f"上传图片失败，状态码: {response.status_code}, 响应: {response.text}"
+                if self.DEBUG:
+                    print(error_msg)
+                
+                # 如果不是已经在重试，且响应表明可能是API密钥问题，尝试切换密钥
+                if not is_retry and (response.status_code in [401, 403] or "auth" in response.text.lower() or "token" in response.text.lower()):
+                    if self.DEBUG:
+                        print(f"上传失败可能与API密钥有关，尝试切换密钥后重试")
+                    
+                    try:
+                        from .key_manager import key_manager
+                        new_key = key_manager.mark_key_invalid(self.auth_token)
+                        if new_key:
+                            self.auth_token = new_key
+                            if self.DEBUG:
+                                print(f"已切换到新的API密钥，重试上传")
+                            # 更新头部信息并重试
+                            new_headers = self._get_dynamic_headers(content_type=None, referer="https://sora.chatgpt.com/library")
+                            return self._try_upload_with_retry(file_path, file_name, mime_type, new_headers, is_retry=True)
+                    except (ImportError, Exception) as e:
+                        if self.DEBUG:
+                            print(f"切换API密钥失败: {str(e)}")
+                
+                return error_msg
+        except Exception as e:
+            error_msg = f"上传图片时出错: {str(e)}"
+            if self.DEBUG:
+                print(error_msg)
+            
+            # 如果不是已经在重试，尝试切换密钥后重试
+            if not is_retry:
+                if self.DEBUG:
+                    print(f"上传过程中发生异常，尝试切换API密钥后重试")
+                
+                try:
+                    from .key_manager import key_manager
+                    new_key = key_manager.mark_key_invalid(self.auth_token)
+                    if new_key:
+                        self.auth_token = new_key
+                        if self.DEBUG:
+                            print(f"已切换到新的API密钥，重试上传")
+                        # 更新头部信息并重试
+                        new_headers = self._get_dynamic_headers(content_type=None, referer="https://sora.chatgpt.com/library")
+                        return self._try_upload_with_retry(file_path, file_name, mime_type, new_headers, is_retry=True)
+                except (ImportError, Exception) as err:
+                    if self.DEBUG:
+                        print(f"切换API密钥失败: {str(err)}")
+            
+            return error_msg
+        finally:
+            # 确保文件句柄被关闭
+            if 'file' in files and files['file'][1]:
+                files['file'][1].close()
+    
+    def generate_image_remix(self, prompt, uploaded_media_id, num_images=1, width=None, height=None):
+        """
+        基于已上传的图片进行重混（Remix）生成新图片
+        参数:
+        prompt (str): 图片生成提示词
+        uploaded_media_id (str): 通过 upload_image 获取的媒体ID (例如 "media_...")
+        num_images (int): 要生成的图片数量
+        width (int, optional): 输出图片宽度。如果为None，可能由API决定。
+        height (int, optional): 输出图片高度。如果为None，可能由API决定。
+        返回:
+        list[str] or str: 成功时返回包含图片URL的列表，失败时返回错误信息字符串
+        """
+        if self.DEBUG:
+            print(f"开始 Remix 图片 (ID: {uploaded_media_id})，提示词: '{prompt}'")
+            
+        # 如果上传图片时使用了特定API密钥，则确保使用同一个密钥进行remix
+        # 在upload_image的返回结果中可能包含used_auth_token
+        if isinstance(uploaded_media_id, dict) and 'id' in uploaded_media_id:
+            if 'used_auth_token' in uploaded_media_id and uploaded_media_id['used_auth_token'] != self.auth_token:
+                if self.DEBUG:
+                    print(f"检测到上传图片时使用了不同的API密钥，切换到匹配的密钥进行Remix操作")
+                self.auth_token = uploaded_media_id['used_auth_token']
+            uploaded_media_id = uploaded_media_id['id']
+        
+        # 获取上传图片的信息，特别是原始尺寸，如果未指定输出尺寸则可能需要
+        # (这里简化，假设API能处理尺寸或���们强制指定)
+        # 实际应用中可能需要先查询 media_id 的详情
+        payload = {
+            "prompt": prompt,
+            "n_variants": num_images,
+            "inpaint_items": [
+                {
+                    "type": "image",
+                    "frame_index": 0,
+                    "preset_id": None,
+                    "generation_id": None,
+                    "upload_media_id": uploaded_media_id, # 关键：引用上传的图片
+                    "source_start_frame": 0,
+                    "source_end_frame": 0,
+                    "crop_bounds": None
+                }
+            ],
+            "operation": "remix", # 关键：操作类型
+            "type": "image_gen",
+            "n_frames": 1,
+            "width": 720, # 可选，如果为None，API可能会基于输入调整
+            "height": 480 # 可选
+        }
+        # 只有当width和height都提供了值时才添加到payload中
+        if width is not None:
+            payload["width"] = width
+        if height is not None:
+            payload["height"] = height
+        try:
+            # 提交任务时使用 library 作为 referer，与示例一致
+            task_id = self._submit_task(payload, referer="https://sora.chatgpt.com/library")
+            if not task_id:
+                # 任务提交失败，尝试切换密钥后重试
+                if self.DEBUG:
+                    print(f"Remix任务提交失败，尝试切换API密钥后重试")
+                
+                try:
+                    # 导入在这里进行以避免循环导入
+                    from .key_manager import key_manager
+                    # 标记当前密钥为无效并获取新密钥
+                    new_key = key_manager.mark_key_invalid(self.auth_token)
+                    if new_key:
+                        self.auth_token = new_key
+                        if self.DEBUG:
+                            print(f"已切换到新的API密钥，重试Remix任务")
+                        # 使用新密钥重试提交任务
+                        task_id = self._submit_task(payload, referer="https://sora.chatgpt.com/library")
+                        if not task_id:
+                            return "Remix任务提交失败（已尝试切换密钥）"
+                    else:
+                        return "Remix任务提交失败（无可用的备用密钥）"
+                except ImportError:
+                    if self.DEBUG:
+                        print(f"无法导入key_manager，无法自动切换密钥")
+                    return "Remix任务提交失败"
+                except Exception as e:
+                    if self.DEBUG:
+                        print(f"切换API密钥时发生错误: {str(e)}")
+                    return f"Remix任务提交失败: {str(e)}"
+            
+            if self.DEBUG:
+                print(f"Remix 任务已提交，ID: {task_id}")
+            # 轮询检查任务状态
+            image_urls = self._poll_task_status(task_id)
+            
+            # 如果轮询返回错误信息，也尝试切换密钥重试
+            if isinstance(image_urls, str) and ("失败" in image_urls or "错误" in image_urls or "error" in image_urls.lower()):
+                if self.DEBUG:
+                    print(f"Remix任务执行失败，尝试切换API密钥后重试")
+                
+                try:
+                    from .key_manager import key_manager
+                    new_key = key_manager.mark_key_invalid(self.auth_token)
+                    if new_key:
+                        self.auth_token = new_key
+                        if self.DEBUG:
+                            print(f"已切换到新的API密钥，重试整个Remix过程")
+                        # 使用新密钥重试整个生成过程
+                        return self.generate_image_remix(prompt, uploaded_media_id, num_images, width, height)
+                except (ImportError, Exception) as e:
+                    if self.DEBUG:
+                        print(f"切换API密钥失败或重试失败: {str(e)}")
+            
+            # 增加图片本地化支持
+            if image_urls and isinstance(image_urls, list):
+                if Config.IMAGE_LOCALIZATION:
+                    if self.DEBUG:
+                        print(f"正在本地化 Remix 生成的 {len(image_urls)} 张图片...")
+                    # 创建事件循环并运行图片本地化
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                    localized_urls = loop.run_until_complete(localize_image_urls(image_urls))
+                    loop.close()
+                    
+                    if self.DEBUG:
+                        print(f"Remix 图片本地化完成")
+                    return localized_urls
+            
+            return image_urls
+        except Exception as e:
+            # 如果发生异常，也尝试切换密钥重试
+            if self.DEBUG:
+                print(f"Remix生成过程中发生异常: {str(e)}，尝试切换API密钥")
+            
+            try:
+                from .key_manager import key_manager
+                new_key = key_manager.mark_key_invalid(self.auth_token)
+                if new_key:
+                    self.auth_token = new_key
+                    if self.DEBUG:
+                        print(f"已切换到新的API密钥，重试整个Remix过程")
+                    # 使用新密钥重试整个生成过程
+                    return self.generate_image_remix(prompt, uploaded_media_id, num_images, width, height)
+            except (ImportError, Exception) as err:
+                if self.DEBUG:
+                    print(f"切换API密钥失败或重试失败: {str(err)}")
+            
+            return f"Remix 生成图片时出错: {str(e)}"
+
+    def _submit_task(self, payload, referer="https://sora.chatgpt.com/explore"):
+        """提交生成任务 (通用，接受payload字典)"""
+        headers = self._get_dynamic_headers(content_type="application/json", referer=referer)
+        
+        # 获取当前的auth_token用于最后可能的释放
+        current_auth_token = self.auth_token
+        
+        try:
+            # 检查是否可以导入key_manager并标记密钥为工作中
+            try:
+                from .key_manager import key_manager
+                # 生成一个临时任务ID，用于标记密钥工作状态
+                temp_task_id = f"pending_task_{self._generate_random_id()}"
+                key_manager.mark_key_as_working(self.auth_token, temp_task_id)
+            except ImportError:
+                if self.DEBUG:
+                    print(f"无法导入key_manager，无法标记密钥工作状态")
+            except Exception as e:
+                if self.DEBUG:
+                    print(f"标记密钥工作状态时发生错误: {str(e)}")
+                
+            response = self.scraper.post(
+                self.gen_url,
+                headers=headers,
+                json=payload,
+                proxies=self.proxies,
+                timeout=20 # 增加超时时间
+            )
+            if response.status_code == 200:
+                try:
+                    result = response.json()
+                    task_id = result.get("id")
+                    if task_id:
+                        # 更新任务ID为实际分配的ID
+                        try:
+                            from .key_manager import key_manager
+                            # 更新工作中状态的任务ID
+                            key_manager.release_key(self.auth_token)  # 先释放临时ID
+                            key_manager.mark_key_as_working(self.auth_token, task_id)  # 用真实ID重新标记
+                            if self.DEBUG:
+                                print(f"已将密钥标记为工作中，任务ID: {task_id}")
+                        except (ImportError, Exception) as e:
+                            if self.DEBUG:
+                                print(f"更新密钥工作状态时发生错误: {str(e)}")
+                        
+                        return task_id
+                    else:
+                        # 任务提交成功但未返回ID，释放密钥
+                        try:
+                            from .key_manager import key_manager
+                            key_manager.release_key(self.auth_token)
+                            if self.DEBUG:
+                                print(f"任务提交未返回ID，已释放密钥")
+                        except (ImportError, Exception) as e:
+                            if self.DEBUG:
+                                print(f"释放密钥时发生错误: {str(e)}")
+                        
+                        # 检查响应中是否有可能表明API密钥问题的信息
+                        response_text = response.text.lower()
+                        is_auth_issue = False
+                        auth_keywords = ["authorization", "auth", "token", "permission", "unauthorized", "credentials", "login"]
+                        
+                        for keyword in auth_keywords:
+                            if keyword in response_text:
+                                is_auth_issue = True
+                                break
+                        
+                        if is_auth_issue:
+                            if self.DEBUG:
+                                print(f"API响应内容表明可能存在认证问题，尝试切换密钥")
+                            
+                            try:
+                                from .key_manager import key_manager
+                                new_key = key_manager.mark_key_invalid(self.auth_token)
+                                if new_key:
+                                    self.auth_token = new_key
+                                    if self.DEBUG:
+                                        print(f"已切换到新的API密钥，重试请求")
+                                    # 使用新密钥重试请求
+                                    return self._submit_task(payload, referer)
+                            except ImportError:
+                                if self.DEBUG:
+                                    print(f"无法导入key_manager，无法自动切换密钥")
+                            except Exception as e:
+                                if self.DEBUG:
+                                    print(f"切换API密钥时发生错误: {str(e)}")
+                        
+                        if self.DEBUG:
+                            print(f"提交任务成功，但响应中未找到任务ID。响应: {response.text}")
+                        return None
+                except json.JSONDecodeError:
+                    # 释放密钥
+                    try:
+                        from .key_manager import key_manager
+                        key_manager.release_key(self.auth_token)
+                        if self.DEBUG:
+                            print(f"JSON解析失败，已释放密钥")
+                    except (ImportError, Exception) as e:
+                        if self.DEBUG:
+                            print(f"释放密钥时发生错误: {str(e)}")
+                            
+                    if self.DEBUG:
+                        print(f"提交任务成功，但无法解析响应JSON。状态码: {response.status_code}, 响应: {response.text}")
+                    return None
+            else:
+                # 释放密钥
+                try:
+                    from .key_manager import key_manager
+                    key_manager.release_key(self.auth_token)
+                    if self.DEBUG:
+                        print(f"请求失败，已释放密钥")
+                except (ImportError, Exception) as e:
+                    if self.DEBUG:
+                        print(f"释放密钥时发生错误: {str(e)}")
+                
+                if self.DEBUG:
+                    print(f"提交任务失败，状态码: {response.status_code}")
+                if self.DEBUG:
+                    print(f"请求Payload: {json.dumps(payload)}")
+                if self.DEBUG:
+                    print(f"响应内容: {response.text}")
+                
+                # 特殊处理429错误（太多并发任务）
+                if response.status_code == 429:
+                    response_text = response.text.lower()
+                    is_concurrent_issue = (
+                        "concurrent" in response_text or 
+                        "too many" in response_text or 
+                        "wait" in response_text or
+                        "progress" in response_text
+                    )
+                    
+                    if is_concurrent_issue:
+                        if self.DEBUG:
+                            print(f"检测到并发限制错误，当前密钥正在处理其他任务，获取新密钥但不禁用当前密钥")
+                        try:
+                            from .key_manager import key_manager
+                            # 不标记为无效，但获取一个新的可用密钥
+                            new_key = key_manager.get_key()
+                            if new_key:
+                                self.auth_token = new_key
+                                if self.DEBUG:
+                                    print(f"已获取新的API密钥，重试请求")
+                                # 使用新密钥重试请求
+                                return self._submit_task(payload, referer)
+                            else:
+                                if self.DEBUG:
+                                    print(f"没有可用的备用密钥")
+                        except (ImportError, Exception) as e:
+                            if self.DEBUG:
+                                print(f"获取新密钥时发生错误: {str(e)}")
+                        return None
+                
+                # 检查是否是认证失败（401/403）或其他可能表明API密钥失效的情况
+                response_text = response.text.lower()
+                is_auth_issue = (
+                    response.status_code in [401, 403] or
+                    "authorization" in response_text or
+                    "auth" in response_text or
+                    "token" in response_text or
+                    "permission" in response_text or
+                    "unauthorized" in response_text or
+                    "credentials" in response_text or
+                    "login" in response_text or
+                    "invalid" in response_text
+                ) and not (
+                    # 排除并发限制导致的错误
+                    "concurrent" in response_text or 
+                    "too many" in response_text or 
+                    "wait" in response_text or
+                    "progress" in response_text
+                )
+                
+                if is_auth_issue:
+                    if self.DEBUG:
+                        print(f"API密钥可能已失效，尝试切换密钥")
+                    
+                    try:
+                        # 导入在这里进行以避免循环导入
+                        from .key_manager import key_manager
+                        # 标记当前密钥为无效并获取新密钥
+                        new_key = key_manager.mark_key_invalid(self.auth_token)
+                        if new_key:
+                            self.auth_token = new_key
+                            if self.DEBUG:
+                                print(f"已切换到新的API密钥，重试请求")
+                            # 使用新密钥重试请求
+                            return self._submit_task(payload, referer)
+                    except ImportError:
+                        if self.DEBUG:
+                            print(f"无法导入key_manager，无法自动切换密钥")
+                    except Exception as e:
+                        if self.DEBUG:
+                            print(f"切换API密钥时发生错误: {str(e)}")
+                            
+                return None
+        except Exception as e:
+            # 确保释放密钥
+            try:
+                from .key_manager import key_manager
+                key_manager.release_key(current_auth_token)
+                if self.DEBUG:
+                    print(f"发生异常，已释放密钥")
+            except (ImportError, Exception) as release_err:
+                if self.DEBUG:
+                    print(f"释放密钥时发生错误: {str(release_err)}")
+                
+            if self.DEBUG:
+                print(f"提交任务时出错: {str(e)}")
+            
+            # 检查异常信息中是否包含可能的认证问题
+            error_str = str(e).lower()
+            is_auth_issue = (
+                "authorization" in error_str or
+                "auth" in error_str or
+                "token" in error_str or
+                "permission" in error_str or
+                "unauthorized" in error_str or
+                "credentials" in error_str or
+                "login" in error_str
+            )
+            
+            if is_auth_issue:
+                if self.DEBUG:
+                    print(f"异常信息表明可能存在API密钥问题，尝试切换密钥")
+                
+                try:
+                    from .key_manager import key_manager
+                    new_key = key_manager.mark_key_invalid(self.auth_token)
+                    if new_key:
+                        self.auth_token = new_key
+                        if self.DEBUG:
+                            print(f"已切换到新的API密钥，重试请求")
+                        # 使用新密钥重试请求
+                        return self._submit_task(payload, referer)
+                except (ImportError, Exception) as err:
+                    if self.DEBUG:
+                        print(f"切换API密钥失败: {str(err)}")
+            
+            return None
+            
+    def _poll_task_status(self, task_id, max_attempts=40, interval=5):
+        """
+        轮询检查任务状态，直到完成，返回所有生成的图片URL列表
+        """
+        # 保存当前使用的密钥，确保最后可以正确释放
+        current_auth_token = self.auth_token
+        
+        if self.DEBUG:
+            print(f"开始轮询任务 {task_id} 的状态...")
+        try:
+            for attempt in range(max_attempts):
+                try:
+                    headers = self._get_dynamic_headers(referer="https://sora.chatgpt.com/library") # Polling often happens from library view
+                    query_url = f"{self.check_url}?limit=10" # 获取最近的任务，减少数据量
+                    response = self.scraper.get(
+                        query_url,
+                        headers=headers,
+                        proxies=self.proxies,
+                        timeout=15
+                    )
+                    if response.status_code == 200:
+                        try:
+                            result = response.json()
+                            task_responses = result.get("task_responses", [])
+                            # 查找对应的任务
+                            for task in task_responses:
+                                if task.get("id") == task_id:
+                                    status = task.get("status")
+                                    if self.DEBUG:
+                                        print(f"  任务 {task_id} 状态: {status} (尝试 {attempt+1}/{max_attempts})")
+                                    if status == "succeeded":
+                                        # 任务成功完成，释放密钥
+                                        try:
+                                            from .key_manager import key_manager
+                                            key_manager.release_key(current_auth_token)
+                                            if self.DEBUG:
+                                                print(f"任务成功完成，已释放密钥")
+                                        except (ImportError, Exception) as e:
+                                            if self.DEBUG:
+                                                print(f"释放密钥时发生错误: {str(e)}")
+                                                
+                                        generations = task.get("generations", [])
+                                        image_urls = []
+                                        if generations:
+                                            for gen in generations:
+                                                url = gen.get("url")
+                                                if url:
+                                                    image_urls.append(url)
+                                        if image_urls:
+                                            if self.DEBUG:
+                                                print(f"任务 {task_id} 成功完成！找到 {len(image_urls)} 张图片。")
+                                            return image_urls
+                                        else:
+                                            if self.DEBUG:
+                                                print(f"任务 {task_id} 状态为 succeeded，但在响应中未找到有效的图片URL。")
+                                            if self.DEBUG:
+                                                print(f"任务详情: {json.dumps(task, indent=2)}")
+                                            return "任务成功但未找到图片URL"
+                                    elif status == "failed":
+                                        # 任务失败，释放密钥
+                                        try:
+                                            from .key_manager import key_manager
+                                            key_manager.release_key(current_auth_token)
+                                            if self.DEBUG:
+                                                print(f"任务失败，已释放密钥")
+                                        except (ImportError, Exception) as e:
+                                            if self.DEBUG:
+                                                print(f"释放密钥时发生错误: {str(e)}")
+                                                
+                                        failure_reason = task.get("failure_reason", "未知原因")
+                                        if self.DEBUG:
+                                            print(f"任务 {task_id} 失败: {failure_reason}")
+                                        # 检查是否是因为API密钥问题导致的失败
+                                        failure_reason_lower = failure_reason.lower()
+                                        auth_keywords = [
+                                            "authorization", "auth", "token", "permission", 
+                                            "unauthorized", "credentials", "login", "invalid"
+                                        ]
+                                        is_auth_issue = any(keyword in failure_reason_lower for keyword in auth_keywords)
+                                        
+                                        if is_auth_issue:
+                                            if self.DEBUG:
+                                                print(f"检测到API密钥可能失效，尝试切换密钥")
+                                            try:
+                                                # 导入在这里进行以避免循环导入
+                                                from .key_manager import key_manager
+                                                # 标记当前密钥为无效并获取新密钥
+                                                new_key = key_manager.mark_key_invalid(self.auth_token)
+                                                if new_key:
+                                                    self.auth_token = new_key
+                                                    if self.DEBUG:
+                                                        print(f"已切换到新的API密钥")
+                                            except ImportError:
+                                                if self.DEBUG:
+                                                    print(f"无法导入key_manager，无法自动切换密钥")
+                                            except Exception as e:
+                                                if self.DEBUG:
+                                                    print(f"切换API密钥时发生错误: {str(e)}")
+                                            return f"任务失败: {failure_reason}"
+                                    elif status in ["rejected", "needs_user_review"]:
+                                        # 任务被拒绝，释放密钥
+                                        try:
+                                            from .key_manager import key_manager
+                                            key_manager.release_key(current_auth_token)
+                                            if self.DEBUG:
+                                                print(f"任务被拒绝，已释放密钥")
+                                        except (ImportError, Exception) as e:
+                                            if self.DEBUG:
+                                                print(f"释放密钥时发生错误: {str(e)}")
+                                                
+                                        if self.DEBUG:
+                                            print(f"任务 {task_id} 被拒绝或需要审查: {status}")
+                                        return f"任务被拒绝或需审查: {status}"
+                                    # else status is pending, processing, etc. - continue polling
+                                    break # Found the task, no need to check others in this response
+                            else:
+                                # Task ID not found in the recent list, maybe it's older or just submitted
+                                if self.DEBUG:
+                                    print(f"  未在最近任务列表中找到 {task_id}，继续等待... (尝试 {attempt+1}/{max_attempts})")
+                        except json.JSONDecodeError:
+                            if self.DEBUG:
+                                print(f"检查任务状态时无法解析响应JSON。状态码: {response.status_code}, 响应: {response.text}")
+                    else:
+                        if self.DEBUG:
+                            print(f"检查任务状态失败，状态码: {response.status_code}, 响应: {response.text}")
+                        
+                        # 检查是否是认证失败或其他可能表明API密钥失效的情况
+                        response_text = response.text.lower()
+                        is_auth_issue = (
+                            response.status_code in [401, 403, 429] or
+                            "authorization" in response_text or
+                            "auth" in response_text or
+                            "token" in response_text or
+                            "permission" in response_text or
+                            "unauthorized" in response_text or
+                            "credentials" in response_text or
+                            "login" in response_text or
+                            "invalid" in response_text
+                        )
+                        
+                        if is_auth_issue:
+                            if self.DEBUG:
+                                print(f"API密钥可能已失效，尝试切换密钥")
+                            
+                            try:
+                                # 导入在这里进行以避免循环导入
+                                from .key_manager import key_manager
+                                # 标记当前密钥为无效并获取新密钥
+                                new_key = key_manager.mark_key_invalid(self.auth_token)
+                                if new_key:
+                                    self.auth_token = new_key
+                                    if self.DEBUG:
+                                        print(f"已切换到新的API密钥，重试请求")
+                                    # 使用新密钥继续轮询
+                                    continue
+                            except ImportError:
+                                if self.DEBUG:
+                                    print(f"无法导入key_manager，无法自动切换密钥")
+                            except Exception as e:
+                                if self.DEBUG:
+                                    print(f"切换API密钥时发生错误: {str(e)}")
+                                    
+                    time.sleep(interval)  # 等待一段时间后再次检查
+                except Exception as e:
+                    if self.DEBUG:
+                        print(f"检查任务状态时出错: {str(e)}")
+                    
+                    # 检查异常信息中是否包含可能的认证问题
+                    error_str = str(e).lower()
+                    is_auth_issue = (
+                        "authorization" in error_str or
+                        "auth" in error_str or
+                        "token" in error_str or
+                        "permission" in error_str or
+                        "unauthorized" in error_str or
+                        "credentials" in error_str or
+                        "login" in error_str
+                    )
+                    
+                    if is_auth_issue:
+                        if self.DEBUG:
+                            print(f"异常信息表明可能存在API密钥问题，尝试切换密钥")
+                        
+                        try:
+                            from .key_manager import key_manager
+                            new_key = key_manager.mark_key_invalid(self.auth_token)
+                            if new_key:
+                                self.auth_token = new_key
+                                if self.DEBUG:
+                                    print(f"已切换到新的API密钥，重试请求")
+                                # 重置当前尝试次数，继续轮询
+                                continue
+                        except (ImportError, Exception) as err:
+                            if self.DEBUG:
+                                print(f"切换API密钥失败: {str(err)}")
+                    
+                    # Add a slightly longer delay on error to avoid hammering the server
+                    time.sleep(interval * 1.5)
+            
+            # 如果达到最大尝试次数，释放密钥
+            try:
+                from .key_manager import key_manager
+                key_manager.release_key(current_auth_token)
+                if self.DEBUG:
+                    print(f"轮询超时，已释放密钥")
+            except (ImportError, Exception) as e:
+                if self.DEBUG:
+                    print(f"释放密钥时发生错误: {str(e)}")
+                    
+            return f"任务 {task_id} 超时 ({max_attempts * interval}秒)，未能获取最终状态"
+        except Exception as e:
+            # 确保在异常情况下也释放密钥
+            try:
+                from .key_manager import key_manager
+                key_manager.release_key(current_auth_token)
+                if self.DEBUG:
+                    print(f"轮询过程发生异常，已释放密钥")
+            except (ImportError, Exception) as release_err:
+                if self.DEBUG:
+                    print(f"释放密钥时发生错误: {str(release_err)}")
+                
+            if self.DEBUG:
+                print(f"轮询任务状态时发生未处理的异常: {str(e)}")
+            import traceback
+            traceback.print_exc()
+            return f"轮询任务状态时出错: {str(e)}"
+
+    def test_connection(self):
+        """
+        测试API连接是否有效，仅发送一个轻量级请求
+        返回:
+        dict: 包含连接状态信息的字典
+        """
+        start_time = time.time()  # 记录开始时间，用于计算响应时间
+        success = False  # 初始化请求结果标识
+        
+        try:
+            # 使用简单的GET请求来验证连接和认证
+            headers = self._get_dynamic_headers(referer="https://sora.chatgpt.com/explore")
+            response = self.scraper.get(
+                "https://sora.chatgpt.com/backend/parameters",
+                headers=headers,
+                proxies=self.proxies,
+                timeout=10
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                # 检查返回的数据中是否含有关键字段，确认API确实有效
+                api_valid = result.get("can_create_images") is not None or "limits_for_images" in result
+                
+                if api_valid:
+                    success = True  # 标记请求成功
+                    # 记录请求结果（成功）
+                    try:
+                        from .key_manager import key_manager
+                        response_time = time.time() - start_time
+                        key_manager.record_request_result(self.auth_token, success, response_time)
+                    except (ImportError, Exception) as e:
+                        if self.DEBUG:
+                            print(f"记录请求结果失败: {str(e)}")
+                    
+                    return {
+                        "status": "success",
+                        "message": "API连接测试成功",
+                        "data": result
+                    }
+                else:
+                    # API返回200但数据不符合预期
+                    success = False  # 标记请求失败
+                    
+                    # 记录请求结果（失败）
+                    try:
+                        from .key_manager import key_manager
+                        response_time = time.time() - start_time
+                        key_manager.record_request_result(self.auth_token, success, response_time)
+                    except (ImportError, Exception) as e:
+                        if self.DEBUG:
+                            print(f"记录请求结果失败: {str(e)}")
+                    
+                    return {
+                        "status": "error",
+                        "message": "API连接测试失败：返回数据格式不符合预期",
+                        "response": result
+                    }
+            else:
+                # 检查是否是认证失败或其他可能表明API密钥失效的情况
+                response_text = response.text.lower()
+                is_auth_issue = (
+                    response.status_code in [401, 403, 429] or
+                    "authorization" in response_text or
+                    "auth" in response_text or
+                    "token" in response_text or
+                    "permission" in response_text or
+                    "unauthorized" in response_text or
+                    "credentials" in response_text or
+                    "login" in response_text or
+                    "invalid" in response_text
+                )
+                
+                success = False  # 标记请求失败
+                
+                # 记录请求结果（失败）
+                try:
+                    from .key_manager import key_manager
+                    response_time = time.time() - start_time
+                    key_manager.record_request_result(self.auth_token, success, response_time)
+                except (ImportError, Exception) as e:
+                    if self.DEBUG:
+                        print(f"记录请求结果失败: {str(e)}")
+                
+                if is_auth_issue:
+                    if self.DEBUG:
+                        print(f"API密钥可能已失效，尝试切换密钥")
+                    
+                    try:
+                        # 导入在这里进行以避免循环导入
+                        from .key_manager import key_manager
+                        # 标记当前密钥为无效并获取新密钥
+                        new_key = key_manager.mark_key_invalid(self.auth_token)
+                        if new_key:
+                            self.auth_token = new_key
+                            if self.DEBUG:
+                                print(f"已切换到新的API密钥，重试连接测试")
+                            # 使用新密钥重试
+                            return self.test_connection()
+                    except ImportError:
+                        if self.DEBUG:
+                            print(f"无法导入key_manager，无法自动切换密钥")
+                    except Exception as e:
+                        if self.DEBUG:
+                            print(f"切换API密钥时发生错误: {str(e)}")
+                
+                return {
+                    "status": "error",
+                    "message": f"API连接测试失败，状态码: {response.status_code}",
+                    "response": response.text
+                }
+        except Exception as e:
+            success = False  # 标记请求失败
+            
+            # 记录请求结果（异常失败）
+            try:
+                from .key_manager import key_manager
+                response_time = time.time() - start_time
+                key_manager.record_request_result(self.auth_token, success, response_time)
+            except (ImportError, Exception) as err:
+                if self.DEBUG:
+                    print(f"记录请求结果失败: {str(err)}")
+            
+            # 检查异常信息中是否包含可能的认证问题
+            error_str = str(e).lower()
+            is_auth_issue = (
+                "authorization" in error_str or
+                "auth" in error_str or
+                "token" in error_str or
+                "permission" in error_str or
+                "unauthorized" in error_str or
+                "credentials" in error_str or
+                "login" in error_str
+            )
+            
+            if is_auth_issue:
+                if self.DEBUG:
+                    print(f"异常信息表明可能存在API密钥问题，尝试切换密钥")
+                
+                try:
+                    from .key_manager import key_manager
+                    new_key = key_manager.mark_key_invalid(self.auth_token)
+                    if new_key:
+                        self.auth_token = new_key
+                        if self.DEBUG:
+                            print(f"已切换到新的API密钥，重试连接测试")
+                        # 使用新密钥重试
+                        return self.test_connection()
+                except (ImportError, Exception) as err:
+                    if self.DEBUG:
+                        print(f"切换API密钥失败: {str(err)}")
+            
+            raise Exception(f"API连接测试失败: {str(e)}") 

src/sora_integration.py

@@ -0,0 +1,114 @@
+import asyncio
+import concurrent.futures
+from typing import List, Dict, Any, Optional, Union
+import json
+import os
+import base64
+import tempfile
+import uuid
+
+# 导入原有的SoraImageGenerator类
+from .sora_generator import SoraImageGenerator
+
+class SoraClient:
+    def __init__(self, proxy_host=None, proxy_port=None, proxy_user=None, proxy_pass=None, auth_token=None):
+        """初始化Sora客户端，使用cloudscraper绕过CF验证"""
+        self.generator = SoraImageGenerator(
+            proxy_host=proxy_host, 
+            proxy_port=proxy_port,
+            proxy_user=proxy_user,
+            proxy_pass=proxy_pass,
+            auth_token=auth_token
+        )
+        # 保存原始的auth_token，用于检测是否已更新
+        self.auth_token = auth_token
+        # 创建线程池执行器
+        self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=10)
+        
+    async def generate_image(self, prompt: str, num_images: int = 1, 
+                           width: int = 720, height: int = 480) -> List[str]:
+        """异步包装SoraImageGenerator.generate_image方法"""
+        loop = asyncio.get_running_loop()
+        # 使用线程池执行同步方法（因为cloudscraper不是异步的）
+        result = await loop.run_in_executor(
+            self.executor, 
+            lambda: self.generator.generate_image(prompt, num_images, width, height)
+        )
+        
+        # 检查generator中的auth_token是否已经被更新（由自动切换密钥机制）
+        if self.generator.auth_token != self.auth_token:
+            self.auth_token = self.generator.auth_token
+        
+        if isinstance(result, list):
+            return result
+        else:
+            raise Exception(f"图像生成失败: {result}")
+    
+    async def upload_image(self, image_path: str) -> Dict:
+        """异步包装上传图片方法"""
+        loop = asyncio.get_running_loop()
+        result = await loop.run_in_executor(
+            self.executor,
+            lambda: self.generator.upload_image(image_path)
+        )
+        
+        # 检查generator中的auth_token是否已经被更新
+        if self.generator.auth_token != self.auth_token:
+            self.auth_token = self.generator.auth_token
+        
+        if isinstance(result, dict) and 'id' in result:
+            return result
+        else:
+            raise Exception(f"图片上传失败: {result}")
+            
+    async def generate_image_remix(self, prompt: str, media_id: str, 
+                                 num_images: int = 1) -> List[str]:
+        """异步包装remix方法"""
+        loop = asyncio.get_running_loop()
+        
+        # 处理可能包含API密钥信息的media_id对象
+        if isinstance(media_id, dict) and 'id' in media_id:
+            # 如果上传时使用的密钥与当前不同，则先切换密钥
+            if 'used_auth_token' in media_id and media_id['used_auth_token'] != self.auth_token:
+                self.auth_token = media_id['used_auth_token']
+                # 同步更新generator的auth_token
+                self.generator.auth_token = self.auth_token
+            # 提取实际的media_id
+            media_id = media_id['id']
+            
+        result = await loop.run_in_executor(
+            self.executor,
+            lambda: self.generator.generate_image_remix(prompt, media_id, num_images)
+        )
+        
+        # 检查generator中的auth_token是否已经被更新
+        if self.generator.auth_token != self.auth_token:
+            self.auth_token = self.generator.auth_token
+        
+        if isinstance(result, list):
+            return result
+        else:
+            raise Exception(f"Remix生成失败: {result}")
+            
+    async def test_connection(self) -> Dict:
+        """测试API连接是否有效"""
+        try:
+            # 简单测试上传功能，这个方法会调用API但不会真正上传文件
+            loop = asyncio.get_running_loop()
+            result = await loop.run_in_executor(
+                self.executor,
+                lambda: self.generator.test_connection()
+            )
+            
+            # 检查generator中的auth_token是否已经被更新
+            if self.generator.auth_token != self.auth_token:
+                self.auth_token = self.generator.auth_token
+            
+            # 直接返回generator.test_connection的结果，保留所有信息
+            return result
+        except Exception as e:
+            return {"status": "error", "message": f"API连接测试失败: {str(e)}"}
+            
+    def close(self):
+        """关闭线程池"""
+        self.executor.shutdown(wait=False) 

src/static/admin/config.html

@@ -0,0 +1,99 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Sora API - 配置管理</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha1/dist/css/bootstrap.min.css" rel="stylesheet">
+    <link href="css/admin.css" rel="stylesheet">
+</head>
+<body>
+    <div class="container">
+        <h1 class="my-4">Sora API - 配置管理</h1>
+        
+        <div id="messages" class="mb-4"></div>
+        
+        <div class="card mb-4">
+            <div class="card-header">
+                <h5 class="mb-0">系统配置</h5>
+            </div>
+            <div class="card-body">
+                <form id="configForm">
+                    <div class="mb-3">
+                        <label class="form-label fw-bold">HTTP代理设置</label>
+                        <div class="row g-3">
+                            <div class="col-md-6">
+                                <label for="proxy_host" class="form-label">代理主机</label>
+                                <input type="text" class="form-control" id="proxy_host" placeholder="例如: 127.0.0.1">
+                            </div>
+                            <div class="col-md-6">
+                                <label for="proxy_port" class="form-label">代理端口</label>
+                                <input type="text" class="form-control" id="proxy_port" placeholder="例如: 7890">
+                            </div>
+                        </div>
+                        <div class="mt-3">
+                            <label class="form-label">代理认证 (可选)</label>
+                            <div class="row g-3">
+                                <div class="col-md-6">
+                                    <label for="proxy_user" class="form-label">用户名</label>
+                                    <input type="text" class="form-control" id="proxy_user" placeholder="代理用户名">
+                                </div>
+                                <div class="col-md-6">
+                                    <label for="proxy_pass" class="form-label">密码</label>
+                                    <input type="password" class="form-control" id="proxy_pass" placeholder="代理密码">
+                                </div>
+                            </div>
+                        </div>
+                        <div class="form-text text-muted mt-2">如需使用代理访问Sora API，请填写以上信息，留空表示不使用代理</div>
+                    </div>
+                    
+                    <hr>
+                    
+                    <div class="mb-3">
+                        <label class="form-label fw-bold">图片本地化设置</label>
+                        <div class="form-check form-switch">
+                            <input class="form-check-input" type="checkbox" id="image_localization">
+                            <label class="form-check-label" for="image_localization">启用图片本地化</label>
+                        </div>
+                        <div class="form-text text-muted">启用后，Sora生成的图片将被下载并保存到本地服务器，避免客户端无法访问外部链接的问题</div>
+                    </div>
+                    
+                    <div class="mb-3">
+                        <label for="image_save_dir" class="form-label">图片保存目录</label>
+                        <input type="text" class="form-control" id="image_save_dir" placeholder="src/static/images">
+                        <div class="form-text text-muted">相对于工作目录的路径，必须确保目录存在且有写入权限</div>
+                    </div>
+                    
+                    <button type="button" id="saveConfig" class="btn btn-primary">保存配置</button>
+                </form>
+            </div>
+        </div>
+        
+        <div class="card mb-4">
+            <div class="card-header">
+                <h5 class="mb-0">帮助说明</h5>
+            </div>
+            <div class="card-body">
+                <p><strong>HTTP代理设置：</strong></p>
+                <ul>
+                    <li>如果您的服务器无法直接访问Sora API，可以配置HTTP代理</li>
+                    <li>代理认证是可选的，如果您的代理服务器不需要认证，请留空</li>
+                    <li>在Docker环境中，代理主机通常设置为<code>host.docker.internal</code>而不是<code>127.0.0.1</code></li>
+                </ul>
+                
+                <p><strong>图片本地化功能说明：</strong></p>
+                <ul>
+                    <li>本功能解决Sora图片URL无法访问的问题，将生成的图片保存到本地服务器</li>
+                    <li>启用后，系统会自动下载Sora返回的图片并存储到指定目录</li>
+                    <li>API返回的图片链接将替换为本地URL地址</li>
+                    <li>确保���置的保存目录有足够的磁盘空间和访问权限</li>
+                </ul>
+                <p class="text-warning"><strong>注意：</strong> 配置变更会立即生效，但不会影响已经生成的图片</p>
+            </div>
+        </div>
+    </div>
+    
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha1/dist/js/bootstrap.bundle.min.js"></script>
+    <script src="js/config.js"></script>
+</body>
+</html> 

src/static/admin/css/style.css

@@ -0,0 +1,424 @@
+/* 全局样式 */
+:root {
+    --sidebar-width: 250px;
+    --sidebar-bg: #343a40;
+    --sidebar-color: #fff;
+    --primary-color: #0d6efd;
+    --success-color: #198754;
+    --warning-color: #ffc107;
+    --danger-color: #dc3545;
+    --info-color: #0dcaf0;
+    --transition-speed: 0.3s;
+}
+
+body {
+    font-family: 'Segoe UI', 'Microsoft YaHei', 'Arial', sans-serif;
+    background-color: #f8f9fa;
+    overflow-x: hidden;
+    margin: 0;
+    padding: 0;
+    min-height: 100vh;
+}
+
+/* 登录页面样式 */
+#login-container, .login-container {
+    background-color: #f8f9fa;
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100vh;
+    z-index: 1050;
+    align-items: center;
+    justify-content: center;
+}
+
+#login-container .card {
+    box-shadow: 0 10px 30px rgba(0, 0, 0, 0.1);
+    border-radius: 15px;
+    overflow: hidden;
+    width: 400px;
+    max-width: 90%;
+}
+
+#login-container .card-header {
+    background-color: var(--primary-color);
+    padding: 1.5rem 1rem;
+}
+
+#login-container .bi-shield-lock {
+    color: var(--primary-color);
+}
+
+#login-form .btn-primary {
+    background-color: var(--primary-color);
+    border-color: var(--primary-color);
+    padding: 0.6rem 1.2rem;
+    font-weight: 500;
+}
+
+#login-form .btn-primary:hover {
+    background-color: #0b5ed7;
+    border-color: #0a58ca;
+}
+
+#login-error {
+    border-radius: 8px;
+}
+
+/* 页面布局 */
+.wrapper {
+    display: flex;
+    width: 100%;
+    min-height: 100vh;
+    align-items: stretch;
+    position: relative;
+}
+
+/* 侧边栏样式 */
+#sidebar {
+    min-width: 250px;
+    max-width: 250px;
+    background: var(--sidebar-bg);
+    color: var(--sidebar-color);
+    transition: all var(--transition-speed);
+    height: 100vh;
+    position: fixed;
+    z-index: 999;
+    box-shadow: 0 0 15px rgba(0, 0, 0, 0.1);
+    top: 0;
+    left: 0;
+}
+
+#sidebar.active {
+    margin-left: -250px;
+}
+
+#sidebar .sidebar-header {
+    padding: 20px;
+    background: #212529;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+#sidebar ul.components {
+    padding: 20px 0;
+    height: calc(100vh - 140px);
+    overflow-y: auto;
+}
+
+#sidebar ul li a {
+    padding: 12px 20px;
+    font-size: 1.1em;
+    display: block;
+    color: #fff;
+    text-decoration: none;
+    transition: all 0.3s;
+    border-left: 3px solid transparent;
+}
+
+#sidebar ul li a:hover {
+    background: #495057;
+    border-left: 3px solid var(--primary-color);
+}
+
+#sidebar ul li.active > a {
+    background: var(--primary-color);
+    color: white;
+    border-left: 3px solid #fff;
+}
+
+#sidebar ul li.sidebar-footer {
+    margin-top: auto;
+    border-top: 1px solid rgba(255, 255, 255, 0.1);
+    position: absolute;
+    bottom: 0;
+    width: 100%;
+}
+
+#sidebar ul li.sidebar-footer a {
+    color: rgba(255, 255, 255, 0.8);
+}
+
+#sidebar ul li.sidebar-footer a:hover {
+    background: rgba(220, 53, 69, 0.6);
+    color: white;
+}
+
+/* 主内容区样式 */
+#content {
+    width: calc(100% - 250px);
+    padding: 0;
+    min-height: 100vh;
+    transition: all 0.3s;
+    position: absolute;
+    right: 0;
+    overflow-x: hidden;
+}
+
+#content.active {
+    width: 100%;
+}
+
+/* 内容页面样式 */
+.content-page {
+    display: none;
+    padding: 0 20px 30px;
+}
+
+.content-page.active {
+    display: block;
+    animation: fadeIn 0.3s;
+}
+
+/* 表格样式 */
+.table th {
+    font-weight: 600;
+    border-top: none;
+    white-space: nowrap;
+}
+
+.table td {
+    vertical-align: middle;
+}
+
+/* 状态标签样式 */
+.status-badge {
+    display: inline-block;
+    padding: 0.25em 0.6em;
+    font-size: 85%;
+    font-weight: 600;
+    line-height: 1;
+    text-align: center;
+    white-space: nowrap;
+    vertical-align: baseline;
+    border-radius: 0.25rem;
+    cursor: help;
+}
+
+.status-enabled {
+    background-color: var(--success-color);
+    color: white;
+}
+
+.status-disabled {
+    background-color: var(--danger-color);
+    color: white;
+}
+
+.status-temp-disabled {
+    background-color: var(--warning-color);
+    color: black;
+    position: relative;
+}
+
+/* 为临时禁用状态的提示信息添加样式 */
+.small.text-muted {
+    font-size: 0.75rem;
+    display: block;
+    margin-top: 3px;
+}
+
+/* 让状态标签支持鼠标悬停提示 */
+.status-badge:hover {
+    background-color: #ffd700;
+    color: black;
+}
+
+/* 响应式调整 */
+@media (max-width: 768px) {
+    #sidebar {
+        margin-left: -250px;
+    }
+    #sidebar.active {
+        margin-left: 0;
+    }
+    #content {
+        width: 100%;
+    }
+    #content.active {
+        width: calc(100% - 250px);
+    }
+    #sidebarCollapse {
+        display: block;
+    }
+    .navbar .container-fluid {
+        padding-left: 10px;
+        padding-right: 10px;
+    }
+}
+
+/* 卡片样式美化 */
+.card {
+    border: none;
+    border-radius: 10px;
+    box-shadow: 0 2px 10px rgba(0, 0, 0, 0.05);
+    margin-bottom: 20px;
+    overflow: hidden;
+}
+
+.card-header {
+    background-color: #fff;
+    border-bottom: 1px solid rgba(0, 0, 0, 0.05);
+    padding: 15px 20px;
+    font-weight: 500;
+}
+
+.card-body {
+    padding: 20px;
+}
+
+/* 按钮样式 */
+.btn-primary {
+    background-color: var(--primary-color);
+    border-color: var(--primary-color);
+}
+
+.btn-primary:hover {
+    background-color: #0b5ed7;
+    border-color: #0a58ca;
+}
+
+.btn-success {
+    background-color: var(--success-color);
+    border-color: var(--success-color);
+}
+
+.btn-danger {
+    background-color: var(--danger-color);
+    border-color: var(--danger-color);
+}
+
+/* 表单元素样式 */
+.form-control:focus {
+    border-color: var(--primary-color);
+    box-shadow: 0 0 0 0.2rem rgba(13, 110, 253, 0.25);
+}
+
+/* 操作按钮样式 */
+.action-btn {
+    margin-right: 5px;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 2.2rem;
+    height: 2.2rem;
+    padding: 0;
+    border-radius: 50%;
+}
+
+.action-btn i {
+    font-size: 0.9rem;
+}
+
+/* 密钥值样式 */
+.key-value {
+    max-width: 180px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    font-family: monospace;
+    font-size: 0.9rem;
+}
+
+/* 统计卡片样式 */
+.card.bg-primary, .card.bg-success, .card.bg-danger, .card.bg-info {
+    box-shadow: 0 4px 10px rgba(0, 0, 0, 0.1);
+    transition: transform 0.3s ease;
+}
+
+.card.bg-primary:hover, .card.bg-success:hover, .card.bg-danger:hover, .card.bg-info:hover {
+    transform: translateY(-5px);
+}
+
+.card.bg-primary .card-title, .card.bg-success .card-title, 
+.card.bg-danger .card-title, .card.bg-info .card-title {
+    font-size: 1rem;
+    opacity: 0.9;
+}
+
+.card.bg-primary .card-text, .card.bg-success .card-text, 
+.card.bg-danger .card-text, .card.bg-info .card-text {
+    font-size: 1.8rem;
+    font-weight: 600;
+}
+
+/* 图表容器 */
+canvas {
+    width: 100% !important;
+    height: 300px !important;
+}
+
+/* 导航栏样式 */
+.navbar {
+    box-shadow: 0 0.125rem 0.25rem rgba(0, 0, 0, 0.075);
+    background-color: #fff !important;
+}
+
+/* 管理员密钥显示 */
+#admin-key-display {
+    font-size: 0.8rem;
+    font-family: monospace;
+}
+
+/* Toast通知样式 */
+.toast {
+    border-radius: 8px;
+    box-shadow: 0 0.5rem 1rem rgba(0, 0, 0, 0.15);
+}
+
+/* 动画效果 */
+@keyframes fadeIn {
+    from { opacity: 0; }
+    to { opacity: 1; }
+}
+
+/* 最近的API密钥列表样式 */
+#recent-keys-list .list-group-item {
+    padding: 0.75rem 1rem;
+    border-left: none;
+    border-right: none;
+}
+
+#recent-keys-list .list-group-item:hover {
+    background-color: rgba(13, 110, 253, 0.05);
+}
+
+/* 模态框样式 */
+.modal-content {
+    border-radius: 12px;
+    border: none;
+    box-shadow: 0 0.5rem 1rem rgba(0, 0, 0, 0.15);
+    overflow: hidden;
+}
+
+.modal-header {
+    border-bottom: 1px solid rgba(0, 0, 0, 0.05);
+}
+
+.modal-footer {
+    border-top: 1px solid rgba(0, 0, 0, 0.05);
+}
+
+/* 分页样式 */
+.pagination {
+    margin-bottom: 0;
+}
+
+.page-link {
+    color: var(--primary-color);
+    border-radius: 4px;
+    margin: 0 2px;
+}
+
+.page-item.active .page-link {
+    background-color: var(--primary-color);
+    border-color: var(--primary-color);
+}
+
+/* 搜索框样式 */
+#search-keys {
+    min-width: 250px;
+    border-radius: 20px;
+    padding-left: 15px;
+    padding-right: 15px;
+} 

src/static/admin/index.html

@@ -0,0 +1,512 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Sora API - 管理控制台</title>
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css">
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.10.0/font/bootstrap-icons.css">
+    <link rel="stylesheet" href="/static/admin/css/style.css">
+</head>
+<body>
+    <!-- 登录页面 -->
+    <div id="login-container" style="display: flex;" class="login-container">
+        <div class="card shadow-lg">
+            <div class="card-header bg-primary text-white text-center py-3">
+                <h4>Sora API 管理控制台</h4>
+            </div>
+            <div class="card-body p-4">
+                <div class="text-center mb-4">
+                    <i class="bi bi-shield-lock" style="font-size: 3rem;"></i>
+                    <h5 class="mt-2">管理员登录</h5>
+                </div>
+                <form id="login-form">
+                    <div class="mb-3">
+                        <label for="admin-key-input" class="form-label">管理员密钥</label>
+                        <input type="password" class="form-control" id="admin-key-input" required>
+                        <div class="form-text">请输入管理员密钥以访问管理控制台</div>
+                    </div>
+                    <div class="d-grid gap-2">
+                        <button type="submit" class="btn btn-primary">登录</button>
+                    </div>
+                </form>
+                <div id="login-error" class="alert alert-danger mt-3" style="display: none;"></div>
+            </div>
+        </div>
+    </div>
+
+    <!-- 管理控制台 -->
+    <div id="admin-panel" style="display: none;" class="wrapper">
+        <!-- 侧边栏导航 -->
+        <nav id="sidebar">
+            <div class="sidebar-header d-flex align-items-center">
+                <h3 class="mb-0">Sora API</h3>
+            </div>
+
+            <ul class="list-unstyled components">
+                <li class="active">
+                    <a href="#" data-page="dashboard"><i class="bi bi-speedometer2 me-2"></i>仪表盘</a>
+                </li>
+                <li>
+                    <a href="#" data-page="keys"><i class="bi bi-key-fill me-2"></i>API密钥管理</a>
+                </li>
+                <li>
+                    <a href="#" data-page="stats"><i class="bi bi-graph-up me-2"></i>使用统计</a>
+                </li>
+                <li>
+                    <a href="#" data-page="settings"><i class="bi bi-gear-fill me-2"></i>系统设置</a>
+                </li>
+                <li class="sidebar-footer">
+                    <a href="#" id="logout-btn"><i class="bi bi-box-arrow-right me-2"></i>退出登录</a>
+                </li>
+            </ul>
+        </nav>
+
+        <!-- 页面内容区 -->
+        <div id="content">
+            <!-- 顶部导航栏 -->
+            <nav class="navbar navbar-expand-lg navbar-light bg-light shadow-sm mb-4">
+                <div class="container-fluid">
+                    <button type="button" id="sidebarCollapse" class="btn btn-primary">
+                        <i class="bi bi-list"></i>
+                    </button>
+                    <div class="ms-3 d-none d-md-block">
+                        <h5 class="mb-0" id="current-page-title">仪表盘</h5>
+                    </div>
+                    <div class="ms-auto d-flex align-items-center">
+                        <span class="badge bg-primary me-3" id="admin-key-display"></span>
+                        <span class="text-muted d-none d-md-block">欢迎回来，管理员</span>
+                    </div>
+                </div>
+            </nav>
+            
+            <!-- 仪表盘页面 -->
+            <div id="dashboard-page" class="content-page active container-fluid">
+                <div class="row mb-4">
+                    <div class="col-12">
+                        <h4 class="mb-4">系统概览</h4>
+                    </div>
+                    <div class="col-md-6 col-lg-3 mb-4">
+                        <div class="card bg-primary text-white h-100">
+                            <div class="card-body">
+                                <h5 class="card-title">总API密钥</h5>
+                                <h3 id="total-keys" class="card-text">--</h3>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="col-md-6 col-lg-3 mb-4">
+                        <div class="card bg-success text-white h-100">
+                            <div class="card-body">
+                                <h5 class="card-title">激活密钥</h5>
+                                <h3 id="active-keys" class="card-text">--</h3>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="col-md-6 col-lg-3 mb-4">
+                        <div class="card bg-danger text-white h-100">
+                            <div class="card-body">
+                                <h5 class="card-title">禁用密钥</h5>
+                                <h3 id="disabled-keys" class="card-text">--</h3>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="col-md-6 col-lg-3 mb-4">
+                        <div class="card bg-info text-white h-100">
+                            <div class="card-body">
+                                <h5 class="card-title">今日请求</h5>
+                                <h3 id="today-requests" class="card-text">--</h3>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+                
+                <div class="row">
+                    <div class="col-lg-8 mb-4">
+                        <div class="card h-100">
+                            <div class="card-header">
+                                <h5 class="card-title mb-0">近期请求趋势</h5>
+                            </div>
+                            <div class="card-body">
+                                <canvas id="dashboard-requests-chart"></canvas>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="col-lg-4 mb-4">
+                        <div class="card h-100">
+                            <div class="card-header">
+                                <h5 class="card-title mb-0">最新API密钥</h5>
+                            </div>
+                            <div class="card-body p-0">
+                                <div class="list-group list-group-flush" id="recent-keys-list">
+                                    <!-- JS动态加载 -->
+                                </div>
+                            </div>
+                            <div class="card-footer text-end">
+                                <a href="#" class="btn btn-sm btn-primary" data-page="keys">查看全部</a>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            
+            <!-- API密钥管理页面 -->
+            <div id="keys-page" class="content-page container-fluid">
+                <div class="row mb-4">
+                    <div class="col-12">
+                        <div class="card">
+                            <div class="card-body">
+                                <div class="d-flex justify-content-between flex-wrap mb-3">
+                                    <div class="mb-2">
+                                        <button id="add-key-btn" class="btn btn-primary me-2">
+                                            <i class="bi bi-plus-circle me-1"></i> 添加密钥
+                                        </button>
+                                        <div class="btn-group">
+                                            <button class="btn btn-outline-secondary dropdown-toggle" type="button" data-bs-toggle="dropdown">
+                                                批量操作
+                                            </button>
+                                            <ul class="dropdown-menu">
+                                                <li><a class="dropdown-item batch-action" data-action="enable" href="#">启用选中</a></li>
+                                                <li><a class="dropdown-item batch-action" data-action="disable" href="#">禁用选中</a></li>
+                                                <li><hr class="dropdown-divider"></li>
+                                                <li><a class="dropdown-item batch-action text-danger" data-action="delete" href="#">删除选中</a></li>
+                                            </ul>
+                                        </div>
+                                        <button id="import-keys-btn" class="btn btn-outline-primary ms-2">
+                                            <i class="bi bi-upload me-1"></i> 批量导入
+                                        </button>
+                                    </div>
+                                    <div class="mb-2">
+                                        <input type="text" id="search-keys" class="form-control" placeholder="搜索密钥...">
+                                    </div>
+                                </div>
+                                
+                                <div class="table-responsive">
+                                    <table class="table table-hover">
+                                        <thead>
+                                            <tr>
+                                                <th><input type="checkbox" id="select-all"></th>
+                                                <th>名称</th>
+                                                <th>密钥值</th>
+                                                <th>状��</th>
+                                                <th>权重</th>
+                                                <th>速率限制</th>
+                                                <th>创建时间</th>
+                                                <th>最后使用</th>
+                                                <th>操作</th>
+                                            </tr>
+                                        </thead>
+                                        <tbody id="keys-table-body">
+                                            <!-- JS动态加载 -->
+                                        </tbody>
+                                    </table>
+                                </div>
+                                
+                                <div id="pagination" class="d-flex justify-content-center mt-4">
+                                    <!-- JS动态加载 -->
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            
+            <!-- 使用统计页面 -->
+            <div id="stats-page" class="content-page container-fluid">
+                <div class="row">
+                    <div class="col-12">
+                        <h4 class="mb-4">使用统计</h4>
+                    </div>
+                    <div class="col-md-6 col-lg-3 mb-4">
+                        <div class="card bg-primary text-white">
+                            <div class="card-body">
+                                <h5 class="card-title">总请求次数</h5>
+                                <h3 id="total-requests" class="card-text">--</h3>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="col-md-6 col-lg-3 mb-4">
+                        <div class="card bg-success text-white">
+                            <div class="card-body">
+                                <h5 class="card-title">成功请求</h5>
+                                <h3 id="successful-requests" class="card-text">--</h3>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="col-md-6 col-lg-3 mb-4">
+                        <div class="card bg-danger text-white">
+                            <div class="card-body">
+                                <h5 class="card-title">失败请求</h5>
+                                <h3 id="failed-requests" class="card-text">--</h3>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="col-md-6 col-lg-3 mb-4">
+                        <div class="card bg-info text-white">
+                            <div class="card-body">
+                                <h5 class="card-title">成功率</h5>
+                                <h3 id="success-rate" class="card-text">--</h3>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+                
+                <div class="row">
+                    <!-- 请求趋势图 -->
+                    <div class="col-lg-8 mb-4">
+                        <div class="card">
+                            <div class="card-header">
+                                <h5 class="card-title mb-0">请求趋势</h5>
+                            </div>
+                            <div class="card-body">
+                                <canvas id="requests-chart"></canvas>
+                            </div>
+                        </div>
+                    </div>
+                    
+                    <!-- 密钥使用分布 -->
+                    <div class="col-lg-4 mb-4">
+                        <div class="card">
+                            <div class="card-header">
+                                <h5 class="card-title mb-0">密钥使用分布</h5>
+                            </div>
+                            <div class="card-body">
+                                <canvas id="keys-usage-chart"></canvas>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            
+            <!-- 设置页面 -->
+            <div id="settings-page" class="content-page container-fluid">
+                <div class="row">
+                    <div class="col-12">
+                        <h4 class="mb-4">系统设置</h4>
+                    </div>
+                    <div class="col-md-6 mb-4">
+                        <div class="card">
+                            <div class="card-header">
+                                <h5 class="card-title mb-0">管理员密钥</h5>
+                            </div>
+                            <div class="card-body">
+                                <div class="mb-3">
+                                    <label for="admin-key" class="form-label">管理员密钥</label>
+                                    <div class="input-group">
+                                        <input type="password" class="form-control" id="admin-key" readonly>
+                                        <button class="btn btn-outline-secondary" type="button" id="show-admin-key">
+                                            <i class="bi bi-eye"></i>
+                                        </button>
+                                        <button class="btn btn-outline-secondary" type="button" id="copy-admin-key">
+                                            <i class="bi bi-clipboard"></i>
+                                        </button>
+                                    </div>
+                                    <div class="form-text">此密钥用于访问管理界面，请妥善保管</div>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                    
+                    <div class="col-md-6 mb-4">
+                        <div class="card">
+                            <div class="card-header">
+                                <h5 class="card-title mb-0">系统配置</h5>
+                            </div>
+                            <div class="card-body">
+                                <form id="settings-form">
+                                    <div class="mb-3">
+                                        <label for="proxy-host" class="form-label">代理主机</label>
+                                        <input type="text" class="form-control" id="proxy-host">
+                                    </div>
+                                    <div class="mb-3">
+                                        <label for="proxy-port" class="form-label">代理端口</label>
+                                        <input type="text" class="form-control" id="proxy-port">
+                                    </div>
+                                    
+                                    <div class="mb-3">
+                                        <label for="proxy-user" class="form-label">代理用户名</label>
+                                        <input type="text" class="form-control" id="proxy-user">
+                                    </div>
+                                    
+                                    <div class="mb-3">
+                                        <label for="proxy-pass" class="form-label">代理密码</label>
+                                        <input type="password" class="form-control" id="proxy-pass">
+                                        <div class="form-text">如果代理服务器需要认证，请填写用户名和密码</div>
+                                    </div>
+                                    
+                                    <hr>
+                                    <h6 class="mb-3">图片本地化设置</h6>
+                                    
+                                    <div class="mb-3 form-check">
+                                        <input type="checkbox" class="form-check-input" id="image-localization">
+                                        <label class="form-check-label" for="image-localization">启用图片本地化</label>
+                                        <div class="form-text">启用后，Sora生成的图片将被下载并保存到本地服务器，避免客户端无法访问外部链接</div>
+                                    </div>
+                                    
+                                    <div class="mb-3">
+                                        <label for="base-url" class="form-label">Base URL</label>
+                                        <input type="text" class="form-control" id="base-url" placeholder="http://example.com">
+                                        <div class="form-text">设置访问本地化图片的基础URL，例如：http://example.com 或 https://your-domain.com</div>
+                                    </div>
+                                    
+                                    <div class="mb-3">
+                                        <label for="image-save-dir" class="form-label">图片保存目录</label>
+                                        <input type="text" class="form-control" id="image-save-dir" placeholder="src/static/images">
+                                        <div class="form-text">相对于工作目录的路径，必须确保目录存在且有写入权限</div>
+                                    </div>
+                                    
+                                    <button type="submit" class="btn btn-primary">保存设置</button>
+                                </form>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+    
+    <!-- 添加/编辑密钥对话框 -->
+    <div class="modal fade" id="keyModal" tabindex="-1">
+        <div class="modal-dialog">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title" id="keyModalLabel">添加新密钥</h5>
+                    <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+                </div>
+                <div class="modal-body">
+                    <form id="key-form">
+                        <input type="hidden" id="key-id">
+                        <div class="mb-3">
+                            <label for="key-name" class="form-label">密钥名称</label>
+                            <input type="text" class="form-control" id="key-name" required>
+                        </div>
+                        <div class="mb-3">
+                            <label for="key-value" class="form-label">密钥值 (Bearer Token)</label>
+                            <input type="text" class="form-control" id="key-value" required>
+                            <div class="form-text">输入OpenAI格式的API密钥，无需添加"Bearer "前缀，系统会自动处理</div>
+                        </div>
+                        <div class="mb-3">
+                            <label for="key-weight" class="form-label">权重 (1-10)</label>
+                            <input type="number" class="form-control" id="key-weight" min="1" max="10" value="1">
+                            <div class="form-text">权重越高，被选中的概率越大</div>
+                        </div>
+                        <div class="mb-3">
+                            <label for="key-rate-limit" class="form-label">速率限制 (每分钟请求数)</label>
+                            <input type="number" class="form-control" id="key-rate-limit" min="1" value="60">
+                        </div>
+                        <div class="mb-3 form-check">
+                            <input type="checkbox" class="form-check-input" id="key-enabled" checked>
+                            <label class="form-check-label" for="key-enabled">启用</label>
+                        </div>
+                        <div class="mb-3">
+                            <label for="key-notes" class="form-label">备注</label>
+                            <textarea class="form-control" id="key-notes" rows="2"></textarea>
+                        </div>
+                    </form>
+                </div>
+                <div class="modal-footer">
+                    <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">取消</button>
+                    <button type="button" class="btn btn-primary" id="test-key-btn">测试连接</button>
+                    <button type="button" class="btn btn-success" id="save-key-btn">保存</button>
+                </div>
+            </div>
+        </div>
+    </div>
+    
+    <!-- 确认对话框 -->
+    <div class="modal fade" id="confirmModal" tabindex="-1">
+        <div class="modal-dialog">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title" id="confirmModalLabel">确认操作</h5>
+                    <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+                </div>
+                <div class="modal-body" id="confirm-message">
+                    确定要执行此操作吗？
+                </div>
+                <div class="modal-footer">
+                    <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">取消</button>
+                    <button type="button" class="btn btn-danger" id="confirm-btn">确认</button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- 批量导入密钥对话框 -->
+    <div class="modal fade" id="importKeysModal" tabindex="-1">
+        <div class="modal-dialog modal-lg">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title">批量导入API密钥</h5>
+                    <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+                </div>
+                <div class="modal-body">
+                    <ul class="nav nav-tabs" id="importTabs" role="tablist">
+                        <li class="nav-item" role="presentation">
+                            <button class="nav-link active" id="paste-tab" data-bs-toggle="tab" data-bs-target="#paste-content" type="button" role="tab">粘贴内容</button>
+                        </li>
+                        <li class="nav-item" role="presentation">
+                            <button class="nav-link" id="file-tab" data-bs-toggle="tab" data-bs-target="#file-upload" type="button" role="tab">上传文件</button>
+                        </li>
+                    </ul>
+                    <div class="tab-content mt-3" id="importTabsContent">
+                        <div class="tab-pane fade show active" id="paste-content" role="tabpanel">
+                            <div class="mb-3">
+                                <label for="keys-text" class="form-label">API密钥列表</label>
+                                <textarea class="form-control" id="keys-text" rows="10" placeholder="支持两种格式：&#10;1. 每行一个密钥&#10;2. 每行格式：[名称],[API密钥],[权重(可选)],[速率限制(可选)]&#10;&#10;例如：&#10;sk-abcdefg123456&#10;我的密钥2,sk-hijklmn789012,5,100"></textarea>
+                            </div>
+                        </div>
+                        <div class="tab-pane fade" id="file-upload" role="tabpanel">
+                            <div class="mb-3">
+                                <label for="keys-file" class="form-label">选择文件</label>
+                                <input class="form-control" type="file" id="keys-file" accept=".txt,.csv">
+                                <div class="form-text">支持TXT或CSV文件，每行格式同上</div>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="form-check mt-3">
+                        <input class="form-check-input" type="checkbox" id="auto-enable-keys" checked>
+                        <label class="form-check-label" for="auto-enable-keys">
+                            自动启用导入的密钥
+                        </label>
+                    </div>
+                    <div class="alert alert-info mt-3">
+                        <i class="bi bi-info-circle me-2"></i> 批量导入将跳过重复的密钥值。如果名称重复但密钥值不同，将作为新密钥添加。
+                    </div>
+                    <div id="import-preview" class="mt-3" style="display: none;">
+                        <h6>导入预览 (<span id="preview-count">0</span>个密钥)</h6>
+                        <div class="table-responsive">
+                            <table class="table table-sm">
+                                <thead>
+                                    <tr>
+                                        <th>名称</th>
+                                        <th>密钥</th>
+                                        <th>权重</th>
+                                        <th>速率限制</th>
+                                    </tr>
+                                </thead>
+                                <tbody id="preview-table-body">
+                                </tbody>
+                            </table>
+                        </div>
+                    </div>
+                </div>
+                <div class="modal-footer">
+                    <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">取消</button>
+                    <button type="button" class="btn btn-primary" id="preview-import-btn">预览</button>
+                    <button type="button" class="btn btn-success" id="confirm-import-btn" disabled>导入</button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Toast通知 -->
+    <div class="position-fixed bottom-0 end-0 p-3" style="z-index: 5">
+        <div id="toast-container"></div>
+    </div>
+
+    <!-- JavaScript库 -->
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <script src="/static/admin/js/main.js"></script>
+</body>
+</html> 

src/static/admin/js/config.js

@@ -0,0 +1,121 @@
+document.addEventListener('DOMContentLoaded', function() {
+    // 获取当前配置
+    fetchConfig();
+    
+    // 保存配置按钮事件
+    document.getElementById('saveConfig').addEventListener('click', saveConfig);
+});
+
+// 获取当前配置
+function fetchConfig() {
+    fetch('/api/config', {
+        method: 'GET',
+        headers: {
+            'Authorization': 'Bearer ' + getAdminKey()
+        }
+    })
+    .then(response => {
+        if (!response.ok) {
+            throw new Error('获取配置失败，请检查管理员密钥是否正确');
+        }
+        return response.json();
+    })
+    .then(data => {
+        // 代理设置
+        document.getElementById('proxy_host').value = data.PROXY_HOST || '';
+        document.getElementById('proxy_port').value = data.PROXY_PORT || '';
+        document.getElementById('proxy_user').value = data.PROXY_USER || '';
+        
+        // 代理密码字段
+        const proxyPassField = document.getElementById('proxy_pass');
+        if (data.PROXY_PASS && data.PROXY_PASS !== '') {
+            // 设置代理密码占位符，防止用户修改
+            proxyPassField.setAttribute('placeholder', '已设置代理密码 (请保留空)');
+        } else {
+            proxyPassField.setAttribute('placeholder', '代理密码');
+        }
+        
+        // 图像本地化设置
+        document.getElementById('image_localization').checked = data.IMAGE_LOCALIZATION || false;
+        document.getElementById('image_save_dir').value = data.IMAGE_SAVE_DIR || 'src/static/images';
+    })
+    .catch(error => {
+        showMessage('错误', error.message, 'danger');
+    });
+}
+
+// 保存配置
+function saveConfig() {
+    // 获取代理设置
+    const proxyHost = document.getElementById('proxy_host').value.trim();
+    const proxyPort = document.getElementById('proxy_port').value.trim();
+    const proxyUser = document.getElementById('proxy_user').value.trim();
+    const proxyPass = document.getElementById('proxy_pass').value.trim();
+    
+    // 获取图像本地化设置
+    const imageLocalization = document.getElementById('image_localization').checked;
+    const imageSaveDir = document.getElementById('image_save_dir').value.trim();
+    
+    // 创建配置对象
+    const config = {
+        PROXY_HOST: proxyHost,
+        PROXY_PORT: proxyPort,
+        PROXY_USER: proxyUser,
+        IMAGE_LOCALIZATION: imageLocalization,
+        IMAGE_SAVE_DIR: imageSaveDir,
+        save_to_env: true
+    };
+    
+    // 如果代理密码存在，则添加到配置对象中
+    if (proxyPass) {
+        config.PROXY_PASS = proxyPass;
+    }
+    
+    fetch('/api/config', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': 'Bearer ' + getAdminKey()
+        },
+        body: JSON.stringify(config)
+    })
+    .then(response => {
+        if (!response.ok) {
+            throw new Error('保存配置失败，请检查管理员密钥是否正确');
+        }
+        return response.json();
+    })
+    .then(data => {
+        showMessage('成功', '配置已保存', 'success');
+        
+        // 成功后，立即重新获取配置以更新显示
+        setTimeout(fetchConfig, 1000);
+    })
+    .catch(error => {
+        showMessage('错误', error.message, 'danger');
+    });
+}
+
+// 获取管理员密钥
+function getAdminKey() {
+    return localStorage.getItem('adminKey') || '';
+}
+
+// 显示消息
+function showMessage(title, message, type) {
+    const alertDiv = document.createElement('div');
+    alertDiv.className = `alert alert-${type} alert-dismissible fade show`;
+    alertDiv.innerHTML = `
+        <strong>${title}:</strong> ${message}
+        <button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>
+    `;
+    
+    const messagesContainer = document.getElementById('messages');
+    messagesContainer.appendChild(alertDiv);
+    
+    // 5秒后自动关闭
+    setTimeout(() => {
+        alertDiv.classList.remove('show');
+        setTimeout(() => alertDiv.remove(), 150);
+    }, 5000);
+} 

src/static/admin/js/main.js

@@ -0,0 +1,1631 @@
+// 全局变量
+let adminKey = '';
+let keysData = [];
+let currentPage = 1;
+const keysPerPage = 10;
+let statsData = null;
+let dashboardRequestsChart = null;
+let requestsChart = null;
+let keysUsageChart = null;
+let systemSettings = {
+    proxyHost: '',
+    proxyPort: '',
+    proxyUser: '',
+    proxyPass: ''
+};
+// token过期时间
+let tokenExpiry = null;
+// JWT配置
+const JWT_EXPIRATION = 3600; // 令牌有效期1小时（秒）
+// 导入预览数据
+let importPreviewData = [];
+
+// DOM 加载完成后执行
+document.addEventListener('DOMContentLoaded', () => {
+    // 检查是否已登录
+    checkAuth();
+    
+    // 绑定登录表单提交事件
+    document.getElementById('login-form').addEventListener('submit', async (e) => {
+        e.preventDefault();
+        await handleLogin();
+    });
+    
+    // 绑定退出登录事件
+    document.getElementById('logout-btn').addEventListener('click', (e) => {
+        e.preventDefault();
+        handleLogout();
+    });
+    
+    // 侧边栏切换
+    document.getElementById('sidebarCollapse').addEventListener('click', () => {
+        const sidebar = document.getElementById('sidebar');
+        const content = document.getElementById('content');
+        
+        sidebar.classList.toggle('active');
+        content.classList.toggle('active');
+    });
+    
+    // 页面切换
+    document.querySelectorAll('[data-page]').forEach(link => {
+        link.addEventListener('click', (e) => {
+            e.preventDefault();
+            const targetPage = link.getAttribute('data-page');
+            
+            // 验证token是否有效
+            if (!isTokenValid()) {
+                handleLogout();
+                showToast('登录已过期，请重新登录', 'warning');
+                return;
+            }
+            
+            // 更新导航链接激活状态
+            document.querySelectorAll('#sidebar li').forEach(li => li.classList.remove('active'));
+            link.closest('li').classList.add('active');
+            
+            // 更新页面标题
+            document.getElementById('current-page-title').textContent = link.textContent.trim();
+            
+            // 隐藏所有页面，只显示目标页面
+            document.querySelectorAll('.content-page').forEach(page => {
+                page.classList.remove('active');
+                page.style.display = 'none';
+            });
+            document.getElementById(`${targetPage}-page`).classList.add('active');
+            document.getElementById(`${targetPage}-page`).style.display = 'block';
+            
+            // 加载相应页面的数据
+            switch (targetPage) {
+                case 'dashboard':
+                    loadDashboard();
+                    break;
+                case 'keys':
+                    loadKeys();
+                    break;
+                case 'stats':
+                    loadStats();
+                    break;
+                case 'settings':
+                    loadSettings();
+                    break;
+            }
+        });
+    });
+    
+    // 仪表盘页面的"查看全部"按钮
+    document.querySelectorAll('#dashboard-page [data-page]').forEach(link => {
+        link.addEventListener('click', (e) => {
+            e.preventDefault();
+            const targetPage = link.getAttribute('data-page');
+            // 触发相应导航的点击事件
+            document.querySelector(`#sidebar a[data-page="${targetPage}"]`).click();
+        });
+    });
+    
+    // 添加密钥按钮事件
+    document.getElementById('add-key-btn').addEventListener('click', () => {
+        // 重置表单
+        document.getElementById('key-form').reset();
+        document.getElementById('key-id').value = '';
+        document.getElementById('keyModalLabel').textContent = '添加新密钥';
+        
+        // 显示模态框
+        const keyModal = new bootstrap.Modal(document.getElementById('keyModal'));
+        keyModal.show();
+    });
+    
+    // 保存密钥按钮事件
+    document.getElementById('save-key-btn').addEventListener('click', saveKey);
+    
+    // 测试密钥按钮事件
+    document.getElementById('test-key-btn').addEventListener('click', testKey);
+    
+    // 全选/取消全选
+    document.getElementById('select-all').addEventListener('change', (e) => {
+        const checkboxes = document.querySelectorAll('#keys-table-body input[type="checkbox"]');
+        checkboxes.forEach(checkbox => checkbox.checked = e.target.checked);
+    });
+    
+    // 批量操作事件
+    document.querySelectorAll('.batch-action').forEach(action => {
+        action.addEventListener('click', (e) => {
+            e.preventDefault();
+            const actionType = action.getAttribute('data-action');
+            const selectedIds = getSelectedKeyIds();
+            
+            if (selectedIds.length === 0) {
+                showToast('请至少选择一个密钥', 'warning');
+                return;
+            }
+            
+            // 显示确认对话框
+            let message = '';
+            if (actionType === 'enable') {
+                message = `确定要启用选中的 ${selectedIds.length} 个密钥吗？`;
+            } else if (actionType === 'disable') {
+                message = `确定要禁用选中的 ${selectedIds.length} 个密钥吗？`;
+            } else if (actionType === 'delete') {
+                message = `确定要删除选中的 ${selectedIds.length} 个密钥吗？此操作不可恢复！`;
+            }
+            
+            showConfirmDialog(message, () => {
+                batchOperation(actionType, selectedIds);
+            });
+        });
+    });
+    
+    // 搜索框事件
+    document.getElementById('search-keys').addEventListener('input', (e) => {
+        const searchTerm = e.target.value.toLowerCase();
+        if (searchTerm) {
+            const filteredKeys = keysData.filter(key => 
+                key.name.toLowerCase().includes(searchTerm) || 
+                key.key.toLowerCase().includes(searchTerm)
+            );
+            renderKeysTable(filteredKeys);
+        } else {
+            renderKeysTable(keysData);
+        }
+    });
+    
+    // 管理员密钥显示/隐藏
+    document.getElementById('show-admin-key').addEventListener('click', () => {
+        const adminKeyInput = document.getElementById('admin-key');
+        if (adminKeyInput.type === 'password') {
+            adminKeyInput.type = 'text';
+            document.getElementById('show-admin-key').innerHTML = '<i class="bi bi-eye-slash"></i>';
+        } else {
+            adminKeyInput.type = 'password';
+            document.getElementById('show-admin-key').innerHTML = '<i class="bi bi-eye"></i>';
+        }
+    });
+    
+    // 复制管理员密钥
+    document.getElementById('copy-admin-key').addEventListener('click', () => {
+        const adminKeyInput = document.getElementById('admin-key');
+        adminKeyInput.type = 'text';
+        adminKeyInput.select();
+        document.execCommand('copy');
+        adminKeyInput.type = 'password';
+        showToast('管理员密钥已复制到剪贴板', 'success');
+    });
+    
+    // 设置表单提交
+    document.getElementById('settings-form').addEventListener('submit', async (e) => {
+        e.preventDefault();
+        await saveSettings();
+    });
+    
+    // 批量导入密钥按钮事件
+    document.getElementById('import-keys-btn').addEventListener('click', () => {
+        // 重置导入表单和预览
+        document.getElementById('keys-text').value = '';
+        document.getElementById('keys-file').value = '';
+        document.getElementById('auto-enable-keys').checked = true;
+        document.getElementById('import-preview').style.display = 'none';
+        document.getElementById('confirm-import-btn').disabled = true;
+        importPreviewData = [];
+        
+        // 显示导入模态框
+        const importModal = new bootstrap.Modal(document.getElementById('importKeysModal'));
+        importModal.show();
+    });
+    
+    // 预览导入按钮事件
+    document.getElementById('preview-import-btn').addEventListener('click', previewImport);
+    
+    // 确认导入按钮事件
+    document.getElementById('confirm-import-btn').addEventListener('click', confirmImport);
+    
+    // 文件选择事件
+    document.getElementById('keys-file').addEventListener('change', async (e) => {
+        if (e.target.files.length > 0) {
+            const file = e.target.files[0];
+            const reader = new FileReader();
+            
+            reader.onload = function(event) {
+                document.getElementById('keys-text').value = event.target.result;
+            };
+            
+            reader.readAsText(file);
+        }
+    });
+});
+
+// 检查是否已登录
+function checkAuth() {
+    const savedAdminKey = localStorage.getItem('adminKey');
+    const savedTokenExpiry = localStorage.getItem('tokenExpiry');
+    
+    if (savedAdminKey && savedTokenExpiry) {
+        adminKey = savedAdminKey;
+        tokenExpiry = parseInt(savedTokenExpiry);
+        
+        // 检查token是否已过期
+        if (isTokenValid()) {
+            showAdminPanel();
+            // 初始化其他数据
+            displayAdminKey();
+            loadDashboard(); // 初始加载仪表盘页面
+            
+            // 如果token即将过期（小于5分钟），则刷新
+            const fiveMinutesInMs = 5 * 60 * 1000;
+            if (tokenExpiry - new Date().getTime() < fiveMinutesInMs) {
+                refreshToken();
+            }
+        } else {
+            // token已过期，清除存储并显示登录面板
+            handleLogout();
+            showToast('登录已过期，请重新登录', 'warning');
+        }
+    } else {
+        showLoginPanel();
+    }
+}
+
+// 处理登录
+async function handleLogin() {
+    const inputKey = document.getElementById('admin-key-input').value.trim();
+    if (!inputKey) {
+        showLoginError('请输入管理员密钥');
+        return;
+    }
+    
+    try {
+        // 显示加载状态
+        document.querySelector('#login-form button').disabled = true;
+        document.querySelector('#login-form button').innerHTML = '<span class="spinner-border spinner-border-sm" role="status" aria-hidden="true"></span> 登录中...';
+        
+        // 使用fetch API进行登录请求
+        const response = await fetch('/api/auth/login', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ admin_key: inputKey })
+        });
+        
+        // 恢复按钮状态
+        document.querySelector('#login-form button').disabled = false;
+        document.querySelector('#login-form button').innerHTML = '登录';
+        
+        if (response.ok) {
+            const data = await response.json();
+            adminKey = data.token;
+            tokenExpiry = new Date().getTime() + (data.expires_in * 1000);
+            
+            // 保存至本地存储
+            localStorage.setItem('adminKey', adminKey);
+            localStorage.setItem('tokenExpiry', tokenExpiry.toString());
+            
+            // 隐藏错误信息
+            document.getElementById('login-error').style.display = 'none';
+            
+            // 显示管理面板
+            showAdminPanel();
+            displayAdminKey();
+            loadDashboard();
+        } else {
+            // 登录失败
+            try {
+                const error = await response.json();
+                showLoginError(error.detail || '登录失败，请检查管理员密钥');
+            } catch {
+                showLoginError('登录失败，请检查管理员密钥');
+            }
+        }
+    } catch (error) {
+        // 处理网络错误等异常
+        document.querySelector('#login-form button').disabled = false;
+        document.querySelector('#login-form button').innerHTML = '登录';
+        console.error('验证管理员密钥失败:', error);
+        showLoginError('验证失败，请稍后再试');
+    }
+}
+
+// 显示登录错误
+function showLoginError(message) {
+    const errorElement = document.getElementById('login-error');
+    errorElement.textContent = message;
+    errorElement.style.display = 'block';
+    
+    // 3秒后自动隐藏
+    setTimeout(() => {
+        errorElement.style.display = 'none';
+    }, 3000);
+}
+
+// 处理登出
+function handleLogout() {
+    localStorage.removeItem('adminKey');
+    localStorage.removeItem('tokenExpiry');
+    adminKey = '';
+    tokenExpiry = null;
+    showLoginPanel();
+    document.getElementById('admin-key-input').value = '';
+}
+
+// 检查token是否有效
+function isTokenValid() {
+    if (!tokenExpiry) return false;
+    // 检查token是否过期（留10秒缓冲）
+    return new Date().getTime() < tokenExpiry - 10000;
+}
+
+// 刷新token
+async function refreshToken() {
+    try {
+        const response = await fetch('/api/auth/refresh', {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${adminKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        
+        if (response.ok) {
+            const data = await response.json();
+            adminKey = data.token;
+            tokenExpiry = new Date().getTime() + (data.expires_in * 1000);
+            localStorage.setItem('adminKey', adminKey);
+            localStorage.setItem('tokenExpiry', tokenExpiry.toString());
+            return true;
+        } else {
+            return false;
+        }
+    } catch (error) {
+        console.error('刷新token失败:', error);
+        return false;
+    }
+}
+
+// 显示登录面板
+function showLoginPanel() {
+    document.getElementById('login-container').style.display = 'flex';
+    document.getElementById('admin-panel').style.display = 'none';
+    // 清除可能存在的错误信息
+    document.getElementById('login-error').style.display = 'none';
+}
+
+// 显示管理面板
+function showAdminPanel() {
+    document.getElementById('login-container').style.display = 'none';
+    document.getElementById('admin-panel').style.display = 'flex';
+    
+    // 确保侧边栏正常显示
+    document.getElementById('sidebar').classList.remove('active');
+    document.getElementById('content').classList.remove('active');
+    
+    // 初始化显示仪表盘页面，隐藏其他页面
+    document.querySelectorAll('.content-page').forEach(page => {
+        page.classList.remove('active');
+        page.style.display = 'none';
+    });
+    document.getElementById('dashboard-page').classList.add('active');
+    document.getElementById('dashboard-page').style.display = 'block';
+    
+    // 更新导航栏状态
+    document.querySelectorAll('#sidebar li').forEach(li => li.classList.remove('active'));
+    document.querySelector('#sidebar li:first-child').classList.add('active');
+    
+    // 更新页面标题
+    document.getElementById('current-page-title').textContent = '仪���盘';
+}
+
+// 显示管理员密钥信息
+function displayAdminKey() {
+    // 设置到隐藏输入框
+    document.getElementById('admin-key').value = adminKey;
+    
+    // 显示密钥部分信息
+    const keyDisplay = adminKey.substring(0, 6) + '...' + adminKey.substring(adminKey.length - 4);
+    document.getElementById('admin-key-display').textContent = '管理员: ' + keyDisplay;
+}
+
+// API请求包装函数，处理token刷新逻辑
+async function apiRequest(url, options = {}) {
+    // 检查token是否即将到期（剩余5分钟以内）
+    const fiveMinutesInMs = 5 * 60 * 1000;
+    if (tokenExpiry && (tokenExpiry - new Date().getTime() < fiveMinutesInMs)) {
+        // 刷新token
+        const refreshSuccess = await refreshToken();
+        if (!refreshSuccess) {
+            // token刷新失败，需要重新登录
+            handleLogout();
+            showToast('登录已过期，请重新登录', 'warning');
+            return null;
+        }
+    }
+    
+    // 确保options中包含正确的headers
+    options.headers = options.headers || {};
+    options.headers['Authorization'] = `Bearer ${adminKey}`;
+    
+    // 如果是POST/PUT请求且有body，确保设置正确的Content-Type
+    if ((options.method === 'POST' || options.method === 'PUT') && options.body) {
+        // 确保Content-Type正确设置
+        if (!options.headers['Content-Type']) {
+            options.headers['Content-Type'] = 'application/json';
+        }
+    }
+    
+    // 发送请求
+    try {
+        const response = await fetch(url, options);
+        
+        // 处理401/403错误（未授权）
+        if (response.status === 401 || response.status === 403) {
+            // 尝试刷新token
+            if (await refreshToken()) {
+                // 刷新成功，使用新token重试请求
+                options.headers['Authorization'] = `Bearer ${adminKey}`;
+                const retryResponse = await fetch(url, options);
+                if (retryResponse.ok) {
+                    return await retryResponse.json();
+                }
+            }
+            
+            // 刷新失败或重试失败，需要重新登录
+            handleLogout();
+            showToast('登录已过期，请重新登录', 'warning');
+            return null;
+        }
+        
+        // 其他错误
+        if (!response.ok) {
+            // 尝试解析错误消息
+            try {
+                const errorData = await response.json();
+                throw new Error(`请求失败: ${response.status} - ${errorData.detail || errorData.message || response.statusText}`);
+            } catch (e) {
+                throw new Error(`请求失败: ${response.status} ${response.statusText}`);
+            }
+        }
+        
+        return await response.json();
+    } catch (error) {
+        console.error('API请求错误:', error);
+        showToast(`请求失败: ${error.message}`, 'error');
+        return null;
+    }
+}
+
+// 加载密钥列表
+async function loadKeys() {
+    try {
+        // 显示加载中
+        document.getElementById('keys-table-body').innerHTML = '<tr><td colspan="9" class="text-center">加载中...</td></tr>';
+        
+        const data = await apiRequest('/api/keys');
+        if (data) {
+            keysData = data;
+            renderKeysTable(keysData);
+        }
+    } catch (error) {
+        console.error('加载密钥失败:', error);
+        document.getElementById('keys-table-body').innerHTML = 
+            `<tr><td colspan="9" class="text-center text-danger">加载失败: ${error.message}</td></tr>`;
+    }
+}
+
+// 渲染密钥表格
+function renderKeysTable(keys) {
+    const tableBody = document.getElementById('keys-table-body');
+    tableBody.innerHTML = '';
+    
+    if (keys.length === 0) {
+        tableBody.innerHTML = '<tr><td colspan="9" class="text-center">暂无密钥数据</td></tr>';
+        return;
+    }
+    
+    // 分页处理
+    const startIndex = (currentPage - 1) * keysPerPage;
+    const endIndex = startIndex + keysPerPage;
+    const keysToShow = keys.slice(startIndex, endIndex);
+    
+    // 渲染表格行
+    keysToShow.forEach(key => {
+        const row = document.createElement('tr');
+        
+        // 创建时间和最后使用时间格式化
+        const createDate = key.created_at ? new Date(key.created_at * 1000).toLocaleString() : '未知';
+        const lastUsedDate = key.last_used ? new Date(key.last_used * 1000).toLocaleString() : '从未使用';
+        
+        // 确定密钥状态
+        let statusText = '';
+        let statusClass = '';
+        let statusTitle = '';
+        let remainingTimeText = '';
+        
+        if (key.temp_disabled_until) {
+            // 临时禁用 - 使用格式化后的时间
+            statusText = '临时禁用';
+            statusClass = 'status-temp-disabled';
+            
+            // 优先使用服务器返回的格式化时间
+            const enableTimeText = key.temp_disabled_until_formatted || 
+                                  new Date(key.temp_disabled_until * 1000).toLocaleString();
+            
+            statusTitle = `将于 ${enableTimeText} 恢复`;
+            
+            // 如果有剩余时间信息，添加可读性更强的显示
+            if (key.temp_disabled_remaining !== undefined) {
+                const remainingSecs = key.temp_disabled_remaining;
+                if (remainingSecs > 0) {
+                    // 转换为 小时:分钟:秒 格式
+                    const hours = Math.floor(remainingSecs / 3600);
+                    const minutes = Math.floor((remainingSecs % 3600) / 60);
+                    const seconds = remainingSecs % 60;
+                    
+                    remainingTimeText = `剩余 ${hours}小时${minutes}分钟`;
+                } else {
+                    remainingTimeText = '即将恢复';
+                }
+            }
+        } else if (key.is_enabled) {
+            // 启用
+            statusText = '启用';
+            statusClass = 'status-enabled';
+        } else {
+            // 永久禁用
+            statusText = '禁用';
+            statusClass = 'status-disabled';
+        }
+        
+        row.innerHTML = `
+            <td><input type="checkbox" name="key-checkbox" class="key-checkbox" value="${key.id}" data-id="${key.id}"></td>
+            <td>${key.name || '未命名'}</td>
+            <td class="key-value">${key.key}</td>
+            <td>
+                <span class="status-badge ${statusClass}" title="${statusTitle}">
+                    ${statusText}
+                </span>
+                ${key.temp_disabled_until ? 
+                    `<div class="small text-muted">
+                        启用于: ${key.temp_disabled_until_formatted || new Date(key.temp_disabled_until * 1000).toLocaleString()}
+                        ${remainingTimeText ? `<br>${remainingTimeText}` : ''}
+                    </div>` : ''}
+            </td>
+            <td>${key.weight || 1}</td>
+            <td>${key.max_rpm || 60}/分钟</td>
+            <td>${createDate}</td>
+            <td>${lastUsedDate}</td>
+            <td>
+                <button class="btn btn-sm btn-primary action-btn edit-key" data-id="${key.id}" title="编辑">
+                    <i class="bi bi-pencil"></i>
+                </button>
+                <button class="btn btn-sm btn-danger action-btn delete-key" data-id="${key.id}" title="删除">
+                    <i class="bi bi-trash"></i>
+                </button>
+                <button class="btn btn-sm btn-secondary action-btn copy-key" data-key="${key.key}" title="复制密钥">
+                    <i class="bi bi-clipboard"></i>
+                </button>
+            </td>
+        `;
+        
+        tableBody.appendChild(row);
+    });
+    
+    // 绑定操作按钮事件
+    bindTableEvents();
+    
+    // 更新分页
+    renderPagination(keys.length);
+}
+
+// 绑定表格操作事件
+function bindTableEvents() {
+    // 编辑按钮
+    document.querySelectorAll('.edit-key').forEach(btn => {
+        btn.addEventListener('click', async () => {
+            const keyId = btn.getAttribute('data-id');
+            await loadKeyDetails(keyId);
+            
+            // 显示模态框
+            document.getElementById('keyModalLabel').textContent = '编辑密钥';
+            const keyModal = new bootstrap.Modal(document.getElementById('keyModal'));
+            keyModal.show();
+        });
+    });
+    
+    // 删除按钮
+    document.querySelectorAll('.delete-key').forEach(btn => {
+        btn.addEventListener('click', () => {
+            const keyId = btn.getAttribute('data-id');
+            const keyName = btn.closest('tr').children[1].textContent;
+            
+            showConfirmDialog(`确定要删除密钥 "${keyName}" 吗？此操作不可恢复！`, () => {
+                deleteKey(keyId);
+            });
+        });
+    });
+    
+    // 复制按钮
+    document.querySelectorAll('.copy-key').forEach(btn => {
+        btn.addEventListener('click', () => {
+            const keyValue = btn.getAttribute('data-key');
+            navigator.clipboard.writeText(keyValue)
+                .then(() => showToast('密钥已复制到剪贴板', 'success'))
+                .catch(err => showToast('复制失败: ' + err, 'error'));
+        });
+    });
+}
+
+// 渲染分页
+function renderPagination(totalKeys) {
+    const pagination = document.getElementById('pagination');
+    pagination.innerHTML = '';
+    
+    if (totalKeys <= keysPerPage) {
+        return;
+    }
+    
+    const totalPages = Math.ceil(totalKeys / keysPerPage);
+    const ul = document.createElement('ul');
+    ul.className = 'pagination';
+    
+    // 上一页
+    const prevLi = document.createElement('li');
+    prevLi.className = `page-item ${currentPage === 1 ? 'disabled' : ''}`;
+    prevLi.innerHTML = `<a class="page-link" href="#" data-page="${currentPage - 1}">上一页</a>`;
+    ul.appendChild(prevLi);
+    
+    // 页码
+    for (let i = 1; i <= totalPages; i++) {
+        const li = document.createElement('li');
+        li.className = `page-item ${currentPage === i ? 'active' : ''}`;
+        li.innerHTML = `<a class="page-link" href="#" data-page="${i}">${i}</a>`;
+        ul.appendChild(li);
+    }
+    
+    // 下一页
+    const nextLi = document.createElement('li');
+    nextLi.className = `page-item ${currentPage === totalPages ? 'disabled' : ''}`;
+    nextLi.innerHTML = `<a class="page-link" href="#" data-page="${currentPage + 1}">下一页</a>`;
+    ul.appendChild(nextLi);
+    
+    pagination.appendChild(ul);
+    
+    // 绑定页码点击事件
+    document.querySelectorAll('.page-link').forEach(link => {
+        link.addEventListener('click', (e) => {
+            e.preventDefault();
+            if (link.parentElement.classList.contains('disabled')) {
+                return;
+            }
+            currentPage = parseInt(link.getAttribute('data-page'));
+            renderKeysTable(keysData);
+        });
+    });
+}
+
+// 加载单个密钥详情
+async function loadKeyDetails(keyId) {
+    try {
+        const keyData = await apiRequest(`/api/keys/${keyId}`);
+        if (!keyData) return;
+        
+        // 填充表单
+        document.getElementById('key-id').value = keyData.id;
+        document.getElementById('key-name').value = keyData.name || '';
+        document.getElementById('key-value').value = keyData.key || '';
+        document.getElementById('key-weight').value = keyData.weight || 1;
+        document.getElementById('key-rate-limit').value = keyData.max_rpm || 60;
+        document.getElementById('key-enabled').checked = keyData.is_enabled;
+        document.getElementById('key-notes').value = keyData.notes || '';
+    } catch (error) {
+        console.error('加载密钥详情失败:', error);
+        showToast('加载密钥详情失败: ' + error.message, 'error');
+    }
+}
+
+// 保存密钥
+async function saveKey() {
+    try {
+        const keyId = document.getElementById('key-id').value;
+        const keyData = {
+            name: document.getElementById('key-name').value,
+            key_value: document.getElementById('key-value').value,
+            weight: parseInt(document.getElementById('key-weight').value),
+            rate_limit: parseInt(document.getElementById('key-rate-limit').value),
+            is_enabled: document.getElementById('key-enabled').checked,
+            notes: document.getElementById('key-notes').value
+        };
+        
+        if (!keyData.name || !keyData.key_value) {
+            showToast('密钥名称和值不能为空', 'warning');
+            return;
+        }
+        
+        let url, method;
+        
+        if (keyId) {
+            // 更新现有密钥
+            url = `/api/keys/${keyId}`;
+            method = 'PUT';
+        } else {
+            // 创建新密钥
+            url = '/api/keys';
+            method = 'POST';
+        }
+        
+        const options = {
+            method,
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(keyData)
+        };
+        
+        const result = await apiRequest(url, options);
+        if (!result) return;
+        
+        // 关闭模态框
+        const keyModal = bootstrap.Modal.getInstance(document.getElementById('keyModal'));
+        keyModal.hide();
+        
+        // 重新加载密钥列表
+        await loadKeys();
+        
+        // 如果是仪表盘页面，也更新仪表盘数据
+        if (document.getElementById('dashboard-page').classList.contains('active')) {
+            await loadDashboard();
+        }
+        
+        // 显示成功消息
+        showToast(keyId ? '密钥更新成功' : '密钥添加成功', 'success');
+    } catch (error) {
+        console.error('保存密钥失败:', error);
+        showToast('保存密钥失败: ' + error.message, 'error');
+    }
+}
+
+// 测试密钥连接
+async function testKey() {
+    try {
+        const keyValue = document.getElementById('key-value').value;
+        
+        if (!keyValue) {
+            showToast('请输入有效的密钥值', 'warning');
+            return;
+        }
+        
+        const keyName = document.getElementById('key-name').value || '新密钥';
+        
+        // 显示测试中状态
+        const testButton = document.getElementById('test-key-btn');
+        const originalText = testButton.innerHTML;
+        testButton.innerHTML = '<i class="bi bi-hourglass-split me-1"></i> 测试中...';
+        testButton.disabled = true;
+        
+        const testData = {
+            name: keyName,
+            key_value: keyValue
+        };
+        
+        const result = await apiRequest('/api/keys/test', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(testData)
+        });
+        
+        // 恢复按钮状态
+        testButton.innerHTML = originalText;
+        testButton.disabled = false;
+        
+        if (!result) return;
+        
+        if (result.status === "success") {
+            showToast(`测试成功: ${result.message || '密钥可用'}`, 'success');
+        } else {
+            showToast(`测试失败: ${result.message || '密钥无法连接'}`, 'warning');
+        }
+    } catch (error) {
+        console.error('测试密钥失败:', error);
+        showToast('测试密钥失败: ' + error.message, 'error');
+        
+        // 恢复按钮状态
+        const testButton = document.getElementById('test-key-btn');
+        testButton.innerHTML = '<i class="bi bi-shield-check me-1"></i> 测试连接';
+        testButton.disabled = false;
+    }
+}
+
+// 删除密钥
+async function deleteKey(keyId) {
+    try {
+        const result = await apiRequest(`/api/keys/${keyId}`, {
+            method: 'DELETE'
+        });
+        
+        if (!result) return;
+        
+        // 重新加载密钥列表
+        await loadKeys();
+        
+        // 如果是仪表盘页面，也更新仪表盘数据
+        if (document.getElementById('dashboard-page').classList.contains('active')) {
+            await loadDashboard();
+        }
+        
+        // 显示成功消息
+        showToast('密钥删除成功', 'success');
+    } catch (error) {
+        console.error('删除密钥失败:', error);
+        showToast('删除密钥失败: ' + error.message, 'error');
+    }
+}
+
+// 批量操作
+async function batchOperation(action, keyIds) {
+    try {
+        const operationData = {
+            action: action,
+            key_ids: keyIds
+        };
+        
+        const result = await apiRequest('/api/keys/batch', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(operationData)
+        });
+        
+        if (!result) return;
+        
+        // 重新加载密钥列表
+        await loadKeys();
+        
+        // 如果是仪表盘页面，也更新仪表盘数据
+        if (document.getElementById('dashboard-page').classList.contains('active')) {
+            await loadDashboard();
+        }
+        
+        // 显示成功消息
+        let message = '';
+        if (action === 'enable') {
+            message = '批量启用成功';
+        } else if (action === 'disable') {
+            message = '批量禁用成功';
+        } else if (action === 'delete') {
+            message = '批量删除成功';
+        }
+        
+        showToast(message, 'success');
+    } catch (error) {
+        console.error('批量操作失败:', error);
+        showToast('批量操作失败: ' + error.message, 'error');
+    }
+}
+
+// 获取所有选中的密钥ID
+function getSelectedKeyIds() {
+    const checkboxes = document.querySelectorAll('#keys-table-body input[type="checkbox"]:checked');
+    return Array.from(checkboxes).map(checkbox => checkbox.getAttribute('data-id'));
+}
+
+// 加载统计数据
+async function loadStats() {
+    try {
+        // 显示加载中状态
+        document.getElementById('total-requests').textContent = '加载中...';
+        document.getElementById('successful-requests').textContent = '加载中...';
+        document.getElementById('failed-requests').textContent = '加载中...';
+        document.getElementById('success-rate').textContent = '加载中...';
+        
+        const data = await apiRequest('/api/stats');
+        if (data) {
+            statsData = data;
+            
+            // 渲染统计卡片
+            renderStats();
+            
+            // 渲染图表
+            renderRequestsChart(statsData.daily_usage);
+            renderKeysUsageChart(statsData.keys_usage);
+        }
+    } catch (error) {
+        console.error('加载统计数据失败:', error);
+        
+        // 创建模拟数据
+        statsData = {
+            total_requests: Math.floor(Math.random() * 5000) + 1000,
+            successful_requests: Math.floor(Math.random() * 4000) + 800,
+            daily_usage: generateMockDailyUsage(),
+            keys_usage: generateMockKeysUsage()
+        };
+        
+        // 渲染模拟数据
+        renderStats();
+        renderRequestsChart(statsData.daily_usage);
+        renderKeysUsageChart(statsData.keys_usage);
+    }
+}
+
+// 渲染统计卡片
+function renderStats() {
+    if (!statsData) {
+        // 如果没有统计数据，使用默认值
+        statsData = {
+            total_requests: 0,
+            successful_requests: 0
+        };
+    }
+    
+    const totalRequests = statsData.total_requests || 0;
+    const successfulRequests = statsData.successful_requests || 0;
+    const failedRequests = totalRequests - successfulRequests;
+    const successRate = totalRequests > 0 ? ((successfulRequests / totalRequests) * 100).toFixed(1) + '%' : '0%';
+    
+    // 更新统计卡片
+    document.getElementById('total-requests').textContent = totalRequests;
+    document.getElementById('successful-requests').textContent = successfulRequests;
+    document.getElementById('failed-requests').textContent = failedRequests;
+    document.getElementById('success-rate').textContent = successRate;
+}
+
+// 渲染请求趋势图
+function renderRequestsChart(dailyUsage) {
+    // 准备数据
+    const dates = Object.keys(dailyUsage || {}).sort();
+    const lastDates = dates.slice(-30); // 最近30天
+    
+    const chartData = {
+        labels: lastDates.map(date => date.substring(5)), // 只显示月-日
+        datasets: [{
+            label: '请求数',
+            data: lastDates.map(date => dailyUsage[date] || 0),
+            backgroundColor: 'rgba(13, 110, 253, 0.4)',
+            borderColor: 'rgba(13, 110, 253, 1)',
+            borderWidth: 2
+        }]
+    };
+    
+    // 销毁现有图表
+    if (requestsChart) {
+        requestsChart.destroy();
+    }
+    
+    // 创建新图表
+    const ctx = document.getElementById('requests-chart').getContext('2d');
+    requestsChart = new Chart(ctx, {
+        type: 'bar',
+        data: chartData,
+        options: {
+            responsive: true,
+            maintainAspectRatio: false,
+            plugins: {
+                legend: {
+                    display: false
+                },
+                tooltip: {
+                    mode: 'index',
+                    intersect: false
+                }
+            },
+            scales: {
+                x: {
+                    grid: {
+                        display: false
+                    }
+                },
+                y: {
+                    beginAtZero: true,
+                    ticks: {
+                        precision: 0
+                    }
+                }
+            }
+        }
+    });
+}
+
+// 渲染密钥使用分布图
+function renderKeysUsageChart(keysUsage) {
+    // 准备数据
+    const keys = Object.keys(keysUsage || {});
+    const values = keys.map(key => keysUsage[key]);
+    
+    // 只显示前8个密钥，其余归为"其他"
+    let displayKeys = keys;
+    let displayValues = values;
+    
+    if (keys.length > 8) {
+        displayKeys = keys.slice(0, 7);
+        displayValues = values.slice(0, 7);
+        
+        // 计算"其他"的总和
+        const othersSum = values.slice(7).reduce((sum, value) => sum + value, 0);
+        displayKeys.push('其他');
+        displayValues.push(othersSum);
+    }
+    
+    // 生成颜色
+    const backgroundColors = [
+        'rgba(13, 110, 253, 0.7)',   // 主蓝色
+        'rgba(220, 53, 69, 0.7)',    // 红色
+        'rgba(25, 135, 84, 0.7)',    // 绿色
+        'rgba(255, 193, 7, 0.7)',    // 黄色
+        'rgba(111, 66, 193, 0.7)',   // 紫色
+        'rgba(23, 162, 184, 0.7)',   // 青色
+        'rgba(102, 16, 242, 0.7)',   // 靛蓝色
+        'rgba(108, 117, 125, 0.7)'   // 灰色
+    ];
+    
+    const chartData = {
+        labels: displayKeys,
+        datasets: [{
+            data: displayValues,
+            backgroundColor: backgroundColors,
+            borderColor: backgroundColors.map(color => color.replace('0.7', '1')),
+            borderWidth: 1
+        }]
+    };
+    
+    // 销毁现有图表
+    if (keysUsageChart) {
+        keysUsageChart.destroy();
+    }
+    
+    // 创建新图表
+    const ctx = document.getElementById('keys-usage-chart').getContext('2d');
+    keysUsageChart = new Chart(ctx, {
+        type: 'pie',
+        data: chartData,
+        options: {
+            responsive: true,
+            maintainAspectRatio: false,
+            plugins: {
+                legend: {
+                    position: 'right'
+                }
+            }
+        }
+    });
+}
+
+// 加载系统设置
+async function loadSettings() {
+    try {
+        const data = await apiRequest('/api/config');
+        if (!data) return;
+        
+        // 设置现有的代理设置
+        document.getElementById('proxy-host').value = data.PROXY_HOST || '';
+        document.getElementById('proxy-port').value = data.PROXY_PORT || '';
+        document.getElementById('proxy-user').value = data.PROXY_USER || '';
+        document.getElementById('proxy-pass').value = '';
+        
+        // 设置基础URL
+        document.getElementById('base-url').value = data.BASE_URL || '';
+        
+        // 设置图片本地化配置
+        document.getElementById('image-localization').checked = data.IMAGE_LOCALIZATION || false;
+        document.getElementById('image-save-dir').value = data.IMAGE_SAVE_DIR || 'src/static/images';
+    } catch (error) {
+        console.error('加载设置失败:', error);
+        showToast('获取设置失败: ' + error.message, 'error');
+    }
+}
+
+// 保存系统设置
+async function saveSettings() {
+    try {
+        // 获取表单数据
+        const config = {
+            PROXY_HOST: document.getElementById('proxy-host').value,
+            PROXY_PORT: document.getElementById('proxy-port').value,
+            PROXY_USER: document.getElementById('proxy-user').value,
+            PROXY_PASS: document.getElementById('proxy-pass').value,
+            BASE_URL: document.getElementById('base-url').value,
+            IMAGE_LOCALIZATION: document.getElementById('image-localization').checked,
+            IMAGE_SAVE_DIR: document.getElementById('image-save-dir').value || 'src/static/images',
+            save_to_env: true
+        };
+        
+        // 调用API保存到服务器
+        const result = await apiRequest('/api/config', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(config)
+        });
+        
+        if (!result) return;
+        
+        showToast('设置已保存', 'success');
+    } catch (error) {
+        console.error('保存设置失败:', error);
+        showToast('保存设置失败: ' + error.message, 'error');
+    }
+}
+
+// 显示确认对话框
+function showConfirmDialog(message, callback) {
+    document.getElementById('confirm-message').textContent = message;
+    const confirmModal = new bootstrap.Modal(document.getElementById('confirmModal'));
+    
+    // 确认按钮事件
+    document.getElementById('confirm-btn').onclick = () => {
+        confirmModal.hide();
+        if (typeof callback === 'function') {
+            callback();
+        }
+    };
+    
+    confirmModal.show();
+}
+
+// 显示提示消息
+function showToast(message, type = 'info') {
+    // 创建Toast元素
+    const toastId = 'toast-' + Date.now();
+    const toastEl = document.createElement('div');
+    toastEl.className = `toast align-items-center text-white bg-${type}`;
+    toastEl.id = toastId;
+    toastEl.setAttribute('role', 'alert');
+    toastEl.setAttribute('aria-live', 'assertive');
+    toastEl.setAttribute('aria-atomic', 'true');
+    
+    toastEl.innerHTML = `
+        <div class="d-flex">
+            <div class="toast-body">
+                ${message}
+            </div>
+            <button type="button" class="btn-close btn-close-white me-2 m-auto" data-bs-dismiss="toast" aria-label="Close"></button>
+        </div>
+    `;
+    
+    // 添加到容器
+    document.getElementById('toast-container').appendChild(toastEl);
+    
+    // 显示Toast
+    const toast = new bootstrap.Toast(toastEl, {
+        autohide: true,
+        delay: 3000
+    });
+    toast.show();
+    
+    // 监听隐藏事件，删除元素
+    toastEl.addEventListener('hidden.bs.toast', () => {
+        toastEl.remove();
+    });
+}
+
+// 加载仪表盘数据
+async function loadDashboard() {
+    try {
+        // 先加载密钥统计
+        await loadKeyStats();
+        
+        // 再加载使用统计
+        await loadUsageStats();
+        
+        // 加载最近的密钥
+        await loadRecentKeys();
+    } catch (error) {
+        console.error('加载仪表盘数据失败:', error);
+        showToast('仪表盘数据加载失败', 'error');
+    }
+}
+
+// 加载密钥统计
+async function loadKeyStats() {
+    try {
+        const data = await apiRequest('/api/keys');
+        if (!data) return;
+        
+        keysData = data;
+        
+        // 计算统计数据
+        const totalKeys = keysData.length;
+        const activeKeys = keysData.filter(key => key.is_enabled).length;
+        const disabledKeys = totalKeys - activeKeys;
+        
+        // 更新统计卡片
+        document.getElementById('total-keys').textContent = totalKeys;
+        document.getElementById('active-keys').textContent = activeKeys;
+        document.getElementById('disabled-keys').textContent = disabledKeys;
+    } catch (error) {
+        console.error('加载密钥统计失败:', error);
+    }
+}
+
+// 加载使用统计
+async function loadUsageStats() {
+    try {
+        const data = await apiRequest('/api/stats');
+        if (!data) return;
+        
+        // 更新仪表盘统计数据
+        const totalRequests = data.total_requests || 0;
+        const successfulRequests = data.successful_requests || 0;
+        const failedRequests = data.failed_requests || 0;
+        
+        // 更新统计卡片
+        document.getElementById('total-requests').textContent = totalRequests;
+        document.getElementById('successful-requests').textContent = successfulRequests;
+        document.getElementById('failed-requests').textContent = failedRequests;
+        
+        // 计算成功率
+        const successRate = totalRequests > 0 ? Math.round((successfulRequests / totalRequests) * 100) : 0;
+        document.getElementById('success-rate').textContent = `${successRate}%`;
+        
+        // 获取今日使用量
+        const today = new Date().toISOString().split('T')[0];
+        const todayRequests = (data.daily_usage && data.daily_usage[today]) || 0;
+        document.getElementById('today-requests').textContent = todayRequests;
+        
+        // 设置图表数据
+        statsData = data;
+        
+        // 更新图表
+        renderDashboardRequestsChart(data.daily_usage || {});
+        
+        // 渲染请求趋势图和密钥使用分布图
+        renderRequestsChart(data.daily_usage || {});
+        renderKeysUsageChart(data.keys_usage || {});
+        
+        console.log("图表数据已更新:", {
+            daily_usage: data.daily_usage,
+            keys_usage: data.keys_usage
+        });
+    } catch (error) {
+        console.error('加载使用统计失败:', error);
+    }
+}
+
+// 加载最近的密钥
+async function loadRecentKeys() {
+    try {
+        if (!keysData || keysData.length === 0) {
+            const data = await apiRequest('/api/keys');
+            if (!data) return;
+            keysData = data;
+        }
+        
+        // 按创建时间排序，获取最近的5个
+        const recentKeys = [...keysData]
+            .sort((a, b) => (b.created_at || 0) - (a.created_at || 0))
+            .slice(0, 5);
+            
+        const recentKeysList = document.getElementById('recent-keys-list');
+        recentKeysList.innerHTML = '';
+        
+        if (recentKeys.length === 0) {
+            recentKeysList.innerHTML = '<div class="list-group-item text-center text-muted">暂无密钥数据</div>';
+            return;
+        }
+        
+        recentKeys.forEach(key => {
+            const createDate = key.created_at ? new Date(key.created_at * 1000).toLocaleDateString() : '未知';
+            const li = document.createElement('a');
+            li.className = 'list-group-item list-group-item-action d-flex justify-content-between align-items-center';
+            li.href = '#';
+            li.innerHTML = `
+                <div>
+                    <strong>${key.name || '未命名'}</strong>
+                    <div class="text-muted small">${key.key.substring(0, 10)}...</div>
+                </div>
+                <div>
+                    <span class="badge ${key.is_enabled ? 'bg-success' : 'bg-danger'} rounded-pill">
+                        ${key.is_enabled ? '启用' : '禁用'}
+                    </span>
+                    <small class="text-muted ms-2">${createDate}</small>
+                </div>
+            `;
+            recentKeysList.appendChild(li);
+            
+            // 点击跳转到密钥管理页面
+            li.addEventListener('click', (e) => {
+                e.preventDefault();
+                document.querySelector('#sidebar a[data-page="keys"]').click();
+            });
+        });
+    } catch (error) {
+        console.error('加载最近密钥失败:', error);
+    }
+}
+
+// 渲染仪表盘请求趋势图
+function renderDashboardRequestsChart(dailyUsage) {
+    // 获取最近7天的日期
+    const dates = [];
+    const now = new Date();
+    for (let i = 6; i >= 0; i--) {
+        const date = new Date(now);
+        date.setDate(now.getDate() - i);
+        dates.push(date.toISOString().split('T')[0]);
+    }
+    
+    // 准备图表数据
+    const chartData = {
+        labels: dates.map(date => date.substring(5)), // 只显示月-日
+        datasets: [{
+            label: '每日请求数',
+            data: dates.map(date => (dailyUsage && dailyUsage[date]) || 0),
+            borderColor: '#0d6efd',
+            backgroundColor: 'rgba(13, 110, 253, 0.1)',
+            borderWidth: 2,
+            fill: true,
+            tension: 0.3
+        }]
+    };
+    
+    // 销毁现有图表
+    if (dashboardRequestsChart) {
+        dashboardRequestsChart.destroy();
+    }
+    
+    // 创建新图表
+    const ctx = document.getElementById('dashboard-requests-chart').getContext('2d');
+    dashboardRequestsChart = new Chart(ctx, {
+        type: 'line',
+        data: chartData,
+        options: {
+            responsive: true,
+            maintainAspectRatio: false,
+            plugins: {
+                legend: {
+                    display: false
+                },
+                tooltip: {
+                    mode: 'index',
+                    intersect: false
+                }
+            },
+            scales: {
+                x: {
+                    grid: {
+                        display: false
+                    }
+                },
+                y: {
+                    beginAtZero: true,
+                    ticks: {
+                        precision: 0
+                    }
+                }
+            }
+        }
+    });
+}
+
+// 批量导入密钥预览
+async function previewImport() {
+    const keysText = document.getElementById('keys-text').value.trim();
+    
+    if (!keysText) {
+        showToast('请输入或上传密钥数据', 'warning');
+        return;
+    }
+    
+    try {
+        // 解析密钥数据
+        const lines = keysText.split('\n').filter(line => line.trim());
+        importPreviewData = [];
+        
+        console.log(`开始处理 ${lines.length} 行数据`);
+        
+        for (let i = 0; i < lines.length; i++) {
+            try {
+                const line = lines[i];
+                // 安全获取子字符串
+                const safeSubstring = (str, start, end) => {
+                    if (!str) return '';
+                    return str.substring(start, Math.min(end, str.length));
+                };
+                
+                console.log(`处理第 ${i+1} 行: ${safeSubstring(line, 0, 10)}...`);
+                
+                // 检查是否是单行密钥格式（不包含逗号）
+                if (!line.includes(',')) {
+                    const keyValue = line.trim();
+                    console.log(`  单行格式，密钥值: ${safeSubstring(keyValue, 0, 5)}...`);
+                    
+                    // 几乎不做验证 - 只要不是空字符串或太短就接受
+                    if (!keyValue || keyValue.length < 5) {
+                        console.log(`  密钥太短，跳过`);
+                        continue; // 跳过太短的密钥
+                    }
+                    
+                    // 为密钥自动生成名称（使用前5位）
+                    const keyName = `密钥_${safeSubstring(keyValue, 0, 5)}`;
+                    
+                    importPreviewData.push({
+                        name: keyName,
+                        key: keyValue,
+                        weight: 1,
+                        rate_limit: 60,
+                        enabled: document.getElementById('auto-enable-keys').checked
+                    });
+                    console.log(`  添加到预览数据，当前共 ${importPreviewData.length} 个`);
+                    continue;
+                }
+                
+                // 处理标准格式（带逗号分隔）
+                const parts = line.split(',').map(part => part.trim());
+                console.log(`  标准格式，分割后有 ${parts.length} 部分`);
+                
+                if (parts.length < 2) {
+                    console.log(`  部分数量不足2，跳过`);
+                    continue; // 跳过格式不正确的行
+                }
+                
+                const keyName = parts[0] || `密钥_未命名_${i+1}`;
+                const keyValue = parts[1] || '';
+                const weight = parts.length > 2 ? parseInt(parts[2]) || 1 : 1;
+                const rateLimit = parts.length > 3 ? parseInt(parts[3]) || 60 : 60;
+                
+                console.log(`  名称: ${keyName}, 密钥: ${safeSubstring(keyValue, 0, 5)}..., 权重: ${weight}, 速率: ${rateLimit}`);
+                
+                // 几乎不做验证 - 只要不是空字符串或太短就接受
+                if (!keyValue || keyValue.length < 5) {
+                    console.log(`  密钥太短，跳过`);
+                    continue; // 跳过太短的密钥
+                }
+                
+                importPreviewData.push({
+                    name: keyName,
+                    key: keyValue,
+                    weight: weight,
+                    rate_limit: rateLimit,
+                    enabled: document.getElementById('auto-enable-keys').checked
+                });
+                console.log(`  添加到预览数据，当前共 ${importPreviewData.length} 个`);
+            } catch (lineError) {
+                console.error(`处理第 ${i+1} 行时出错:`, lineError);
+                // 继续处理下一行
+                continue;
+            }
+        }
+        
+        console.log(`处理完成，共有 ${importPreviewData.length} 个有效密钥`);
+        
+        // 显示预览
+        if (importPreviewData.length > 0) {
+            renderImportPreview();
+            document.getElementById('preview-count').textContent = importPreviewData.length;
+            document.getElementById('import-preview').style.display = 'block';
+            document.getElementById('confirm-import-btn').disabled = false;
+            console.log('预览渲染完成，启用导入按钮');
+        } else {
+            showToast('未找到有效的密钥数据', 'warning');
+            document.getElementById('import-preview').style.display = 'none';
+            document.getElementById('confirm-import-btn').disabled = true;
+            console.log('未找到有效密钥，禁用导入按钮');
+        }
+    } catch (error) {
+        console.error('预览导入失败:', error);
+        showToast('预览失败: ' + error.message, 'danger');
+    }
+}
+
+// 渲染导入预览表格
+function renderImportPreview() {
+    const tableBody = document.getElementById('preview-table-body');
+    tableBody.innerHTML = '';
+    
+    // 限制预览最多显示10行
+    const displayData = importPreviewData.slice(0, 10);
+    
+    displayData.forEach(key => {
+        const row = document.createElement('tr');
+        
+        // 名称
+        const nameCell = document.createElement('td');
+        nameCell.textContent = key.name;
+        row.appendChild(nameCell);
+        
+        // 密钥(部分隐藏)
+        const keyCell = document.createElement('td');
+        const maskedKey = key.key.substring(0, 5) + '...' + key.key.substring(key.key.length - 4);
+        keyCell.textContent = maskedKey;
+        row.appendChild(keyCell);
+        
+        // 权重
+        const weightCell = document.createElement('td');
+        weightCell.textContent = key.weight;
+        row.appendChild(weightCell);
+        
+        // 速率限制
+        const rateLimitCell = document.createElement('td');
+        rateLimitCell.textContent = key.rate_limit;
+        row.appendChild(rateLimitCell);
+        
+        tableBody.appendChild(row);
+    });
+    
+    // 如果有更多未显示的行
+    if (importPreviewData.length > 10) {
+        const moreRow = document.createElement('tr');
+        const moreCell = document.createElement('td');
+        moreCell.colSpan = 4;
+        moreCell.textContent = `... 另外 ${importPreviewData.length - 10} 个密钥未在预览中显示`;
+        moreCell.className = 'text-center text-muted';
+        moreRow.appendChild(moreCell);
+        tableBody.appendChild(moreRow);
+    }
+}
+
+// 确认导入密钥
+async function confirmImport() {
+    if (importPreviewData.length === 0) {
+        showToast('没有要导入的密钥', 'warning');
+        return;
+    }
+    
+    try {
+        // 显示加载状态
+        const importBtn = document.getElementById('confirm-import-btn');
+        const originalText = importBtn.textContent;
+        importBtn.disabled = true;
+        importBtn.innerHTML = '<span class="spinner-border spinner-border-sm" role="status" aria-hidden="true"></span> 导入中...';
+        
+        console.log('准备发送批量导入请求，数据预览：', importPreviewData.slice(0, 2));
+        
+        // 简化数据处理
+        const requestData = {
+            action: "import",
+            keys: []
+        };
+        
+        // 手动将每个importPreviewData项转换为普通对象
+        for (const item of importPreviewData) {
+            requestData.keys.push({
+                name: item.name || "",
+                key: item.key || "",
+                weight: item.weight || 1,
+                rate_limit: item.rate_limit || 60,
+                enabled: item.enabled !== undefined ? item.enabled : true
+            });
+        }
+        
+        console.log('发送请求到 /api/keys/batch，请求数据：', requestData);
+        
+        // 发送请求
+        const response = await apiRequest('/api/keys/batch', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(requestData)
+        });
+        
+        console.log('收到批量导入响应：', response);
+        
+        if (response && response.success) {
+            // 隐藏模态框
+            bootstrap.Modal.getInstance(document.getElementById('importKeysModal')).hide();
+            
+            // 刷新密钥列表
+            await loadKeys();
+            
+            // 显示成功消息
+            const successCount = response.imported || importPreviewData.length;
+            const skippedCount = response.skipped || 0;
+            let message = `成功导入 ${successCount} 个密钥`;
+            if (skippedCount > 0) {
+                message += `，${skippedCount} 个重复密钥已跳过`;
+            }
+            showToast(message, 'success');
+            console.log('导入成功完成');
+        } else {
+            const errorMsg = (response && response.message) ? response.message : '未知错误';
+            showToast('导入失败: ' + errorMsg, 'danger');
+            console.error('导入失败，服务器响应：', response);
+        }
+    } catch (error) {
+        console.error('导入过程中发生异常:', error);
+        showToast('导入失败: ' + error.message, 'danger');
+    } finally {
+        // 恢复按钮状态
+        const importBtn = document.getElementById('confirm-import-btn');
+        importBtn.disabled = false;
+        importBtn.textContent = '导入';
+    }
+} 

src/utils.py

@@ -0,0 +1,208 @@
+import os
+import uuid
+import aiohttp
+import aiofiles
+import logging
+import ssl
+from urllib.parse import urlparse
+from .config import Config
+
+# 初始化日志
+logger = logging.getLogger("sora-api.utils")
+
+# 图片本地化调试开关
+IMAGE_DEBUG = os.getenv("IMAGE_DEBUG", "").lower() in ("true", "1", "yes")
+
+# 修复Python 3.11之前版本中HTTPS代理处理HTTPS请求的问题
+# 参考: https://docs.aiohttp.org/en/stable/client_advanced.html#proxy-support
+try:
+    import aiohttp.connector
+    orig_create_connection = aiohttp.connector.TCPConnector._create_connection
+
+    async def patched_create_connection(self, req, traces, timeout):
+        if req.ssl and req.proxy and req.proxy.scheme == 'https':
+            # 为代理连接创建SSL上下文
+            proxy_ssl = ssl.create_default_context()
+            req.proxy_ssl = proxy_ssl
+            
+            if IMAGE_DEBUG:
+                logger.debug("已应用HTTPS代理补丁")
+        
+        return await orig_create_connection(self, req, traces, timeout)
+    
+    # 应用猴子补丁
+    aiohttp.connector.TCPConnector._create_connection = patched_create_connection
+    
+    if IMAGE_DEBUG:
+        logger.debug("已启用aiohttp HTTPS代理支持补丁")
+except Exception as e:
+    logger.warning(f"应用HTTPS代理补丁失败: {e}")
+
+async def download_and_save_image(image_url: str) -> str:
+    """
+    下载图片并保存到本地
+    
+    Args:
+        image_url: 图片URL
+        
+    Returns:
+        本地化后的图片URL
+    """
+    # 如果未启用本地化或URL已经是本地路径，直接返回
+    if not Config.IMAGE_LOCALIZATION:
+        if IMAGE_DEBUG:
+            logger.debug(f"图片本地化未启用，返回原始URL: {image_url}")
+        return image_url
+    
+    # 检查是否已经是本地URL
+    # 准备URL检测所需的信息
+    parsed_base_url = urlparse(Config.BASE_URL)
+    base_path = parsed_base_url.path.rstrip('/')
+    
+    # 直接检查常见的图片URL模式
+    local_url_patterns = [
+        "/images/",
+        "/static/images/",
+        f"{base_path}/images/",
+        f"{base_path}/static/images/"
+    ]
+    
+    # 检查是否有自定义前缀
+    if Config.STATIC_PATH_PREFIX:
+        prefix = Config.STATIC_PATH_PREFIX
+        if not prefix.startswith('/'):
+            prefix = f"/{prefix}"
+        local_url_patterns.append(f"{prefix}/images/")
+        local_url_patterns.append(f"{base_path}{prefix}/images/")
+    
+    # 检查是否符合任何本地URL模式
+    is_local_url = any(pattern in image_url for pattern in local_url_patterns)
+    
+    if is_local_url:
+        if IMAGE_DEBUG:
+            logger.debug(f"URL已是本地图片路径: {image_url}")
+        
+        # 如果是相对路径，补充完整的URL
+        if image_url.startswith("/"):
+            return f"{parsed_base_url.scheme}://{parsed_base_url.netloc}{image_url}"
+        return image_url
+    
+    try:
+        # 生成文件名和保存路径
+        parsed_url = urlparse(image_url)
+        file_extension = os.path.splitext(parsed_url.path)[1] or ".png"
+        filename = f"{uuid.uuid4()}{file_extension}"
+        save_path = os.path.join(Config.IMAGE_SAVE_DIR, filename)
+        
+        # 确保保存目录存在
+        os.makedirs(Config.IMAGE_SAVE_DIR, exist_ok=True)
+        
+        if IMAGE_DEBUG:
+            logger.debug(f"下载图片: {image_url} -> {save_path}")
+        
+        # 配置代理
+        proxy = None
+        if Config.PROXY_HOST and Config.PROXY_PORT:
+            proxy_auth = None
+            if Config.PROXY_USER and Config.PROXY_PASS:
+                proxy_auth = aiohttp.BasicAuth(Config.PROXY_USER, Config.PROXY_PASS)
+            
+            proxy_url = f"http://{Config.PROXY_HOST}:{Config.PROXY_PORT}"
+            if IMAGE_DEBUG:
+                auth_info = f" (使用认证)" if proxy_auth else ""
+                logger.debug(f"使用代理: {proxy_url}{auth_info}")
+            proxy = proxy_url
+        
+        # 下载图片
+        timeout = aiohttp.ClientTimeout(total=60)
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+            # 创建请求参数
+            request_kwargs = {"timeout": 30}
+            if proxy:
+                request_kwargs["proxy"] = proxy
+                if Config.PROXY_USER and Config.PROXY_PASS:
+                    request_kwargs["proxy_auth"] = aiohttp.BasicAuth(Config.PROXY_USER, Config.PROXY_PASS)
+            
+            async with session.get(image_url, **request_kwargs) as response:
+                if response.status != 200:
+                    logger.warning(f"下载失败，状态码: {response.status}, URL: {image_url}")
+                    return image_url
+                
+                content = await response.read()
+                if not content:
+                    logger.warning("下载内容为空")
+                    return image_url
+                
+                # 保存图片
+                async with aiofiles.open(save_path, "wb") as f:
+                    await f.write(content)
+        
+        # 检查文件是否成功保存
+        if not os.path.exists(save_path) or os.path.getsize(save_path) == 0:
+            logger.warning(f"图片保存失败: {save_path}")
+            if os.path.exists(save_path):
+                os.remove(save_path)
+            return image_url
+        
+        # 返回本地URL
+        # 获取文件名
+        filename = os.path.basename(save_path)
+        
+        # 解析基础URL
+        parsed_base_url = urlparse(Config.BASE_URL)
+        base_path = parsed_base_url.path.rstrip('/')
+        
+        # 使用固定的图片URL格式
+        relative_url = f"/images/{filename}"
+        
+        # 如果设置了STATIC_PATH_PREFIX，优先使用该前缀
+        if Config.STATIC_PATH_PREFIX:
+            prefix = Config.STATIC_PATH_PREFIX
+            if not prefix.startswith('/'):
+                prefix = f"/{prefix}"
+            relative_url = f"{prefix}/images/{filename}"
+        
+        # 如果BASE_URL有子路径，添加到相对路径前
+        if base_path:
+            relative_url = f"{base_path}{relative_url}"
+        
+        # 处理重复斜杠
+        while "//" in relative_url:
+            relative_url = relative_url.replace("//", "/")
+        
+        # 生成完整URL
+        full_url = f"{parsed_base_url.scheme}://{parsed_base_url.netloc}{relative_url}"
+        
+        if IMAGE_DEBUG:
+            logger.debug(f"图片保存成功: {full_url}")
+            logger.debug(f"图片保存路径: {save_path}")
+        
+        return full_url
+    except Exception as e:
+        logger.error(f"图片下载失败: {str(e)}", exc_info=IMAGE_DEBUG)
+        return image_url
+
+async def localize_image_urls(image_urls: list) -> list:
+    """
+    批量将图片URL本地化
+    
+    Args:
+        image_urls: 图片URL列表
+        
+    Returns:
+        本地化后的URL列表
+    """
+    if not Config.IMAGE_LOCALIZATION or not image_urls:
+        return image_urls
+    
+    if IMAGE_DEBUG:
+        logger.debug(f"本地化 {len(image_urls)} 个URL: {image_urls}")
+    else:
+        logger.info(f"本地化 {len(image_urls)} 个图片")
+    
+    localized_urls = []
+    for url in image_urls:
+        localized_url = await download_and_save_image(url)
+        localized_urls.append(localized_url)
+    
+    return localized_urls 

test_client.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import requests
+import json
+import time
+import sys
+import base64
+import os
+
+# 设置UTF-8编码
+if sys.platform.startswith('win'):
+    os.system("chcp 65001")
+    if hasattr(sys.stdout, 'reconfigure'):
+        sys.stdout.reconfigure(encoding='utf-8')
+
+API_URL = "http://127.0.0.1:8890/v1/chat/completions"
+API_KEY = "sk-123456"  # 替换为实际的API key
+
+def test_text_to_image(prompt="生成一只可爱的猫咪", stream=False):
+    """测试文本到图像生成"""
+    print(f"\n===== 测试文本到图像生成 =====")
+    try:
+        print(f"提示词: '{prompt}'")
+    except UnicodeEncodeError:
+        print(f"提示词: [包含非ASCII字符]")
+    print(f"流式响应: {stream}")
+    
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {API_KEY}"
+    }
+    
+    payload = {
+        "model": "sora-1.0",
+        "messages": [
+            {"role": "user", "content": prompt}
+        ],
+        "n": 1,
+        "stream": stream
+    }
+    
+    start_time = time.time()
+    response = requests.post(
+        API_URL,
+        headers=headers,
+        json=payload,
+        stream=stream
+    )
+    
+    if response.status_code != 200:
+        print(f"错误: 状态码 {response.status_code}")
+        print(response.text)
+        return
+    
+    if stream:
+        # 处理流式响应
+        print("流式响应内容:")
+        for line in response.iter_lines():
+            if line:
+                line = line.decode('utf-8')
+                if line.startswith("data: "):
+                    data = line[6:]
+                    if data == "[DONE]":
+                        print("[完成]")
+                    else:
+                        try:
+                            json_data = json.loads(data)
+                            if 'choices' in json_data and json_data['choices'] and 'delta' in json_data['choices'][0]:
+                                delta = json_data['choices'][0]['delta']
+                                if 'content' in delta:
+                                    print(f"接收内容: {delta['content']}")
+                        except Exception as e:
+                            print(f"解析响应时出错: {e}")
+    else:
+        # 处理普通响应
+        try:
+            data = response.json()
+            print(f"响应内容:")
+            print(json.dumps(data, indent=2, ensure_ascii=False))
+            
+            if 'choices' in data and data['choices']:
+                image_url = None
+                content = data['choices'][0]['message']['content']
+                if "![Generated Image](" in content:
+                    image_url = content.split("![Generated Image](")[1].split(")")[0]
+                    print(f"\n生成的图片URL: {image_url}")
+        except Exception as e:
+            print(f"解析响应时出错: {e}")
+    
+    elapsed = time.time() - start_time
+    print(f"请求耗时: {elapsed:.2f}秒")
+
+def test_image_to_image(image_path, prompt="将这张图片变成动漫风格"):
+    """测试图像到图像生成（Remix）"""
+    print(f"\n===== 测试图像到图像生成 =====")
+    print(f"图片路径: '{image_path}'")
+    print(f"提示词: '{prompt}'")
+    
+    # 读取并转换图片为base64
+    try:
+        with open(image_path, "rb") as image_file:
+            base64_image = base64.b64encode(image_file.read()).decode('utf-8')
+    except Exception as e:
+        print(f"读取图片失败: {e}")
+        return
+    
+    # 构建请求
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {API_KEY}"
+    }
+    
+    payload = {
+        "model": "sora-1.0",
+        "messages": [
+            {"role": "user", "content": f"data:image/jpeg;base64,{base64_image}\n{prompt}"}
+        ],
+        "n": 1,
+        "stream": False
+    }
+    
+    start_time = time.time()
+    response = requests.post(
+        API_URL,
+        headers=headers,
+        json=payload
+    )
+    
+    if response.status_code != 200:
+        print(f"错误: 状态码 {response.status_code}")
+        print(response.text)
+        return
+    
+    # 处理响应
+    try:
+        data = response.json()
+        print(f"响应内容:")
+        print(json.dumps(data, indent=2, ensure_ascii=False))
+        
+        if 'choices' in data and data['choices']:
+            image_url = None
+            content = data['choices'][0]['message']['content']
+            if "![Generated Image](" in content:
+                image_url = content.split("![Generated Image](")[1].split(")")[0]
+                print(f"\n生成的图片URL: {image_url}")
+    except Exception as e:
+        print(f"解析响应时出错: {e}")
+    
+    elapsed = time.time() - start_time
+    print(f"请求耗时: {elapsed:.2f}秒")
+
+def main():
+    """主函数"""
+    if len(sys.argv) < 2:
+        print("用法: python test_client.py <测试类型> [参数...]")
+        print("测试类型:")
+        print("  text2img <提示词> [stream=true/false]")
+        print("  img2img <图片路径> <提示词>")
+        return
+    
+    test_type = sys.argv[1].lower()
+    
+    if test_type == "text2img":
+        prompt = sys.argv[2] if len(sys.argv) > 2 else "生成一只可爱的猫咪"
+        stream = False
+        if len(sys.argv) > 3 and sys.argv[3].lower() == "stream=true":
+            stream = True
+        test_text_to_image(prompt, stream)
+    elif test_type == "img2img":
+        if len(sys.argv) < 3:
+            print("错误: 需要图片路径")
+            return
+        image_path = sys.argv[2]
+        prompt = sys.argv[3] if len(sys.argv) > 3 else "将这张图片变成动漫风格"
+        test_image_to_image(image_path, prompt)
+    else:
+        print(f"错误: 未知的测试类型 '{test_type}'")
+
+if __name__ == "__main__":
+    main() 

test_image_download.py

@@ -0,0 +1,131 @@
+import asyncio
+import os
+import sys
+import logging
+
+# 配置日志
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+
+# 添加src目录到Python路径
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from src.utils import download_and_save_image, localize_image_urls
+from src.config import Config
+
+# 设置为True启用本地化
+Config.IMAGE_LOCALIZATION = True
+# 打开调试日志
+os.environ["IMAGE_DEBUG"] = "true"
+# 确保目录存在
+os.makedirs(Config.IMAGE_SAVE_DIR, exist_ok=True)
+
+async def test_single_download():
+    """测试单个图片下载"""
+    # 使用一个可靠的图片URL进行测试
+    test_url = "https://pic.baidu.com/feed/b90e7bec54e736d1f9ddbe94c2691f254d4ade13.jpeg"
+    print(f"测试单个图片下载: {test_url}")
+    
+    local_url = await download_and_save_image(test_url)
+    print(f"下载结果: {local_url}")
+    
+    # 检查文件是否真的下载了
+    if local_url.startswith("http"):
+        # 处理完整URL的情况
+        url_path = local_url.split(Config.BASE_URL, 1)[-1]
+        if url_path.startswith("/static/"):
+            relative_path = url_path[len("/static/"):]
+            file_path = os.path.join(Config.STATIC_DIR, relative_path)
+            print(f"完整URL转换为文件路径: {file_path}")
+            
+            if os.path.exists(file_path):
+                print(f"文件存在: {file_path}, 大小: {os.path.getsize(file_path)} 字节")
+            else:
+                print(f"文件不存在: {file_path}")
+                # 尝试查找可能的文件
+                dir_path = os.path.dirname(file_path)
+                if os.path.exists(dir_path):
+                    print(f"目录存在: {dir_path}")
+                    print(f"目录内容: {os.listdir(dir_path)}")
+                else:
+                    print(f"目录不存在: {dir_path}")
+        else:
+            print(f"URL格式异常: {local_url}")
+    elif local_url.startswith("/static/"):
+        # 从URL恢复实际的文件路径
+        relative_path = local_url[len("/static/"):]
+        file_path = os.path.join(Config.STATIC_DIR, relative_path)
+        print(f"相对URL转换为文件路径: {file_path}")
+        
+        if os.path.exists(file_path):
+            print(f"文件存在: {file_path}, 大小: {os.path.getsize(file_path)} 字节")
+        else:
+            print(f"文件不存在: {file_path}")
+    else:
+        print("下载失败，返回了原始URL")
+
+async def test_multiple_downloads():
+    """测试多个图片下载"""
+    test_urls = [
+        "https://pic.baidu.com/feed/b90e7bec54e736d1f9ddbe94c2691f254d4ade13.jpeg",
+        "https://pic1.zhimg.com/v2-b78b719d8782ad5146851b87bbd3a9fb_r.jpg"
+    ]
+    print(f"\n测试多个图片下载: {test_urls}")
+    
+    local_urls = await localize_image_urls(test_urls)
+    
+    print(f"本地化结果: {local_urls}")
+    
+    # 验证所有文件是否下载成功
+    for i, url in enumerate(local_urls):
+        print(f"\n检查文件 {i+1}:")
+        if url.startswith("http"):
+            # 处理完整URL的情况
+            if url.startswith(Config.BASE_URL):
+                url_path = url.split(Config.BASE_URL, 1)[-1]
+                if url_path.startswith("/static/"):
+                    relative_path = url_path[len("/static/"):]
+                    file_path = os.path.join(Config.STATIC_DIR, relative_path)
+                    print(f"完整URL转换为文件路径: {file_path}")
+                    
+                    if os.path.exists(file_path):
+                        print(f"文件 {i+1} 存在: {file_path}, 大小: {os.path.getsize(file_path)} 字节")
+                    else:
+                        print(f"文件 {i+1} 不存在: {file_path}")
+                        # 尝试查找可能的文件
+                        dir_path = os.path.dirname(file_path)
+                        if os.path.exists(dir_path):
+                            print(f"目录存在: {dir_path}")
+                            print(f"目录内容: {os.listdir(dir_path)}")
+                        else:
+                            print(f"目录不存在: {dir_path}")
+                else:
+                    print(f"URL格式异常: {url}")
+            else:
+                print(f"文件 {i+1} 下载失败，返回了原始URL: {url}")
+        elif url.startswith("/static/"):
+            # 从URL恢复实际的文件路径
+            relative_path = url[len("/static/"):]
+            file_path = os.path.join(Config.STATIC_DIR, relative_path)
+            print(f"相对URL转换为文件路径: {file_path}")
+            
+            if os.path.exists(file_path):
+                print(f"文件 {i+1} 存在: {file_path}, 大小: {os.path.getsize(file_path)} 字节")
+            else:
+                print(f"文件 {i+1} 不存在: {file_path}")
+        else:
+            print(f"文件 {i+1} 下载失败，返回了原始URL: {url}")
+
+async def main():
+    print(f"配置信息:")
+    print(f"IMAGE_LOCALIZATION: {Config.IMAGE_LOCALIZATION}")
+    print(f"STATIC_DIR: {Config.STATIC_DIR}")
+    print(f"IMAGE_SAVE_DIR: {Config.IMAGE_SAVE_DIR}")
+    
+    await test_single_download()
+    await test_multiple_downloads()
+
+if __name__ == "__main__":
+    asyncio.run(main())