Upload 102 files

.gitattributes

@@ -33,3 +33,11 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+files/image.png filter=lfs diff=lfs merge=lfs -text
+files/image1.png filter=lfs diff=lfs merge=lfs -text
+files/image2.png filter=lfs diff=lfs merge=lfs -text
+files/image3.png filter=lfs diff=lfs merge=lfs -text
+files/image4.png filter=lfs diff=lfs merge=lfs -text
+files/image5.png filter=lfs diff=lfs merge=lfs -text
+files/image6.png filter=lfs diff=lfs merge=lfs -text
+files/image7.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# 复制所需文件到容器中
+COPY ./requirements.txt /app
+COPY ./VERSION /app
+
+RUN pip install --no-cache-dir -r requirements.txt
+COPY ./app /app/app
+
+# Expose port
+EXPOSE 8000
+
+# Run the application
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000", "--no-access-log"]

LICENSE

@@ -0,0 +1,17 @@
+知识共享署名-非商业性使用 4.0 国际 (CC BY-NC 4.0) 协议
+
+您可以自由地：
+- 共享 — 在任何媒介以任何形式复制、发行本作品
+- 演绎 — 修改、转换或以本作品为基础进行创作
+
+惟须遵守下列条件：
+- 署名 — 您必须给出适当的署名，提供指向本协议的链接，并指明是否（对原作）作了修改。您可以以任何合理方式进行，但不得以任何方式暗示许可方认可您或您的使用。
+- 非商业性使用 — 您不得将本作品用于商业目的，包括但不限于任何形式的商业倒卖、SaaS、API 付费接口、二次销售、打包出售、收费分发或其他直接或间接盈利行为。
+
+如需商业授权，请联系原作者获得书面许可。违者将承担相应法律责任。
+
+Creative Commons Attribution-NonCommercial 4.0 International Public License
+
+By exercising the Licensed Rights (defined below), You accept and agree to be bound by the terms and conditions of this Creative Commons Attribution-NonCommercial 4.0 International Public License ("Public License"). To the extent this Public License may be interpreted as a contract, You are granted the Licensed Rights in consideration of Your acceptance of these terms and conditions, and the Licensor grants You such rights in consideration of benefits the Licensor receives from making the Licensed Material available under these terms and conditions.
+
+Full license text: https://creativecommons.org/licenses/by-nc/4.0/legalcode

README.md

@@ -1,13 +1,282 @@
+[Read this document in Chinese](README_ZH.md)
+
+# Gemini Balance - Gemini API Proxy and Load Balancer
+
+<p align="center">
+  <a href="https://trendshift.io/repositories/13692" target="_blank">
+    <img src="https://trendshift.io/api/badge/repositories/13692" alt="snailyp%2Fgemini-balance | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/>
+  </a>
+</p>
+
+<p align="center">
+  <a href="https://www.python.org/"><img src="https://img.shields.io/badge/Python-3.9%2B-blue.svg" alt="Python"></a>
+  <a href="https://fastapi.tiangolo.com/"><img src="https://img.shields.io/badge/FastAPI-0.100%2B-green.svg" alt="FastAPI"></a>
+  <a href="https://www.uvicorn.org/"><img src="https://img.shields.io/badge/Uvicorn-running-purple.svg" alt="Uvicorn"></a>
+  <a href="https://t.me/+soaHax5lyI0wZDVl"><img src="https://img.shields.io/badge/Telegram-Group-blue.svg?logo=telegram" alt="Telegram Group"></a>
+</p>
+
+> ⚠️ **Important**: This project is licensed under the [CC BY-NC 4.0](LICENSE) license. **Any form of commercial resale service is prohibited**.
+> I have never sold this service on any platform. If you encounter someone selling this service, they are a reseller. Please do not be deceived.
+
+---
+
+## 📖 Project Introduction
+
+**Gemini Balance** is an application built with Python FastAPI, designed to provide proxy and load balancing functions for the Google Gemini API. It allows you to manage multiple Gemini API Keys and implement key rotation, authentication, model filtering, and status monitoring through simple configuration. Additionally, the project integrates image generation and multiple image hosting upload functions, and supports proxying in the OpenAI API format.
+
+<details>
+<summary>📂 View Project Structure</summary>
+
+```plaintext
+app/
+├── config/       # Configuration management
+├── core/         # Core application logic (FastAPI instance creation, middleware, etc.)
+├── database/     # Database models and connections
+├── domain/       # Business domain objects
+├── exception/    # Custom exceptions
+├── handler/      # Request handlers
+├── log/          # Logging configuration
+├── main.py       # Application entry point
+├── middleware/   # FastAPI middleware
+├── router/       # API routes (Gemini, OpenAI, status page, etc.)
+├── scheduler/    # Scheduled tasks (e.g., Key status check)
+├── service/      # Business logic services (chat, Key management, statistics, etc.)
+├── static/       # Static files (CSS, JS)
+├── templates/    # HTML templates (e.g., Key status page)
+└── utils/        # Utility functions
+```
+</details>
+
+---
+
+## ✨ Feature Highlights
+
+*   **Multi-Key Load Balancing**: Supports configuring multiple Gemini API Keys (`API_KEYS`) for automatic sequential polling.
+*   **Visual Configuration**: Configurations modified through the admin backend take effect immediately without restarting.
+    ![Configuration Panel](files/image4.png)
+*   **Dual Protocol API Compatibility**: Supports both Gemini and OpenAI CHAT API formats.
+    *   OpenAI Base URL: `http://localhost:8000(/hf)/v1`
+    *   Gemini Base URL: `http://localhost:8000(/gemini)/v1beta`
+*   **Image-Text Chat & Modification**: Configure models with `IMAGE_MODELS` to support image-text chat and editing. Use the `configured_model-image` model name to invoke.
+    ![Chat with Image Generation](files/image6.png)
+    ![Modify Image](files/image7.png)
+*   **Web Search**: Configure models with `SEARCH_MODELS` to support web search. Use the `configured_model-search` model name to invoke.
+    ![Web Search](files/image8.png)
+*   **Key Status Monitoring**: Provides a `/keys_status` page (authentication required) for real-time monitoring.
+    ![Monitoring Panel](files/image.png)
+*   **Detailed Logging**: Provides detailed error logs for easy troubleshooting.
+    ![Call Details](files/image1.png)
+    ![Log List](files/image2.png)
+    ![Log Details](files/image3.png)
+*   **Flexible Key Addition**: Add keys in batches using the `gemini_key` regex, with automatic deduplication.
+    ![Add Key](files/image5.png)
+*   **Failure Retry & Auto-Disable**: Automatically retries failed API requests (`MAX_RETRIES`) and disables keys after excessive failures (`MAX_FAILURES`).
+*   **Comprehensive API Compatibility**:
+    *   **Embeddings API**: Fully compatible with the OpenAI `embeddings` API format.
+    *   **Image Generation API**: Adapts the `imagen-3.0-generate-002` model to the OpenAI image generation API format.
+*   **Automatic Model List Maintenance**: Automatically fetches and syncs the latest model lists from Gemini and OpenAI.
+*   **Proxy Support**: Supports HTTP/SOCKS5 proxies (`PROXIES`).
+*   **Docker Support**: Provides Docker images for both AMD and ARM architectures.
+    *   Image Address: `ghcr.io/snailyp/gemini-balance:latest`
+
+---
+
+## 🚀 Quick Start
+
+### Option 1: Docker Compose (Recommended)
+
+1.  **Get `docker-compose.yml`**:
+    Download the `docker-compose.yml` file from the project repository.
+2.  **Prepare `.env` file**:
+    Copy `.env.example` to `.env` and configure it. Ensure `DATABASE_TYPE` is set to `mysql` and fill in the `MYSQL_*` details.
+3.  **Start Services**:
+    In the directory containing `docker-compose.yml` and `.env`, run:
+    ```bash
+    docker-compose up -d
+    ```
+
+### Option 2: Docker Command
+
+1.  **Pull Image**:
+    ```bash
+    docker pull ghcr.io/snailyp/gemini-balance:latest
+    ```
+2.  **Prepare `.env` file**:
+    Copy `.env.example` to `.env` and configure it.
+3.  **Run Container**:
+    ```bash
+    docker run -d -p 8000:8000 --name gemini-balance \
+    -v ./data:/app/data \
+    --env-file .env \
+    ghcr.io/snailyp/gemini-balance:latest
+    ```
+    *   `-d`: Detached mode.
+    *   `-p 8000:8000`: Map container port 8000 to host.
+    *   `-v ./data:/app/data`: Mount volume for persistent data.
+    *   `--env-file .env`: Load environment variables.
+
+### Option 3: Local Development
+
+1.  **Clone and Install**:
+    ```bash
+    git clone https://github.com/snailyp/gemini-balance.git
+    cd gemini-balance
+    pip install -r requirements.txt
+    ```
+2.  **Configure Environment**:
+    Copy `.env.example` to `.env` and configure it.
+3.  **Start Application**:
+    ```bash
+    uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload
+    ```
+    Access the application at `http://localhost:8000`.
+
+---
+
+## ⚙️ API Endpoints
+
+### Gemini API Format (`/gemini/v1beta`)
+
+This endpoint is directly forwarded to official Gemini API format endpoint, without advanced features.
+
+*   `GET /models`: List available Gemini models.
+*   `POST /models/{model_name}:generateContent`: Generate content.
+*   `POST /models/{model_name}:streamGenerateContent`: Stream content generation.
+
+### OpenAI API Format
+
+#### Hugging Face (HF) Compatible
+
+If you want to use advanced features, like fake streaming, please use this endpoint.
+
+*   `GET /hf/v1/models`: List models.
+*   `POST /hf/v1/chat/completions`: Chat completion.
+*   `POST /hf/v1/embeddings`: Create text embeddings.
+*   `POST /hf/v1/images/generations`: Generate images.
+
+#### Standard OpenAI
+
+This endpoint is directly forwarded to official OpenAI Compatible API format endpoint, without advanced features.
+
+*   `GET /openai/v1/models`: List models.
+*   `POST /openai/v1/chat/completions`: Chat completion (Recommended).
+*   `POST /openai/v1/embeddings`: Create text embeddings.
+*   `POST /openai/v1/images/generations`: Generate images.
+
 ---
-title: Gemini
-emoji: 📚
-colorFrom: pink
-colorTo: red
-sdk: gradio
-sdk_version: 5.45.0
-app_file: app.py
-pinned: false
-license: mit
+
+<details>
+<summary>📋 View Full Configuration List</summary>
+
+| Configuration Item | Description | Default Value |
+| :--- | :--- | :--- |
+| **Database** | | |
+| `DATABASE_TYPE` | `mysql` or `sqlite` | `mysql` |
+| `SQLITE_DATABASE` | Path for SQLite database file | `default_db` |
+| `MYSQL_HOST` | MySQL host address | `localhost` |
+| `MYSQL_SOCKET` | MySQL socket address | `/var/run/mysqld/mysqld.sock` |
+| `MYSQL_PORT` | MySQL port | `3306` |
+| `MYSQL_USER` | MySQL username | `your_db_user` |
+| `MYSQL_PASSWORD` | MySQL password | `your_db_password` |
+| `MYSQL_DATABASE` | MySQL database name | `defaultdb` |
+| **API** | | |
+| `API_KEYS` | **Required**, list of Gemini API keys | `[]` |
+| `ALLOWED_TOKENS` | **Required**, list of access tokens | `[]` |
+| `AUTH_TOKEN` | Super admin token, defaults to the first of `ALLOWED_TOKENS` | `sk-123456` |
+| `ADMIN_SESSION_EXPIRE` | Admin session expiration time in seconds (5 minutes to 24 hours) | `3600` |
+| `TEST_MODEL` | Model for testing key validity | `gemini-1.5-flash` |
+| `IMAGE_MODELS` | Models supporting image generation | `["gemini-2.0-flash-exp"]` |
+| `SEARCH_MODELS` | Models supporting web search | `["gemini-2.0-flash-exp"]` |
+| `FILTERED_MODELS` | Disabled models | `[]` |
+| `TOOLS_CODE_EXECUTION_ENABLED` | Enable code execution tool | `false` |
+| `SHOW_SEARCH_LINK` | Display search result links in response | `true` |
+| `SHOW_THINKING_PROCESS` | Display model's thinking process | `true` |
+| `THINKING_MODELS` | Models supporting thinking process | `[]` |
+| `THINKING_BUDGET_MAP` | Budget map for thinking function (model:budget) | `{}` |
+| `URL_NORMALIZATION_ENABLED` | Enable smart URL routing | `false` |
+| `URL_CONTEXT_ENABLED` | Enable URL context understanding | `false` |
+| `URL_CONTEXT_MODELS` | Models supporting URL context | `[]` |
+| `BASE_URL` | Gemini API base URL | `https://generativelanguage.googleapis.com/v1beta` |
+| `MAX_FAILURES` | Max failures allowed per key | `3` |
+| `MAX_RETRIES` | Max retries for failed API requests | `3` |
+| `CHECK_INTERVAL_HOURS` | Interval (hours) to re-check disabled keys | `1` |
+| `TIMEZONE` | Application timezone | `Asia/Shanghai` |
+| `TIME_OUT` | Request timeout (seconds) | `300` |
+| `PROXIES` | List of proxy servers | `[]` |
+| **Logging & Security** | | |
+| `LOG_LEVEL` | Log level: `DEBUG`, `INFO`, `WARNING`, `ERROR` | `INFO` |
+| `AUTO_DELETE_ERROR_LOGS_ENABLED` | Auto-delete error logs | `true` |
+| `AUTO_DELETE_ERROR_LOGS_DAYS` | Error log retention period (days) | `7` |
+| `AUTO_DELETE_REQUEST_LOGS_ENABLED`| Auto-delete request logs | `false` |
+| `AUTO_DELETE_REQUEST_LOGS_DAYS` | Request log retention period (days) | `30` |
+| `SAFETY_SETTINGS` | Content safety thresholds (JSON string) | `[{"category": "HARM_CATEGORY_HARASSMENT", "threshold": "OFF"}, ...]` |
+| **TTS** | | |
+| `TTS_MODEL` | TTS model name | `gemini-2.5-flash-preview-tts` |
+| `TTS_VOICE_NAME` | TTS voice name | `Zephyr` |
+| `TTS_SPEED` | TTS speed | `normal` |
+| **Image Generation** | | |
+| `PAID_KEY` | Paid API Key for advanced features | `your-paid-api-key` |
+| `CREATE_IMAGE_MODEL` | Image generation model | `imagen-3.0-generate-002` |
+| `UPLOAD_PROVIDER` | Image upload provider: `smms`, `picgo`, `cloudflare_imgbed` | `smms` |
+| `SMMS_SECRET_TOKEN` | SM.MS API Token | `your-smms-token` |
+| `PICGO_API_KEY` | PicoGo API Key | `your-picogo-apikey` |
+| `PICGO_API_URL` | PicoGo API Server URL | `https://www.picgo.net/api/1/upload` |
+| `CLOUDFLARE_IMGBED_URL` | CloudFlare ImgBed upload URL | `https://xxxxxxx.pages.dev/upload` |
+| `CLOUDFLARE_IMGBED_AUTH_CODE`| CloudFlare ImgBed auth key | `your-cloudflare-imgber-auth-code` |
+| `CLOUDFLARE_IMGBED_UPLOAD_FOLDER`| CloudFlare ImgBed upload folder | `""` |
+| **Stream Optimizer** | | |
+| `STREAM_OPTIMIZER_ENABLED` | Enable stream output optimization | `false` |
+| `STREAM_MIN_DELAY` | Minimum stream output delay | `0.016` |
+| `STREAM_MAX_DELAY` | Maximum stream output delay | `0.024` |
+| `STREAM_SHORT_TEXT_THRESHOLD`| Short text threshold | `10` |
+| `STREAM_LONG_TEXT_THRESHOLD` | Long text threshold | `50` |
+| `STREAM_CHUNK_SIZE` | Stream output chunk size | `5` |
+| **Fake Stream** | | |
+| `FAKE_STREAM_ENABLED` | Enable fake streaming | `false` |
+| `FAKE_STREAM_EMPTY_DATA_INTERVAL_SECONDS` | Heartbeat interval for fake streaming (seconds) | `5` |
+
+</details>
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## 🤝 Contributing
+
+Pull Requests or Issues are welcome.
+
+[![Contributors](https://contrib.rocks/image?repo=snailyp/gemini-balance)](https://github.com/snailyp/gemini-balance/graphs/contributors)
+
+## ⭐ Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=snailyp/gemini-balance&type=Date)](https://star-history.com/#snailyp/gemini-balance&Date)
+
+## 🎉 Special Thanks
+
+*   [PicGo](https://www.picgo.net/)
+*   [SM.MS](https://smms.app/)
+*   [CloudFlare-ImgBed](https://github.com/MarSeventh/CloudFlare-ImgBed)
+
+## 🙏 Our Supporters
+
+A special shout-out to [DigitalOcean](https://m.do.co/c/b249dd7f3b4c) for providing the rock-solid and dependable cloud infrastructure that keeps this project humming!
+
+<a href="https://m.do.co/c/b249dd7f3b4c">
+  <img src="files/dataocean.svg" alt="DigitalOcean Logo" width="200"/>
+</a>
+
+CDN acceleration and security protection for this project are sponsored by [Tencent EdgeOne](https://edgeone.ai/?from=github).
+
+<a href="https://edgeone.ai/?from=github">
+  <img src="https://edgeone.ai/media/34fe3a45-492d-4ea4-ae5d-ea1087ca7b4b.png" alt="EdgeOne Logo" width="200"/>
+</a>
+
+## 💖 Friendly Projects
+
+*   **[OneLine](https://github.com/chengtx809/OneLine)** by [chengtx809](https://github.com/chengtx809) - AI-driven hot event timeline generation tool.
+
+## 🎁 Project Support
+
+If you find this project helpful, consider supporting me via [Afdian](https://afdian.com/a/snaily).
+
+## License
+
+This project is licensed under the [CC BY-NC 4.0](LICENSE) (Attribution-NonCommercial) license.

README_ZH.md

@@ -0,0 +1,283 @@
+# Gemini Balance - Gemini API 代理和负载均衡器
+
+<p align="center">
+  <a href="https://trendshift.io/repositories/13692" target="_blank">
+    <img src="https://trendshift.io/api/badge/repositories/13692" alt="snailyp%2Fgemini-balance | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/>
+  </a>
+</p>
+
+<p align="center">
+  <a href="https://www.python.org/"><img src="https://img.shields.io/badge/Python-3.9%2B-blue.svg" alt="Python"></a>
+  <a href="https://fastapi.tiangolo.com/"><img src="https://img.shields.io/badge/FastAPI-0.100%2B-green.svg" alt="FastAPI"></a>
+  <a href="https://www.uvicorn.org/"><img src="https://img.shields.io/badge/Uvicorn-running-purple.svg" alt="Uvicorn"></a>
+  <a href="https://t.me/+soaHax5lyI0wZDVl"><img src="https://img.shields.io/badge/Telegram-Group-blue.svg?logo=telegram" alt="Telegram Group"></a>
+</p>
+
+> ⚠️ **重要声明**: 本项目采用 [CC BY-NC 4.0](LICENSE) 协议，**禁止任何形式的商业倒卖服务**。
+> 本人从未在任何平台售卖服务，如遇售卖，均为倒卖行为，请勿上当受骗。
+
+---
+
+## 📖 项目简介
+
+**Gemini Balance** 是一个基于 Python FastAPI 构建的应用程序，旨在提供 Google Gemini API 的代理和负载均衡功能。它允许您管理多个 Gemini API Key，并通过简单的配置实现 Key 的轮询、认证、模型过滤和状态监控。此外，项目还集成了图像生成和多种图床上传功能，并支持 OpenAI API 格式的代理。
+
+<details>
+<summary>📂 查看项目结构</summary>
+
+```plaintext
+app/
+├── config/       # 配置管理
+├── core/         # 核心应用逻辑 (FastAPI 实例创建, 中间件等)
+├── database/     # 数据库模型和连接
+├── domain/       # 业务领域对象
+├── exception/    # 自定义异常
+├── handler/      # 请求处理器
+├── log/          # 日志配置
+├── main.py       # 应用入口
+├── middleware/   # FastAPI 中间件
+├── router/       # API 路由 (Gemini, OpenAI, 状态页等)
+├── scheduler/    # 定时任务 (如 Key 状态检查)
+├── service/      # 业务逻辑服务 (聊天, Key 管理, 统计等)
+├── static/       # 静态文件 (CSS, JS)
+├── templates/    # HTML 模板 (如 Key 状态页)
+└── utils/        # 工具函数
+```
+</details>
+
+---
+
+## ✨ 功能亮点
+
+*   **多 Key 负载均衡**: 支持配置多个 Gemini API Key (`API_KEYS`)，自动按顺序轮询使用，提高可用性和并发能力。
+*   **可视化配置即时生效**: 通过管理后台修改配置后，无需重启服务即可生效。
+    ![配置面板](files/image4.png)
+*   **双协议 API 兼容**: 同时支持 Gemini 和 OpenAI 格式的 CHAT API 请求转发。
+    *   OpenAI Base URL: `http://localhost:8000(/hf)/v1`
+    *   Gemini Base URL: `http://localhost:8000(/gemini)/v1beta`
+*   **图文对话与修图**: 通过 `IMAGE_MODELS` 配置支持图文对话和修图功能的模型，调用时使用 `配置模型-image` 模型名。
+    ![对话生图](files/image6.png)
+    ![修改图片](files/image7.png)
+*   **联网搜索**: 通过 `SEARCH_MODELS` 配置支持联网搜索的模型，调用时使用 `配置模型-search` 模型名。
+    ![联网搜索](files/image8.png)
+*   **Key 状态监控**: 提供 `/keys_status` 页面（需要认证），实时查看各 Key 的状态和使用情况。
+    ![监控面板](files/image.png)
+*   **详细日志记录**: 提供详细的错误日志，方便排查问题。
+    ![调用详情](files/image1.png)
+    ![日志列表](files/image2.png)
+    ![日志详情](files/image3.png)
+*   **灵活的密钥添加**: 支持通过正则表达式 `gemini_key` 批量添加密钥，并自动去重。
+    ![添加密钥](files/image5.png)
+*   **失败重试与自动禁用**: 自动处理 API 请求失败，进行重试 (`MAX_RETRIES`)，并在 Key 失效次数过多时自动禁用 (`MAX_FAILURES`)，定时检查恢复 (`CHECK_INTERVAL_HOURS`)。
+*   **全面的 API 兼容**:
+    *   **Embeddings 接口**: 完美适配 OpenAI 格式的 `embeddings` 接口。
+    *   **画图接口**: 将 `imagen-3.0-generate-002` 模型接口改造为 OpenAI 画图接口格式。
+*   **模型列表自动维护**: 自动获取并同步 Gemini 和 OpenAI 的最新模型列表，兼容 New API。
+*   **代理支持**: 支持配置 HTTP/SOCKS5 代理 (`PROXIES`)，方便在特殊网络环境下使用。
+*   **Docker 支持**: 提供 AMD 和 ARM 架构的 Docker 镜像，方便快速部署。
+    *   镜像地址: `ghcr.io/snailyp/gemini-balance:latest`
+
+---
+
+## 🚀 快速开始
+
+### 方式一：使用 Docker Compose (推荐)
+
+这是最推荐的部署方式，可以一键启动应用和数据库。
+
+1.  **下载 `docker-compose.yml`**:
+    从项目仓库获取 `docker-compose.yml` 文件。
+2.  **准备 `.env` 文件**:
+    从 `.env.example` 复制一份并重命名为 `.env`，然后根据需求修改配置。特别注意，`DATABASE_TYPE` 应设置为 `mysql`，并填写 `MYSQL_*` 相关配置。
+3.  **启动服务**:
+    在 `docker-compose.yml` 和 `.env` 文件所在的目录下，运行以下命令：
+    ```bash
+    docker-compose up -d
+    ```
+    该命令会以后台模式启动 `gemini-balance` 应用和 `mysql` 数据库。
+
+### 方式二：使用 Docker 命令
+
+1.  **拉取镜像**:
+    ```bash
+    docker pull ghcr.io/snailyp/gemini-balance:latest
+    ```
+2.  **准备 `.env` 文件**:
+    从 `.env.example` 复制一份并重命名为 `.env`，然后根据需求修改配置。
+3.  **运行容器**:
+    ```bash
+    docker run -d -p 8000:8000 --name gemini-balance \
+    -v ./data:/app/data \
+    --env-file .env \
+    ghcr.io/snailyp/gemini-balance:latest
+    ```
+    *   `-d`: 后台运行。
+    *   `-p 8000:8000`: 将容器的 8000 端口映射到主机。
+    *   `-v ./data:/app/data`: 挂载数据卷以持久化 SQLite 数据和日志。
+    *   `--env-file .env`: 加载环境变量配置文件。
+
+### 方式三：本地运行 (适用于开发)
+
+1.  **克隆仓库并安装依赖**:
+    ```bash
+    git clone https://github.com/snailyp/gemini-balance.git
+    cd gemini-balance
+    pip install -r requirements.txt
+    ```
+2.  **配置环境变量**:
+    从 `.env.example` 复制一份并重命名为 `.env`，然后根据需求修改配置。
+3.  **启动应用**:
+    ```bash
+    uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload
+    ```
+    应用启动后，访问 `http://localhost:8000`。
+
+---
+
+## ⚙️ API 端点
+
+### Gemini API 格式 (`/gemini/v1beta`)
+
+此端点将请求直接转发到官方 Gemini API 格式的端点，不包含高级功能。
+
+*   `GET /models`: 列出可用的 Gemini 模型。
+*   `POST /models/{model_name}:generateContent`: 生成内容。
+*   `POST /models/{model_name}:streamGenerateContent`: 流式生成内容。
+
+### OpenAI API 格式
+
+#### 兼容 huggingface (HF) 格式
+
+如果您需要使用高级功能（例如假流式输出），请使用此端点。
+
+*   `GET /hf/v1/models`: 列出模型。
+*   `POST /hf/v1/chat/completions`: 聊天补全。
+*   `POST /hf/v1/embeddings`: 创建文本嵌入。
+*   `POST /hf/v1/images/generations`: 生成图像。
+
+#### 标准 OpenAI 格式
+
+此端点直接转发至官方的 OpenAI 兼容 API 格式端点，不包含高级功能。
+
+*   `GET /openai/v1/models`: 列出模型。
+*   `POST /openai/v1/chat/completions`: 聊天补全 (推荐，速度更快，防截断)。
+*   `POST /openai/v1/embeddings`: 创建文本嵌入。
+*   `POST /openai/v1/images/generations`: 生成图像。
+
+---
+
+<details>
+<summary>📋 查看完整配置项列表</summary>
+
+| 配置项 | 说明 | 默认值 |
+| :--- | :--- | :--- |
+| **数据库配置** | | |
+| `DATABASE_TYPE` | 数据库类型: `mysql` 或 `sqlite` | `mysql` |
+| `SQLITE_DATABASE` | 当使用 `sqlite` 时必填，SQLite 数据库文件路径 | `default_db` |
+| `MYSQL_HOST` | 当使用 `mysql` 时必填，MySQL 数据库主机地址 | `localhost` |
+| `MYSQL_SOCKET` | 可选，MySQL 数据库 socket 地址 | `/var/run/mysqld/mysqld.sock` |
+| `MYSQL_PORT` | 当使用 `mysql` 时必填，MySQL 数据库端口 | `3306` |
+| `MYSQL_USER` | 当使用 `mysql` 时必填，MySQL 数据库用户名 | `your_db_user` |
+| `MYSQL_PASSWORD` | 当使用 `mysql` 时必填，MySQL 数据库密码 | `your_db_password` |
+| `MYSQL_DATABASE` | 当使用 `mysql` 时必填，MySQL 数据库名称 | `defaultdb` |
+| **API 相关配置** | | |
+| `API_KEYS` | **必填**, Gemini API 密钥列表，用于负载均衡 | `[]` |
+| `ALLOWED_TOKENS` | **必填**, 允许访问的 Token 列表 | `[]` |
+| `AUTH_TOKEN` | 超级管理员 Token，不填则使用 `ALLOWED_TOKENS` 的第一个 | `sk-123456` |
+| `TEST_MODEL` | 用于测试密钥可用性的模型 | `gemini-1.5-flash` |
+| `IMAGE_MODELS` | 支持绘图功能的模型列表 | `["gemini-2.0-flash-exp"]` |
+| `SEARCH_MODELS` | 支持搜索功能的模型列表 | `["gemini-2.0-flash-exp"]` |
+| `FILTERED_MODELS` | 被禁用的模型列表 | `[]` |
+| `TOOLS_CODE_EXECUTION_ENABLED` | 是否启用代码执行工具 | `false` |
+| `SHOW_SEARCH_LINK` | 是否在响应中显示搜索结果链接 | `true` |
+| `SHOW_THINKING_PROCESS` | 是否显示模型思考过程 | `true` |
+| `THINKING_MODELS` | 支持思考功能的模型列表 | `[]` |
+| `THINKING_BUDGET_MAP` | 思考功能预算映射 (模型名:预算值) | `{}` |
+| `URL_NORMALIZATION_ENABLED` | 是否启用智能路由映射功能 | `false` |
+| `URL_CONTEXT_ENABLED` | 是否启用URL上下文理解功能 | `false` |
+| `URL_CONTEXT_MODELS` | 支持URL上下文理解功能的模型列表 | `[]` |
+| `BASE_URL` | Gemini API 基础 URL | `https://generativelanguage.googleapis.com/v1beta` |
+| `MAX_FAILURES` | 单个 Key 允许的最大失败次数 | `3` |
+| `MAX_RETRIES` | API 请求失败时的最大重试次数 | `3` |
+| `CHECK_INTERVAL_HOURS` | 禁用 Key 恢复检查间隔 (小时) | `1` |
+| `TIMEZONE` | 应用程序使用的时区 | `Asia/Shanghai` |
+| `TIME_OUT` | 请求���时时间 (秒) | `300` |
+| `PROXIES` | 代理服务器列表 (例如 `http://user:pass@host:port`) | `[]` |
+| **日志与安全** | | |
+| `LOG_LEVEL` | 日志级别: `DEBUG`, `INFO`, `WARNING`, `ERROR` | `INFO` |
+| `AUTO_DELETE_ERROR_LOGS_ENABLED` | 是否自动删除错误日志 | `true` |
+| `AUTO_DELETE_ERROR_LOGS_DAYS` | 错误日志保留天数 | `7` |
+| `AUTO_DELETE_REQUEST_LOGS_ENABLED`| 是否自动删除请求日志 | `false` |
+| `AUTO_DELETE_REQUEST_LOGS_DAYS` | 请求日志保留天数 | `30` |
+| `SAFETY_SETTINGS` | 内容安全阈值 (JSON 字符串) | `[{"category": "HARM_CATEGORY_HARASSMENT", "threshold": "OFF"}, ...]` |
+| **TTS 相关** | | |
+| `TTS_MODEL` | TTS 模型名称 | `gemini-2.5-flash-preview-tts` |
+| `TTS_VOICE_NAME` | TTS 语音名称 | `Zephyr` |
+| `TTS_SPEED` | TTS 语速 | `normal` |
+| **图像生成相关** | | |
+| `PAID_KEY` | 付费版API Key，用于图片生成等高级功能 | `your-paid-api-key` |
+| `CREATE_IMAGE_MODEL` | 图片生成模型 | `imagen-3.0-generate-002` |
+| `UPLOAD_PROVIDER` | 图片上传提供商: `smms`, `picgo`, `cloudflare_imgbed` | `smms` |
+| `SMMS_SECRET_TOKEN` | SM.MS图床的API Token | `your-smms-token` |
+| `PICGO_API_KEY` | [PicoGo](https://www.picgo.net/)图床的API Key | `your-picogo-apikey` |
+| `PICGO_API_URL` | [PicoGo](https://www.picgo.net/)图床的API服务器地址 | `https://www.picgo.net/api/1/upload` |
+| `CLOUDFLARE_IMGBED_URL` | [CloudFlare](https://github.com/MarSeventh/CloudFlare-ImgBed) 图床上传地址 | `https://xxxxxxx.pages.dev/upload` |
+| `CLOUDFLARE_IMGBED_AUTH_CODE`| CloudFlare图床的鉴权key | `your-cloudflare-imgber-auth-code` |
+| `CLOUDFLARE_IMGBED_UPLOAD_FOLDER`| CloudFlare图床的上传文件夹路径 | `""` |
+| **流式优化器相关** | | |
+| `STREAM_OPTIMIZER_ENABLED` | 是否启用流式输出优化 | `false` |
+| `STREAM_MIN_DELAY` | 流式输出最小延迟 | `0.016` |
+| `STREAM_MAX_DELAY` | 流式输出最大延迟 | `0.024` |
+| `STREAM_SHORT_TEXT_THRESHOLD`| 短文本阈值 | `10` |
+| `STREAM_LONG_TEXT_THRESHOLD` | 长文本阈值 | `50` |
+| `STREAM_CHUNK_SIZE` | 流式输出块大小 | `5` |
+| **伪流式 (Fake Stream) 相关** | | |
+| `FAKE_STREAM_ENABLED` | 是否启用伪流式传输 | `false` |
+| `FAKE_STREAM_EMPTY_DATA_INTERVAL_SECONDS` | 伪流式传输时发送心跳空数据的间隔秒数 | `5` |
+
+</details>
+
+---
+
+## 🤝 贡献
+
+欢迎通过提交 Pull Request 或 Issue 来为项目做出贡献。
+
+[![Contributors](https://contrib.rocks/image?repo=snailyp/gemini-balance)](https://github.com/snailyp/gemini-balance/graphs/contributors)
+
+## ⭐ Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=snailyp/gemini-balance&type=Date)](https://star-history.com/#snailyp/gemini-balance&Date)
+
+## 🎉 特别鸣谢
+
+*   [PicGo](https://www.picgo.net/)
+*   [SM.MS](https://smms.app/)
+*   [CloudFlare-ImgBed](https://github.com/MarSeventh/CloudFlare-ImgBed)
+
+## 💖 友情项目
+
+*   **[OneLine](https://github.com/chengtx809/OneLine)** by [chengtx809](https://github.com/chengtx809) - AI 驱动的热点事件时间轴生成工具。
+
+## 🎁 项目支持
+
+如果你觉得这个项目对你有帮助，可以考虑通过 [爱发电](https://afdian.com/a/snaily) 支持我。
+
+## 许可证
+
+本项目采用 [CC BY-NC 4.0](LICENSE)（署名-非商业性使用）协议。
+
+
+## 赞助商
+
+特别感谢 [DigitalOcean](https://m.do.co/c/b249dd7f3b4c) 为本项目提供稳定可靠的云基础设施支持。
+
+<a href="https://m.do.co/c/b249dd7f3b4c">
+  <img src="files/dataocean.svg" alt="DigitalOcean Logo" width="200"/>
+</a>
+
+本项目的 CDN 加速和安全防护由 [Tencent EdgeOne](https://edgeone.ai/?from=github) 赞助。
+
+<a href="https://edgeone.ai/?from=github">
+  <img src="https://edgeone.ai/media/34fe3a45-492d-4ea4-ae5d-ea1087ca7b4b.png" alt="EdgeOne Logo" width="200"/>
+</a>

VERSION

@@ -0,0 +1 @@
+2.2.5

app/config/config.py

@@ -0,0 +1,513 @@
+"""
+应用程序配置模块
+"""
+
+import datetime
+import json
+from typing import Any, Dict, List, Type, get_args, get_origin
+
+from pydantic import ValidationError, ValidationInfo, field_validator, Field
+from pydantic_settings import BaseSettings
+from sqlalchemy import insert, select, update
+
+from app.core.constants import (
+    API_VERSION,
+    DEFAULT_CREATE_IMAGE_MODEL,
+    DEFAULT_FILTER_MODELS,
+    DEFAULT_MODEL,
+    DEFAULT_SAFETY_SETTINGS,
+    DEFAULT_STREAM_CHUNK_SIZE,
+    DEFAULT_STREAM_LONG_TEXT_THRESHOLD,
+    DEFAULT_STREAM_MAX_DELAY,
+    DEFAULT_STREAM_MIN_DELAY,
+    DEFAULT_STREAM_SHORT_TEXT_THRESHOLD,
+    DEFAULT_TIMEOUT,
+    MAX_RETRIES,
+)
+from app.log.logger import Logger
+
+
+class Settings(BaseSettings):
+    # 数据库配置
+    DATABASE_TYPE: str = "mysql"  # sqlite 或 mysql
+    SQLITE_DATABASE: str = "default_db"
+    MYSQL_HOST: str = ""
+    MYSQL_PORT: int = 3306
+    MYSQL_USER: str = ""
+    MYSQL_PASSWORD: str = ""
+    MYSQL_DATABASE: str = ""
+    MYSQL_SOCKET: str = ""
+
+    # 验证 MySQL 配置
+    @field_validator(
+        "MYSQL_HOST", "MYSQL_PORT", "MYSQL_USER", "MYSQL_PASSWORD", "MYSQL_DATABASE"
+    )
+    def validate_mysql_config(cls, v: Any, info: ValidationInfo) -> Any:
+        if info.data.get("DATABASE_TYPE") == "mysql":
+            if v is None or v == "":
+                raise ValueError(
+                    "MySQL configuration is required when DATABASE_TYPE is 'mysql'"
+                )
+        return v
+
+    # API相关配置
+    API_KEYS: List[str]=[]
+    ALLOWED_TOKENS: List[str]=[]
+    BASE_URL: str = f"https://generativelanguage.googleapis.com/{API_VERSION}"
+    AUTH_TOKEN: str = ""
+    MAX_FAILURES: int = 3
+    TEST_MODEL: str = DEFAULT_MODEL
+    TIME_OUT: int = DEFAULT_TIMEOUT
+    MAX_RETRIES: int = MAX_RETRIES
+    PROXIES: List[str] = []
+    PROXIES_USE_CONSISTENCY_HASH_BY_API_KEY: bool = True  # 是否使用一致性哈希来选择代理
+    VERTEX_API_KEYS: List[str] = []
+    VERTEX_EXPRESS_BASE_URL: str = "https://aiplatform.googleapis.com/v1beta1/publishers/google"
+
+    # 智能路由配置
+    URL_NORMALIZATION_ENABLED: bool = False  # 是否启用智能路由映射功能
+
+    # 自定义 Headers
+    CUSTOM_HEADERS: Dict[str, str] = {}
+
+    # 模型相关配置
+    SEARCH_MODELS: List[str] = ["gemini-2.0-flash-exp"]
+    IMAGE_MODELS: List[str] = ["gemini-2.0-flash-exp"]
+    FILTERED_MODELS: List[str] = DEFAULT_FILTER_MODELS
+    TOOLS_CODE_EXECUTION_ENABLED: bool = False
+    # 是否启用网址上下文
+    URL_CONTEXT_ENABLED: bool = False
+    URL_CONTEXT_MODELS: List[str] = ["gemini-2.5-pro","gemini-2.5-flash","gemini-2.5-flash-lite","gemini-2.0-flash","gemini-2.0-flash-live-001"]
+    SHOW_SEARCH_LINK: bool = True
+    SHOW_THINKING_PROCESS: bool = True
+    THINKING_MODELS: List[str] = []
+    THINKING_BUDGET_MAP: Dict[str, float] = {}
+
+    # TTS相关配置
+    TTS_MODEL: str = "gemini-2.5-flash-preview-tts"
+    TTS_VOICE_NAME: str = "Zephyr"
+    TTS_SPEED: str = "normal"
+
+    # 图像生成相关配置
+    PAID_KEY: str = ""
+    CREATE_IMAGE_MODEL: str = DEFAULT_CREATE_IMAGE_MODEL
+    UPLOAD_PROVIDER: str = "smms"
+    SMMS_SECRET_TOKEN: str = ""
+    PICGO_API_KEY: str = ""
+    PICGO_API_URL: str = "https://www.picgo.net/api/1/upload"
+    CLOUDFLARE_IMGBED_URL: str = ""
+    CLOUDFLARE_IMGBED_AUTH_CODE: str = ""
+    CLOUDFLARE_IMGBED_UPLOAD_FOLDER: str = ""
+
+    # 流式输出优化器配置
+    STREAM_OPTIMIZER_ENABLED: bool = False
+    STREAM_MIN_DELAY: float = DEFAULT_STREAM_MIN_DELAY
+    STREAM_MAX_DELAY: float = DEFAULT_STREAM_MAX_DELAY
+    STREAM_SHORT_TEXT_THRESHOLD: int = DEFAULT_STREAM_SHORT_TEXT_THRESHOLD
+    STREAM_LONG_TEXT_THRESHOLD: int = DEFAULT_STREAM_LONG_TEXT_THRESHOLD
+    STREAM_CHUNK_SIZE: int = DEFAULT_STREAM_CHUNK_SIZE
+
+    # 假流式配置 (Fake Streaming Configuration)
+    FAKE_STREAM_ENABLED: bool = False  # 是否启用假流式输出
+    FAKE_STREAM_EMPTY_DATA_INTERVAL_SECONDS: int = 5  # 假流式发送空数据的间隔时间（秒）
+
+    # 调度器配置
+    CHECK_INTERVAL_HOURS: int = 1  # 默认检查间隔为1小时
+    TIMEZONE: str = "Asia/Shanghai"  # 默认时区
+
+    # github
+    GITHUB_REPO_OWNER: str = "snailyp"
+    GITHUB_REPO_NAME: str = "gemini-balance"
+
+    # 日志配置
+    LOG_LEVEL: str = "INFO"
+    AUTO_DELETE_ERROR_LOGS_ENABLED: bool = True
+    AUTO_DELETE_ERROR_LOGS_DAYS: int = 7
+    AUTO_DELETE_REQUEST_LOGS_ENABLED: bool = False
+    AUTO_DELETE_REQUEST_LOGS_DAYS: int = 30
+    SAFETY_SETTINGS: List[Dict[str, str]] = DEFAULT_SAFETY_SETTINGS
+
+    # Files API
+    FILES_CLEANUP_ENABLED: bool = True
+    FILES_CLEANUP_INTERVAL_HOURS: int = 1
+    FILES_USER_ISOLATION_ENABLED: bool = True
+
+    # Admin Session Configuration
+    ADMIN_SESSION_EXPIRE: int = Field(
+        default=3600,
+        ge=300,
+        le=86400,
+        description="Admin session expiration time in seconds (5 minutes to 24 hours)"
+    )
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        # 设置默认AUTH_TOKEN（如果未提供）
+        if not self.AUTH_TOKEN and self.ALLOWED_TOKENS:
+            self.AUTH_TOKEN = self.ALLOWED_TOKENS[0]
+
+
+# 创建全局配置实例
+settings = Settings()
+
+
+def _parse_db_value(key: str, db_value: str, target_type: Type) -> Any:
+    """尝试将数据库字符串值解析为目标 Python 类型"""
+    from app.log.logger import get_config_logger
+
+    logger = get_config_logger()
+    try:
+        origin_type = get_origin(target_type)
+        args = get_args(target_type)
+
+        # 处理 List 类型
+        if origin_type is list:
+            # 处理 List[str]
+            if args and args[0] == str:
+                try:
+                    parsed = json.loads(db_value)
+                    if isinstance(parsed, list):
+                        return [str(item) for item in parsed]
+                except json.JSONDecodeError:
+                    return [item.strip() for item in db_value.split(",") if item.strip()]
+                logger.warning(
+                    f"Could not parse '{db_value}' as List[str] for key '{key}', falling back to comma split or empty list."
+                )
+                return [item.strip() for item in db_value.split(",") if item.strip()]
+            # 处理 List[Dict[str, str]]
+            elif args and get_origin(args[0]) is dict:
+                try:
+                    parsed = json.loads(db_value)
+                    if isinstance(parsed, list):
+                        valid = all(
+                            isinstance(item, dict)
+                            and all(isinstance(k, str) for k in item.keys())
+                            and all(isinstance(v, str) for v in item.values())
+                            for item in parsed
+                        )
+                        if valid:
+                            return parsed
+                        else:
+                            logger.warning(
+                                f"Invalid structure in List[Dict[str, str]] for key '{key}'. Value: {db_value}"
+                            )
+                            return []
+                    else:
+                        logger.warning(
+                            f"Parsed DB value for key '{key}' is not a list type. Value: {db_value}"
+                        )
+                        return []
+                except json.JSONDecodeError:
+                    logger.error(
+                        f"Could not parse '{db_value}' as JSON for List[Dict[str, str]] for key '{key}'. Returning empty list."
+                    )
+                    return []
+                except Exception as e:
+                    logger.error(
+                        f"Error parsing List[Dict[str, str]] for key '{key}': {e}. Value: {db_value}. Returning empty list."
+                    )
+                    return []
+        # 处理 Dict 类型
+        elif origin_type is dict:
+            # 处理 Dict[str, str]
+            if args and args == (str, str):
+                parsed_dict = {}
+                try:
+                    parsed = json.loads(db_value)
+                    if isinstance(parsed, dict):
+                        parsed_dict = {str(k): str(v) for k, v in parsed.items()}
+                    else:
+                        logger.warning(
+                            f"Parsed DB value for key '{key}' is not a dictionary type. Value: {db_value}"
+                        )
+                except json.JSONDecodeError:
+                     logger.error(f"Could not parse '{db_value}' as Dict[str, str] for key '{key}'. Returning empty dict.")
+                return parsed_dict
+            # 处理 Dict[str, float]
+            elif args and args == (str, float):
+                parsed_dict = {}
+                try:
+                    parsed = json.loads(db_value)
+                    if isinstance(parsed, dict):
+                        parsed_dict = {str(k): float(v) for k, v in parsed.items()}
+                    else:
+                        logger.warning(
+                            f"Parsed DB value for key '{key}' is not a dictionary type. Value: {db_value}"
+                        )
+                except (json.JSONDecodeError, ValueError, TypeError) as e1:
+                    if isinstance(e1, json.JSONDecodeError) and "'" in db_value:
+                        logger.warning(
+                            f"Failed initial JSON parse for key '{key}'. Attempting to replace single quotes. Error: {e1}"
+                        )
+                        try:
+                            corrected_db_value = db_value.replace("'", '"')
+                            parsed = json.loads(corrected_db_value)
+                            if isinstance(parsed, dict):
+                                parsed_dict = {str(k): float(v) for k, v in parsed.items()}
+                            else:
+                                logger.warning(
+                                    f"Parsed DB value (after quote replacement) for key '{key}' is not a dictionary type. Value: {corrected_db_value}"
+                                )
+                        except (json.JSONDecodeError, ValueError, TypeError) as e2:
+                            logger.error(
+                                f"Could not parse '{db_value}' as Dict[str, float] for key '{key}' even after replacing quotes: {e2}. Returning empty dict."
+                            )
+                    else:
+                        logger.error(
+                            f"Could not parse '{db_value}' as Dict[str, float] for key '{key}': {e1}. Returning empty dict."
+                        )
+                return parsed_dict
+        # 处理 bool
+        elif target_type == bool:
+            return db_value.lower() in ("true", "1", "yes", "on")
+        # 处理 int
+        elif target_type == int:
+            return int(db_value)
+        # 处理 float
+        elif target_type == float:
+            return float(db_value)
+        # 默认为 str 或其他 pydantic 能直接处理的类型
+        else:
+            return db_value
+    except (ValueError, TypeError, json.JSONDecodeError) as e:
+        logger.warning(
+            f"Failed to parse db_value '{db_value}' for key '{key}' as type {target_type}: {e}. Using original string value."
+        )
+        return db_value  # 解析失败则返回原始字符串
+
+
+async def sync_initial_settings():
+    """
+    应用启动时同步配置：
+    1. 从数据库加载设置。
+    2. 将数据库设置合并到内存 settings (数据库优先)。
+    3. 将最终的内存 settings 同步回数据库。
+    """
+    from app.log.logger import get_config_logger
+
+    logger = get_config_logger()
+    # 延迟导入以避免循环依赖和确保数据库连接已初始化
+    from app.database.connection import database
+    from app.database.models import Settings as SettingsModel
+
+    global settings
+    logger.info("Starting initial settings synchronization...")
+
+    if not database.is_connected:
+        try:
+            await database.connect()
+            logger.info("Database connection established for initial sync.")
+        except Exception as e:
+            logger.error(
+                f"Failed to connect to database for initial settings sync: {e}. Skipping sync."
+            )
+            return
+
+    try:
+        # 1. 从数据库加载设置
+        db_settings_raw: List[Dict[str, Any]] = []
+        try:
+            query = select(SettingsModel.key, SettingsModel.value)
+            results = await database.fetch_all(query)
+            db_settings_raw = [
+                {"key": row["key"], "value": row["value"]} for row in results
+            ]
+            logger.info(f"Fetched {len(db_settings_raw)} settings from database.")
+        except Exception as e:
+            logger.error(
+                f"Failed to fetch settings from database: {e}. Proceeding with environment/dotenv settings."
+            )
+            # 即使数据库读取失败，也要继续执行，确保基于 env/dotenv 的配置能同步到数据库
+
+        db_settings_map: Dict[str, str] = {
+            s["key"]: s["value"] for s in db_settings_raw
+        }
+
+        # 2. 将数据库设置合并到内存 settings (数据库优先)
+        updated_in_memory = False
+
+        for key, db_value in db_settings_map.items():
+            if key == "DATABASE_TYPE":
+                logger.debug(
+                    f"Skipping update of '{key}' in memory from database. "
+                    "This setting is controlled by environment/dotenv."
+                )
+                continue
+            if hasattr(settings, key):
+                target_type = Settings.__annotations__.get(key)
+                if target_type:
+                    try:
+                        parsed_db_value = _parse_db_value(key, db_value, target_type)
+                        memory_value = getattr(settings, key)
+
+                        # 比较解析后的值和内存中的值
+                        # 注意：对于列表等复杂类型，直接比较可能不够健壮，但这里简化处理
+                        if parsed_db_value != memory_value:
+                            # 检查类型是否匹配，以防解析函数返回了不兼容的类型
+                            type_match = False
+                            origin_type = get_origin(target_type)
+                            if origin_type:  # It's a generic type
+                                if isinstance(parsed_db_value, origin_type):
+                                    type_match = True
+                            # It's a non-generic type, or a specific generic we want to handle
+                            elif isinstance(parsed_db_value, target_type):
+                                type_match = True
+
+                            if type_match:
+                                setattr(settings, key, parsed_db_value)
+                                logger.debug(
+                                    f"Updated setting '{key}' in memory from database value ({target_type})."
+                                )
+                                updated_in_memory = True
+                            else:
+                                logger.warning(
+                                    f"Parsed DB value type mismatch for key '{key}'. Expected {target_type}, got {type(parsed_db_value)}. Skipping update."
+                                )
+
+                    except Exception as e:
+                        logger.error(
+                            f"Error processing database setting for key '{key}': {e}"
+                        )
+            else:
+                logger.warning(
+                    f"Database setting '{key}' not found in Settings model definition. Ignoring."
+                )
+
+        # 如果内存中有更新，重新验证 Pydantic 模型（可选但推荐）
+        if updated_in_memory:
+            try:
+                # 重新加载以确保类型转换和验证
+                settings = Settings(**settings.model_dump())
+                logger.info(
+                    "Settings object re-validated after merging database values."
+                )
+            except ValidationError as e:
+                logger.error(
+                    f"Validation error after merging database settings: {e}. Settings might be inconsistent."
+                )
+
+        # 3. 将最终的内存 settings 同步回数据库
+        final_memory_settings = settings.model_dump()
+        settings_to_update: List[Dict[str, Any]] = []
+        settings_to_insert: List[Dict[str, Any]] = []
+        now = datetime.datetime.now(datetime.timezone.utc)
+
+        existing_db_keys = set(db_settings_map.keys())
+
+        for key, value in final_memory_settings.items():
+            if key == "DATABASE_TYPE":
+                logger.debug(
+                    f"Skipping synchronization of '{key}' to database. "
+                    "This setting is controlled by environment/dotenv."
+                )
+                continue
+
+            # 序列化值为字符串或 JSON 字符串
+            if isinstance(value, (list, dict)):
+                db_value = json.dumps(
+                    value, ensure_ascii=False
+                )
+            elif isinstance(value, bool):
+                db_value = str(value).lower()
+            elif value is None:
+                db_value = ""
+            else:
+                db_value = str(value)
+
+            data = {
+                "key": key,
+                "value": db_value,
+                "description": f"{key} configuration setting",
+                "updated_at": now,
+            }
+
+            if key in existing_db_keys:
+                # 仅当值与数据库中的不同时才更新
+                if db_settings_map[key] != db_value:
+                    settings_to_update.append(data)
+            else:
+                # 如果键不在数据库中，则插入
+                data["created_at"] = now
+                settings_to_insert.append(data)
+
+        # 在事务中执行批量插入和更新
+        if settings_to_insert or settings_to_update:
+            try:
+                async with database.transaction():
+                    if settings_to_insert:
+                        # 获取现有描述以避免覆盖
+                        query_existing = select(
+                            SettingsModel.key, SettingsModel.description
+                        ).where(
+                            SettingsModel.key.in_(
+                                [s["key"] for s in settings_to_insert]
+                            )
+                        )
+                        existing_desc = {
+                            row["key"]: row["description"]
+                            for row in await database.fetch_all(query_existing)
+                        }
+                        for item in settings_to_insert:
+                            item["description"] = existing_desc.get(
+                                item["key"], item["description"]
+                            )
+
+                        query_insert = insert(SettingsModel).values(settings_to_insert)
+                        await database.execute(query=query_insert)
+                        logger.info(
+                            f"Synced (inserted) {len(settings_to_insert)} settings to database."
+                        )
+
+                    if settings_to_update:
+                        # 获取现有描述以避免覆盖
+                        query_existing = select(
+                            SettingsModel.key, SettingsModel.description
+                        ).where(
+                            SettingsModel.key.in_(
+                                [s["key"] for s in settings_to_update]
+                            )
+                        )
+                        existing_desc = {
+                            row["key"]: row["description"]
+                            for row in await database.fetch_all(query_existing)
+                        }
+
+                        for setting_data in settings_to_update:
+                            setting_data["description"] = existing_desc.get(
+                                setting_data["key"], setting_data["description"]
+                            )
+                            query_update = (
+                                update(SettingsModel)
+                                .where(SettingsModel.key == setting_data["key"])
+                                .values(
+                                    value=setting_data["value"],
+                                    description=setting_data["description"],
+                                    updated_at=setting_data["updated_at"],
+                                )
+                            )
+                            await database.execute(query=query_update)
+                        logger.info(
+                            f"Synced (updated) {len(settings_to_update)} settings to database."
+                        )
+            except Exception as e:
+                logger.error(
+                    f"Failed to sync settings to database during startup: {str(e)}"
+                )
+        else:
+            logger.info(
+                "No setting changes detected between memory and database during initial sync."
+            )
+
+        # 刷新日志等级
+        Logger.update_log_levels(final_memory_settings.get("LOG_LEVEL"))
+
+    except Exception as e:
+        logger.error(f"An unexpected error occurred during initial settings sync: {e}")
+    finally:
+        if database.is_connected:
+            try:
+                pass
+            except Exception as e:
+                logger.error(f"Error disconnecting database after initial sync: {e}")
+
+    logger.info("Initial settings synchronization finished.")

app/core/application.py

@@ -0,0 +1,156 @@
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+
+from app.config.config import settings, sync_initial_settings
+from app.database.connection import connect_to_db, disconnect_from_db
+from app.database.initialization import initialize_database
+from app.exception.exceptions import setup_exception_handlers
+from app.log.logger import get_application_logger, setup_access_logging
+from app.middleware.middleware import setup_middlewares
+from app.router.routes import setup_routers
+from app.scheduler.scheduled_tasks import start_scheduler, stop_scheduler
+from app.service.key.key_manager import get_key_manager_instance
+from app.service.update.update_service import check_for_updates
+from app.utils.helpers import get_current_version
+
+logger = get_application_logger()
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+STATIC_DIR = PROJECT_ROOT / "app" / "static"
+TEMPLATES_DIR = PROJECT_ROOT / "app" / "templates"
+
+# 初始化模板引擎，并添加全局变量
+templates = Jinja2Templates(directory="app/templates")
+
+
+# 定义一个函数来更新模板全局变量
+def update_template_globals(app: FastAPI, update_info: dict):
+    # Jinja2Templates 实例没有直接更新全局变量的方法
+    # 我们需要在请求上下文中传递这些变量，或者修改 Jinja 环境
+    # 更简单的方法是将其存储在 app.state 中，并在渲染时传递
+    app.state.update_info = update_info
+    logger.info(f"Update info stored in app.state: {update_info}")
+
+
+# --- Helper functions for lifespan ---
+async def _setup_database_and_config(app_settings):
+    """Initializes database, syncs settings, and initializes KeyManager."""
+    initialize_database()
+    logger.info("Database initialized successfully")
+    await connect_to_db()
+    await sync_initial_settings()
+    await get_key_manager_instance(app_settings.API_KEYS, app_settings.VERTEX_API_KEYS)
+    logger.info("Database, config sync, and KeyManager initialized successfully")
+
+
+async def _shutdown_database():
+    """Disconnects from the database."""
+    await disconnect_from_db()
+
+
+def _start_scheduler():
+    """Starts the background scheduler."""
+    try:
+        start_scheduler()
+        logger.info("Scheduler started successfully.")
+    except Exception as e:
+        logger.error(f"Failed to start scheduler: {e}")
+
+
+def _stop_scheduler():
+    """Stops the background scheduler."""
+    stop_scheduler()
+
+
+async def _perform_update_check(app: FastAPI):
+    """Checks for updates and stores the info in app.state."""
+    update_available, latest_version, error_message = await check_for_updates()
+    current_version = get_current_version()
+    update_info = {
+        "update_available": update_available,
+        "latest_version": latest_version,
+        "error_message": error_message,
+        "current_version": current_version,
+    }
+    if not hasattr(app, "state"):
+        from starlette.datastructures import State
+
+        app.state = State()
+    app.state.update_info = update_info
+    logger.info(f"Update check completed. Info: {update_info}")
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """
+    Manages the application startup and shutdown events.
+
+    Args:
+        app: FastAPI应用实例
+    """
+    logger.info("Application starting up...")
+    try:
+        await _setup_database_and_config(settings)
+        await _perform_update_check(app)
+        _start_scheduler()
+
+    except Exception as e:
+        logger.critical(
+            f"Critical error during application startup: {str(e)}", exc_info=True
+        )
+
+    yield
+
+    logger.info("Application shutting down...")
+    _stop_scheduler()
+    await _shutdown_database()
+
+
+def create_app() -> FastAPI:
+    """
+    创建并配置FastAPI应用程序实例
+
+    Returns:
+        FastAPI: 配置好的FastAPI应用程序实例
+    """
+
+    # 创建FastAPI应用
+    current_version = get_current_version()
+    app = FastAPI(
+        title="Gemini Balance API",
+        description="Gemini API代理服务，支持负载均衡和密钥管理",
+        version=current_version,
+        lifespan=lifespan,
+    )
+
+    if not hasattr(app, "state"):
+        from starlette.datastructures import State
+
+        app.state = State()
+    app.state.update_info = {
+        "update_available": False,
+        "latest_version": None,
+        "error_message": "Initializing...",
+        "current_version": current_version,
+    }
+
+    # 配置静态文件
+    app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
+
+    # 配置中间件
+    setup_middlewares(app)
+
+    # 配置异常处理器
+    setup_exception_handlers(app)
+
+    # 配置路由
+    setup_routers(app)
+
+    # 配置访问日志API密钥隐藏
+    setup_access_logging()
+
+    return app

app/core/constants.py

@@ -0,0 +1,112 @@
+"""
+常量定义模块
+"""
+
+# API相关常量
+API_VERSION = "v1beta"
+DEFAULT_TIMEOUT = 300  # 秒
+MAX_RETRIES = 3  # 最大重试次数
+
+# 模型相关常量
+SUPPORTED_ROLES = ["user", "model", "system"]
+DEFAULT_MODEL = "gemini-1.5-flash"
+DEFAULT_TEMPERATURE = 0.7
+DEFAULT_MAX_TOKENS = 8192
+DEFAULT_TOP_P = 0.9
+DEFAULT_TOP_K = 40
+DEFAULT_FILTER_MODELS = [
+    "gemini-1.0-pro-vision-latest",
+    "gemini-pro-vision",
+    "chat-bison-001",
+    "text-bison-001",
+    "embedding-gecko-001",
+]
+DEFAULT_CREATE_IMAGE_MODEL = "imagen-3.0-generate-002"
+
+# 图像生成相关常量
+VALID_IMAGE_RATIOS = ["1:1", "3:4", "4:3", "9:16", "16:9"]
+
+# 上传提供商
+UPLOAD_PROVIDERS = ["smms", "picgo", "cloudflare_imgbed"]
+DEFAULT_UPLOAD_PROVIDER = "smms"
+
+# 流式输出相关常量
+DEFAULT_STREAM_MIN_DELAY = 0.016
+DEFAULT_STREAM_MAX_DELAY = 0.024
+DEFAULT_STREAM_SHORT_TEXT_THRESHOLD = 10
+DEFAULT_STREAM_LONG_TEXT_THRESHOLD = 50
+DEFAULT_STREAM_CHUNK_SIZE = 5
+
+# 正则表达式模式
+IMAGE_URL_PATTERN = r"!\[(.*?)\]\((.*?)\)"
+DATA_URL_PATTERN = r"data:([^;]+);base64,(.+)"
+
+# Audio/Video Settings
+SUPPORTED_AUDIO_FORMATS = ["wav", "mp3", "flac", "ogg"]
+SUPPORTED_VIDEO_FORMATS = ["mp4", "mov", "avi", "webm"]
+MAX_AUDIO_SIZE_BYTES = 50 * 1024 * 1024  # Example: 50MB limit for Base64 payload
+MAX_VIDEO_SIZE_BYTES = 200 * 1024 * 1024  # Example: 200MB limit
+
+# Optional: Define MIME type mappings if needed, or handle directly in converter
+AUDIO_FORMAT_TO_MIMETYPE = {
+    "wav": "audio/wav",
+    "mp3": "audio/mpeg",
+    "flac": "audio/flac",
+    "ogg": "audio/ogg",
+}
+
+VIDEO_FORMAT_TO_MIMETYPE = {
+    "mp4": "video/mp4",
+    "mov": "video/quicktime",
+    "avi": "video/x-msvideo",
+    "webm": "video/webm",
+}
+
+GEMINI_2_FLASH_EXP_SAFETY_SETTINGS = [
+    {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "OFF"},
+    {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "OFF"},
+    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "OFF"},
+    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "OFF"},
+    {"category": "HARM_CATEGORY_CIVIC_INTEGRITY", "threshold": "OFF"},
+]
+
+DEFAULT_SAFETY_SETTINGS = [
+    {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "OFF"},
+    {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "OFF"},
+    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "OFF"},
+    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "OFF"},
+    {"category": "HARM_CATEGORY_CIVIC_INTEGRITY", "threshold": "BLOCK_NONE"},
+]
+
+TTS_VOICE_NAMES = [
+    "Zephyr",
+    "Puck",
+    "Charon",
+    "Kore",
+    "Fenrir",
+    "Leda",
+    "Orus",
+    "Aoede",
+    "Callirrhoe",
+    "Autonoe",
+    "Enceladus",
+    "Iapetus",
+    "Umbriel",
+    "Algieba",
+    "Despina",
+    "Erinome",
+    "Algenib",
+    "Rasalgethi",
+    "Laomedeia",
+    "Achernar",
+    "Alnilam",
+    "Schedar",
+    "Gacrux",
+    "Pulcherrima",
+    "Achird",
+    "Zubenelgenubi",
+    "Vindemiatrix",
+    "Sadachbia",
+    "Sadaltager",
+    "Sulafat",
+]

app/core/security.py

@@ -0,0 +1,90 @@
+from typing import Optional
+
+from fastapi import Header, HTTPException
+
+from app.config.config import settings
+from app.log.logger import get_security_logger
+
+logger = get_security_logger()
+
+
+def verify_auth_token(token: str) -> bool:
+    return token == settings.AUTH_TOKEN
+
+
+class SecurityService:
+
+    async def verify_key(self, key: str):
+        if key not in settings.ALLOWED_TOKENS and key != settings.AUTH_TOKEN:
+            logger.error("Invalid key")
+            raise HTTPException(status_code=401, detail="Invalid key")
+        return key
+
+    async def verify_authorization(
+        self, authorization: Optional[str] = Header(None)
+    ) -> str:
+        if not authorization:
+            logger.error("Missing Authorization header")
+            raise HTTPException(status_code=401, detail="Missing Authorization header")
+
+        if not authorization.startswith("Bearer "):
+            logger.error("Invalid Authorization header format")
+            raise HTTPException(
+                status_code=401, detail="Invalid Authorization header format"
+            )
+
+        token = authorization.replace("Bearer ", "")
+        if token not in settings.ALLOWED_TOKENS and token != settings.AUTH_TOKEN:
+            logger.error("Invalid token")
+            raise HTTPException(status_code=401, detail="Invalid token")
+
+        return token
+
+    async def verify_goog_api_key(
+        self, x_goog_api_key: Optional[str] = Header(None)
+    ) -> str:
+        """验证Google API Key"""
+        if not x_goog_api_key:
+            logger.error("Missing x-goog-api-key header")
+            raise HTTPException(status_code=401, detail="Missing x-goog-api-key header")
+
+        if (
+            x_goog_api_key not in settings.ALLOWED_TOKENS
+            and x_goog_api_key != settings.AUTH_TOKEN
+        ):
+            logger.error("Invalid x-goog-api-key")
+            raise HTTPException(status_code=401, detail="Invalid x-goog-api-key")
+
+        return x_goog_api_key
+
+    async def verify_auth_token(
+        self, authorization: Optional[str] = Header(None)
+    ) -> str:
+        if not authorization:
+            logger.error("Missing auth_token header")
+            raise HTTPException(status_code=401, detail="Missing auth_token header")
+        token = authorization.replace("Bearer ", "")
+        if token != settings.AUTH_TOKEN:
+            logger.error("Invalid auth_token")
+            raise HTTPException(status_code=401, detail="Invalid auth_token")
+
+        return token
+
+    async def verify_key_or_goog_api_key(
+        self, key: Optional[str] = None , x_goog_api_key: Optional[str] = Header(None)
+    ) -> str:
+        """验证URL中的key或请求头中的x-goog-api-key"""
+        # 如果URL中的key有效，直接返回
+        if key in settings.ALLOWED_TOKENS or key == settings.AUTH_TOKEN:
+            return key
+        
+        # 否则检查请求头中的x-goog-api-key
+        if not x_goog_api_key:
+            logger.error("Invalid key and missing x-goog-api-key header")
+            raise HTTPException(status_code=401, detail="Invalid key and missing x-goog-api-key header")
+        
+        if x_goog_api_key not in settings.ALLOWED_TOKENS and x_goog_api_key != settings.AUTH_TOKEN:
+            logger.error("Invalid key and invalid x-goog-api-key")
+            raise HTTPException(status_code=401, detail="Invalid key and invalid x-goog-api-key")
+        
+        return x_goog_api_key

app/database/__init__.py

@@ -0,0 +1,3 @@
+"""
+数据库模块
+"""

app/database/connection.py

@@ -0,0 +1,71 @@
+"""
+数据库连接池模块
+"""
+from pathlib import Path
+from urllib.parse import quote_plus
+from databases import Database
+from sqlalchemy import create_engine, MetaData
+from sqlalchemy.ext.declarative import declarative_base
+
+from app.config.config import settings
+from app.log.logger import get_database_logger
+
+logger = get_database_logger()
+
+# 数据库URL
+if settings.DATABASE_TYPE == "sqlite":
+    # 确保 data 目录存在
+    data_dir = Path("data")
+    data_dir.mkdir(exist_ok=True)
+    db_path = data_dir / settings.SQLITE_DATABASE
+    DATABASE_URL = f"sqlite:///{db_path}"
+elif settings.DATABASE_TYPE == "mysql":
+    if settings.MYSQL_SOCKET:
+        DATABASE_URL = f"mysql+pymysql://{settings.MYSQL_USER}:{quote_plus(settings.MYSQL_PASSWORD)}@/{settings.MYSQL_DATABASE}?unix_socket={settings.MYSQL_SOCKET}"
+    else:
+        DATABASE_URL = f"mysql+pymysql://{settings.MYSQL_USER}:{quote_plus(settings.MYSQL_PASSWORD)}@{settings.MYSQL_HOST}:{settings.MYSQL_PORT}/{settings.MYSQL_DATABASE}"
+else:
+    raise ValueError("Unsupported database type. Please set DATABASE_TYPE to 'sqlite' or 'mysql'.")
+
+# 创建数据库引擎
+# pool_pre_ping=True: 在从连接池获取连接前执行简单的 "ping" 测试，确保连接有效
+engine = create_engine(DATABASE_URL, pool_pre_ping=True)
+
+# 创建元数据对象
+metadata = MetaData()
+
+# 创建基类
+Base = declarative_base(metadata=metadata)
+
+# 创建数据库连接池，并配置连接池参数，在sqlite中不使用连接池
+# min_size/max_size: 连接池的最小/最大连接数
+# pool_recycle=3600: 连接在池中允许存在的最大秒数（生命周期）。
+#                    设置为 3600 秒（1小时），确保在 MySQL 默认的 wait_timeout (通常8小时) 或其他网络超时之前回收连接。
+#                    如果遇到连接失效问题，可以尝试调低此值，使其小于实际的 wait_timeout 或网络超时时间。
+# databases 库会自动处理连接失效后的重连尝试。
+if settings.DATABASE_TYPE == "sqlite":
+    database = Database(DATABASE_URL)
+else:
+    database = Database(DATABASE_URL, min_size=5, max_size=20, pool_recycle=1800)
+
+async def connect_to_db():
+    """
+    连接到数据库
+    """
+    try:
+        await database.connect()
+        logger.info(f"Connected to {settings.DATABASE_TYPE}")
+    except Exception as e:
+        logger.error(f"Failed to connect to database: {str(e)}")
+        raise
+
+
+async def disconnect_from_db():
+    """
+    断开数据库连接
+    """
+    try:
+        await database.disconnect()
+        logger.info(f"Disconnected from {settings.DATABASE_TYPE}")
+    except Exception as e:
+        logger.error(f"Failed to disconnect from database: {str(e)}")

app/database/initialization.py

@@ -0,0 +1,77 @@
+"""
+数据库初始化模块
+"""
+from dotenv import dotenv_values
+
+from sqlalchemy import inspect
+from sqlalchemy.orm import Session
+
+from app.database.connection import engine, Base
+from app.database.models import Settings
+from app.log.logger import get_database_logger
+
+logger = get_database_logger()
+
+
+def create_tables():
+    """
+    创建数据库表
+    """
+    try:
+        # 创建所有表
+        Base.metadata.create_all(engine)
+        logger.info("Database tables created successfully")
+    except Exception as e:
+        logger.error(f"Failed to create database tables: {str(e)}")
+        raise
+
+
+def import_env_to_settings():
+    """
+    将.env文件中的配置项导入到t_settings表中
+    """
+    try:
+        # 获取.env文件中的所有配置项
+        env_values = dotenv_values(".env")
+        
+        # 获取检查器
+        inspector = inspect(engine)
+        
+         # 检查t_settings表是否存在
+        if "t_settings" in inspector.get_table_names():
+            # 使用Session进行数据库操作
+            with Session(engine) as session:
+                # 获取所有现有的配置项
+                current_settings = {setting.key: setting for setting in session.query(Settings).all()}
+                
+                # 遍历所有配置项
+                for key, value in env_values.items():
+                    # 检查配置项是否已存在
+                    if key not in current_settings:
+                        # 插入配置项
+                        new_setting = Settings(key=key, value=value)
+                        session.add(new_setting)
+                        logger.info(f"Inserted setting: {key}")
+                
+                # 提交事务
+                session.commit()
+                
+        logger.info("Environment variables imported to settings table successfully")
+    except Exception as e:
+        logger.error(f"Failed to import environment variables to settings table: {str(e)}")
+        raise
+
+
+def initialize_database():
+    """
+    初始化数据库
+    """
+    try:
+        # 创建表
+        create_tables()
+        
+        # 导入环境变量
+        import_env_to_settings()
+    except Exception as e:
+        logger.error(f"Failed to initialize database: {str(e)}")
+        raise

app/database/models.py

@@ -0,0 +1,129 @@
+"""
+数据库模型模块
+"""
+import datetime
+from sqlalchemy import Column, Integer, String, Text, DateTime, JSON, Boolean, BigInteger, Enum
+import enum
+
+from app.database.connection import Base
+
+
+class Settings(Base):
+    """
+    设置表，对应.env中的配置项
+    """
+    __tablename__ = "t_settings"
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    key = Column(String(100), nullable=False, unique=True, comment="配置项键名")
+    value = Column(Text, nullable=True, comment="配置项值")
+    description = Column(String(255), nullable=True, comment="配置项描述")
+    created_at = Column(DateTime, default=datetime.datetime.now, comment="创建时间")
+    updated_at = Column(DateTime, default=datetime.datetime.now, onupdate=datetime.datetime.now, comment="更新时间")
+    
+    def __repr__(self):
+        return f"<Settings(key='{self.key}', value='{self.value}')>"
+
+
+class ErrorLog(Base):
+    """
+    错误日志表
+    """
+    __tablename__ = "t_error_logs"
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    gemini_key = Column(String(100), nullable=True, comment="Gemini API密钥")
+    model_name = Column(String(100), nullable=True, comment="模型名称")
+    error_type = Column(String(50), nullable=True, comment="错误类型")
+    error_log = Column(Text, nullable=True, comment="错误日志")
+    error_code = Column(Integer, nullable=True, comment="错误代码")
+    request_msg = Column(JSON, nullable=True, comment="请求消息")
+    request_time = Column(DateTime, default=datetime.datetime.now, comment="请求时间")
+    
+    def __repr__(self):
+        return f"<ErrorLog(id='{self.id}', gemini_key='{self.gemini_key}')>"
+
+
+class RequestLog(Base):
+    """
+    API 请求日志表
+    """
+
+    __tablename__ = "t_request_log"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    request_time = Column(DateTime, default=datetime.datetime.now, comment="请求时间")
+    model_name = Column(String(100), nullable=True, comment="模型名称")
+    api_key = Column(String(100), nullable=True, comment="使用的API密钥")
+    is_success = Column(Boolean, nullable=False, comment="请求是否成功")
+    status_code = Column(Integer, nullable=True, comment="API响应状态码")
+    latency_ms = Column(Integer, nullable=True, comment="请求耗时(毫秒)")
+
+    def __repr__(self):
+        return f"<RequestLog(id='{self.id}', key='{self.api_key[:4]}...', success='{self.is_success}')>"
+
+
+class FileState(enum.Enum):
+    """文件状态枚举"""
+    PROCESSING = "PROCESSING"
+    ACTIVE = "ACTIVE"
+    FAILED = "FAILED"
+
+
+class FileRecord(Base):
+    """
+    文件记录表，用于存储上传到 Gemini 的文件信息
+    """
+    __tablename__ = "t_file_records"
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    
+    # 文件基本信息
+    name = Column(String(255), unique=True, nullable=False, comment="文件名称，格式: files/{file_id}")
+    display_name = Column(String(255), nullable=True, comment="用户上传时的原始文件名")
+    mime_type = Column(String(100), nullable=False, comment="MIME 类型")
+    size_bytes = Column(BigInteger, nullable=False, comment="文件大小（字节）")
+    sha256_hash = Column(String(255), nullable=True, comment="文件的 SHA256 哈希值")
+    
+    # 状态信息
+    state = Column(Enum(FileState), nullable=False, default=FileState.PROCESSING, comment="文件状态")
+    
+    # 时间戳
+    create_time = Column(DateTime, nullable=False, comment="创建时间")
+    update_time = Column(DateTime, nullable=False, comment="更新时间")
+    expiration_time = Column(DateTime, nullable=False, comment="过期时间")
+    
+    # API 相关
+    uri = Column(String(500), nullable=False, comment="文件访问 URI")
+    api_key = Column(String(100), nullable=False, comment="上传时使用的 API Key")
+    upload_url = Column(Text, nullable=True, comment="临时上传 URL（用于分块上传）")
+    
+    # 额外信息
+    user_token = Column(String(100), nullable=True, comment="上传用户的 token")
+    upload_completed = Column(DateTime, nullable=True, comment="上传完成时间")
+    
+    def __repr__(self):
+        return f"<FileRecord(name='{self.name}', state='{self.state.value if self.state else 'None'}', api_key='{self.api_key[:8]}...')>"
+    
+    def to_dict(self):
+        """转换为字典格式，用于 API 响应"""
+        return {
+            "name": self.name,
+            "displayName": self.display_name,
+            "mimeType": self.mime_type,
+            "sizeBytes": str(self.size_bytes),
+            "createTime": self.create_time.isoformat() + "Z",
+            "updateTime": self.update_time.isoformat() + "Z",
+            "expirationTime": self.expiration_time.isoformat() + "Z",
+            "sha256Hash": self.sha256_hash,
+            "uri": self.uri,
+            "state": self.state.value if self.state else "PROCESSING"
+        }
+    
+    def is_expired(self):
+        """检查文件是否已过期"""
+        # 确保比较时都是 timezone-aware
+        expiration_time = self.expiration_time
+        if expiration_time.tzinfo is None:
+            expiration_time = expiration_time.replace(tzinfo=datetime.timezone.utc)
+        return datetime.datetime.now(datetime.timezone.utc) > expiration_time

app/database/services.py

@@ -0,0 +1,775 @@
+"""
+数据库服务模块
+"""
+
+import json
+from datetime import datetime, timedelta, timezone
+from typing import Any, Dict, List, Optional, Union
+
+from sqlalchemy import asc, delete, desc, func, insert, select, update
+
+from app.database.connection import database
+from app.database.models import ErrorLog, FileRecord, FileState, RequestLog, Settings
+from app.log.logger import get_database_logger
+from app.utils.helpers import redact_key_for_logging
+
+logger = get_database_logger()
+
+
+async def get_all_settings() -> List[Dict[str, Any]]:
+    """
+    获取所有设置
+
+    Returns:
+        List[Dict[str, Any]]: 设置列表
+    """
+    try:
+        query = select(Settings)
+        result = await database.fetch_all(query)
+        return [dict(row) for row in result]
+    except Exception as e:
+        logger.error(f"Failed to get all settings: {str(e)}")
+        raise
+
+
+async def get_setting(key: str) -> Optional[Dict[str, Any]]:
+    """
+    获取指定键的设置
+
+    Args:
+        key: 设置键名
+
+    Returns:
+        Optional[Dict[str, Any]]: 设置信息，如果不存在则返回None
+    """
+    try:
+        query = select(Settings).where(Settings.key == key)
+        result = await database.fetch_one(query)
+        return dict(result) if result else None
+    except Exception as e:
+        logger.error(f"Failed to get setting {key}: {str(e)}")
+        raise
+
+
+async def update_setting(
+    key: str, value: str, description: Optional[str] = None
+) -> bool:
+    """
+    更新设置
+
+    Args:
+        key: 设置键名
+        value: 设置值
+        description: 设置描述
+
+    Returns:
+        bool: 是否更新成功
+    """
+    try:
+        # 检查设置是否存在
+        setting = await get_setting(key)
+
+        if setting:
+            # 更新设置
+            query = (
+                update(Settings)
+                .where(Settings.key == key)
+                .values(
+                    value=value,
+                    description=description if description else setting["description"],
+                    updated_at=datetime.now(),
+                )
+            )
+            await database.execute(query)
+            logger.info(f"Updated setting: {key}")
+            return True
+        else:
+            # 插入设置
+            query = insert(Settings).values(
+                key=key,
+                value=value,
+                description=description,
+                created_at=datetime.now(),
+                updated_at=datetime.now(),
+            )
+            await database.execute(query)
+            logger.info(f"Inserted setting: {key}")
+            return True
+    except Exception as e:
+        logger.error(f"Failed to update setting {key}: {str(e)}")
+        return False
+
+
+async def add_error_log(
+    gemini_key: Optional[str] = None,
+    model_name: Optional[str] = None,
+    error_type: Optional[str] = None,
+    error_log: Optional[str] = None,
+    error_code: Optional[int] = None,
+    request_msg: Optional[Union[Dict[str, Any], str]] = None,
+    request_datetime: Optional[datetime] = None,
+) -> bool:
+    """
+    添加错误日志
+
+    Args:
+        gemini_key: Gemini API密钥
+        error_log: 错误日志
+        error_code: 错误代码 (例如 HTTP 状态码)
+        request_msg: 请求消息
+
+    Returns:
+        bool: 是否添加成功
+    """
+    try:
+        # 如果request_msg是字典，则转换为JSON字符串
+        if isinstance(request_msg, dict):
+            request_msg_json = request_msg
+        elif isinstance(request_msg, str):
+            try:
+                request_msg_json = json.loads(request_msg)
+            except json.JSONDecodeError:
+                request_msg_json = {"message": request_msg}
+        else:
+            request_msg_json = None
+
+        # 插入错误日志
+        query = insert(ErrorLog).values(
+            gemini_key=gemini_key,
+            error_type=error_type,
+            error_log=error_log,
+            model_name=model_name,
+            error_code=error_code,
+            request_msg=request_msg_json,
+            request_time=(request_datetime if request_datetime else datetime.now()),
+        )
+        await database.execute(query)
+        logger.info(f"Added error log for key: {redact_key_for_logging(gemini_key)}")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to add error log: {str(e)}")
+        return False
+
+
+async def get_error_logs(
+    limit: int = 20,
+    offset: int = 0,
+    key_search: Optional[str] = None,
+    error_search: Optional[str] = None,
+    error_code_search: Optional[str] = None,
+    start_date: Optional[datetime] = None,
+    end_date: Optional[datetime] = None,
+    sort_by: str = "id",
+    sort_order: str = "desc",
+) -> List[Dict[str, Any]]:
+    """
+    获取错误日志，支持搜索、日期过滤和排序
+
+    Args:
+        limit (int): 限制数量
+        offset (int): 偏移量
+        key_search (Optional[str]): Gemini密钥搜索词 (模糊匹配)
+        error_search (Optional[str]): 错误类型或日志内容搜索词 (模糊匹配)
+        error_code_search (Optional[str]): 错误码搜索词 (精确匹配)
+        start_date (Optional[datetime]): 开始日期时间
+        end_date (Optional[datetime]): 结束日期时间
+        sort_by (str): 排序字段 (例如 'id', 'request_time')
+        sort_order (str): 排序顺序 ('asc' or 'desc')
+
+    Returns:
+        List[Dict[str, Any]]: 错误日志列表
+    """
+    try:
+        query = select(
+            ErrorLog.id,
+            ErrorLog.gemini_key,
+            ErrorLog.model_name,
+            ErrorLog.error_type,
+            ErrorLog.error_log,
+            ErrorLog.error_code,
+            ErrorLog.request_time,
+        )
+
+        if key_search:
+            query = query.where(ErrorLog.gemini_key.ilike(f"%{key_search}%"))
+        if error_search:
+            query = query.where(
+                (ErrorLog.error_type.ilike(f"%{error_search}%"))
+                | (ErrorLog.error_log.ilike(f"%{error_search}%"))
+            )
+        if start_date:
+            query = query.where(ErrorLog.request_time >= start_date)
+        if end_date:
+            query = query.where(ErrorLog.request_time < end_date)
+        if error_code_search:
+            try:
+                error_code_int = int(error_code_search)
+                query = query.where(ErrorLog.error_code == error_code_int)
+            except ValueError:
+                logger.warning(
+                    f"Invalid format for error_code_search: '{error_code_search}'. Expected an integer. Skipping error code filter."
+                )
+
+        sort_column = getattr(ErrorLog, sort_by, ErrorLog.id)
+        if sort_order.lower() == "asc":
+            query = query.order_by(asc(sort_column))
+        else:
+            query = query.order_by(desc(sort_column))
+
+        query = query.limit(limit).offset(offset)
+
+        result = await database.fetch_all(query)
+        return [dict(row) for row in result]
+    except Exception as e:
+        logger.exception(f"Failed to get error logs with filters: {str(e)}")
+        raise
+
+
+async def get_error_logs_count(
+    key_search: Optional[str] = None,
+    error_search: Optional[str] = None,
+    error_code_search: Optional[str] = None,
+    start_date: Optional[datetime] = None,
+    end_date: Optional[datetime] = None,
+) -> int:
+    """
+    获取符合条件的错误日志总数
+
+    Args:
+        key_search (Optional[str]): Gemini密钥搜索词 (模糊匹配)
+        error_search (Optional[str]): 错误类型或日志内容搜索词 (模糊匹配)
+        error_code_search (Optional[str]): 错误码搜索词 (精确匹配)
+        start_date (Optional[datetime]): 开始日期时间
+        end_date (Optional[datetime]): 结束日期时间
+
+    Returns:
+        int: 日志总数
+    """
+    try:
+        query = select(func.count()).select_from(ErrorLog)
+
+        if key_search:
+            query = query.where(ErrorLog.gemini_key.ilike(f"%{key_search}%"))
+        if error_search:
+            query = query.where(
+                (ErrorLog.error_type.ilike(f"%{error_search}%"))
+                | (ErrorLog.error_log.ilike(f"%{error_search}%"))
+            )
+        if start_date:
+            query = query.where(ErrorLog.request_time >= start_date)
+        if end_date:
+            query = query.where(ErrorLog.request_time < end_date)
+        if error_code_search:
+            try:
+                error_code_int = int(error_code_search)
+                query = query.where(ErrorLog.error_code == error_code_int)
+            except ValueError:
+                logger.warning(
+                    f"Invalid format for error_code_search in count: '{error_code_search}'. Expected an integer. Skipping error code filter."
+                )
+
+        count_result = await database.fetch_one(query)
+        return count_result[0] if count_result else 0
+    except Exception as e:
+        logger.exception(f"Failed to count error logs with filters: {str(e)}")
+        raise
+
+
+# 新增函数：获取单条错误日志详情
+async def get_error_log_details(log_id: int) -> Optional[Dict[str, Any]]:
+    """
+    根据 ID 获取单个错误日志的详细信息
+
+    Args:
+        log_id (int): 错误日志的 ID
+
+    Returns:
+        Optional[Dict[str, Any]]: 包含日志详细信息的字典，如果未找到则返回 None
+    """
+    try:
+        query = select(ErrorLog).where(ErrorLog.id == log_id)
+        result = await database.fetch_one(query)
+        if result:
+            # 将 request_msg (JSONB) 转换为字符串以便在 API 中返回
+            log_dict = dict(result)
+            if "request_msg" in log_dict and log_dict["request_msg"] is not None:
+                # 确保即使是 None 或非 JSON 数据也能处理
+                try:
+                    log_dict["request_msg"] = json.dumps(
+                        log_dict["request_msg"], ensure_ascii=False, indent=2
+                    )
+                except TypeError:
+                    log_dict["request_msg"] = str(log_dict["request_msg"])
+            return log_dict
+        else:
+            return None
+    except Exception as e:
+        logger.exception(f"Failed to get error log details for ID {log_id}: {str(e)}")
+        raise
+
+
+# 新增函数：通过 gemini_key / error_code / 时间窗口 查找最接近的错误日志
+async def find_error_log_by_info(
+    gemini_key: str,
+    timestamp: datetime,
+    status_code: Optional[int] = None,
+    window_seconds: int = 1,
+) -> Optional[Dict[str, Any]]:
+    """
+    在给定时间窗口内，根据 gemini_key（精确匹配）及可选的 status_code 查找最接近 timestamp 的错误日志。
+
+    假设错误日志的 error_code 存储的是 HTTP 状态码或等价错误码。
+
+    Args:
+        gemini_key: 完整的 Gemini key 字符串。
+        timestamp: 目标时间（UTC 或本地，与存储一致）。
+        status_code: 可选的错误码，若提供则优先匹配该错误码。
+        window_seconds: 允许的时间偏差窗口，单位秒，默认为 1 秒。
+
+    Returns:
+        Optional[Dict[str, Any]]: 最匹配的一条错误日志的完整详情（字段与 get_error_log_details 一致），若未找到则返回 None。
+    """
+    try:
+        start_time = timestamp - timedelta(seconds=window_seconds)
+        end_time = timestamp + timedelta(seconds=window_seconds)
+
+        base_query = select(ErrorLog).where(
+            ErrorLog.gemini_key == gemini_key,
+            ErrorLog.request_time >= start_time,
+            ErrorLog.request_time <= end_time,
+        )
+
+        # 若提供了状态码，先尝试按状态码过滤
+        if status_code is not None:
+            query = base_query.where(ErrorLog.error_code == status_code).order_by(
+                ErrorLog.request_time.desc()
+            )
+            candidates = await database.fetch_all(query)
+            if not candidates:
+                # 回退：不按状态码，仅按时间窗口
+                query2 = base_query.order_by(ErrorLog.request_time.desc())
+                candidates = await database.fetch_all(query2)
+        else:
+            query = base_query.order_by(ErrorLog.request_time.desc())
+            candidates = await database.fetch_all(query)
+
+        if not candidates:
+            return None
+
+        # 在 Python 中选择与 timestamp 最接近的一条
+        def _to_dict(row: Any) -> Dict[str, Any]:
+            d = dict(row)
+            if "request_msg" in d and d["request_msg"] is not None:
+                try:
+                    d["request_msg"] = json.dumps(
+                        d["request_msg"], ensure_ascii=False, indent=2
+                    )
+                except TypeError:
+                    d["request_msg"] = str(d["request_msg"])
+            return d
+
+        best = min(
+            candidates,
+            key=lambda r: abs((r["request_time"] - timestamp).total_seconds()),
+        )
+        return _to_dict(best)
+    except Exception as e:
+        logger.exception(
+            f"Failed to find error log by info (key=***{gemini_key[-4:] if gemini_key else ''}, code={status_code}, ts={timestamp}, window={window_seconds}s): {str(e)}"
+        )
+        raise
+
+
+async def delete_error_logs_by_ids(log_ids: List[int]) -> int:
+    """
+    根据提供的 ID 列表批量删除错误日志 (异步)。
+
+    Args:
+        log_ids: 要删除的错误日志 ID 列表。
+
+    Returns:
+        int: 实际删除的日志数量。
+    """
+    if not log_ids:
+        return 0
+    try:
+        # 使用 databases 执行删除
+        query = delete(ErrorLog).where(ErrorLog.id.in_(log_ids))
+        # execute 返回受影响的行数，但 databases 库的 execute 不直接返回 rowcount
+        # 我们需要先查询是否存在，或者依赖数据库约束/触发器（如果适用）
+        # 或者，我们可以执行删除并假设成功，除非抛出异常
+        # 为了简单起见，我们执行删除并记录日志，不精确返回删除数量
+        # 如果需要精确数量，需要先执行 SELECT COUNT(*)
+        await database.execute(query)
+        # 注意：databases 的 execute 不返回 rowcount，所以我们不能直接返回删除的数量
+        # 返回 log_ids 的长度作为尝试删除的数量，或者返回 0/1 表示操作尝试
+        logger.info(f"Attempted bulk deletion for error logs with IDs: {log_ids}")
+        return len(log_ids)  # 返回尝试删除的数量
+    except Exception as e:
+        # 数据库连接或执行错误
+        logger.error(
+            f"Error during bulk deletion of error logs {log_ids}: {e}", exc_info=True
+        )
+        raise
+
+
+async def delete_error_log_by_id(log_id: int) -> bool:
+    """
+    根据 ID 删除单个错误日志 (异步)。
+
+    Args:
+        log_id: 要删除的错误日志 ID。
+
+    Returns:
+        bool: 如果成功删除返回 True，否则返回 False。
+    """
+    try:
+        # 先检查是否存在 (可选，但更明确)
+        check_query = select(ErrorLog.id).where(ErrorLog.id == log_id)
+        exists = await database.fetch_one(check_query)
+
+        if not exists:
+            logger.warning(
+                f"Attempted to delete non-existent error log with ID: {log_id}"
+            )
+            return False
+
+        # 执行删除
+        delete_query = delete(ErrorLog).where(ErrorLog.id == log_id)
+        await database.execute(delete_query)
+        logger.info(f"Successfully deleted error log with ID: {log_id}")
+        return True
+    except Exception as e:
+        logger.error(f"Error deleting error log with ID {log_id}: {e}", exc_info=True)
+        raise
+
+
+async def delete_all_error_logs() -> int:
+    """
+    删除所有错误日志条目。
+
+    Returns:
+        int: 被删除的错误日志数量。如果使用的数据库驱动不支持返回受影响行数，则返回 -1 表示操作成功。
+    """
+    try:
+        # 直接执行删除操作，避免不必要的查询
+        delete_query = delete(ErrorLog)
+        await database.execute(delete_query)
+
+        logger.info("Successfully deleted all error logs.")
+
+        # 由于 databases 库的 execute 方法不返回受影响的行数，
+        # 返回 -1 表示删除操作成功执行，但具体删除数量未知
+        # 这比先查询再删除的方式更高效
+        return -1
+    except Exception as e:
+        logger.error(f"Failed to delete all error logs: {str(e)}", exc_info=True)
+        raise
+
+
+# 新增函数：添加请求日志
+async def add_request_log(
+    model_name: Optional[str],
+    api_key: Optional[str],
+    is_success: bool,
+    status_code: Optional[int] = None,
+    latency_ms: Optional[int] = None,
+    request_time: Optional[datetime] = None,
+) -> bool:
+    """
+    添加 API 请求日志
+
+    Args:
+        model_name: 模型名称
+        api_key: 使用的 API 密钥
+        is_success: 请求是否成功
+        status_code: API 响应状态码
+        latency_ms: 请求耗时(毫秒)
+        request_time: 请求发生时间 (如果为 None, 则使用当前时间)
+
+    Returns:
+        bool: 是否添加成功
+    """
+    try:
+        log_time = request_time if request_time else datetime.now()
+
+        query = insert(RequestLog).values(
+            request_time=log_time,
+            model_name=model_name,
+            api_key=api_key,
+            is_success=is_success,
+            status_code=status_code,
+            latency_ms=latency_ms,
+        )
+        await database.execute(query)
+        return True
+    except Exception as e:
+        logger.error(f"Failed to add request log: {str(e)}")
+        return False
+
+
+# ==================== 文件记录相关函数 ====================
+
+
+async def create_file_record(
+    name: str,
+    mime_type: str,
+    size_bytes: int,
+    api_key: str,
+    uri: str,
+    create_time: datetime,
+    update_time: datetime,
+    expiration_time: datetime,
+    state: FileState = FileState.PROCESSING,
+    display_name: Optional[str] = None,
+    sha256_hash: Optional[str] = None,
+    upload_url: Optional[str] = None,
+    user_token: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    创建文件记录
+
+    Args:
+        name: 文件名称（格式: files/{file_id}）
+        mime_type: MIME 类型
+        size_bytes: 文件大小（字节）
+        api_key: 上传时使用的 API Key
+        uri: 文件访问 URI
+        create_time: 创建时间
+        update_time: 更新时间
+        expiration_time: 过期时间
+        display_name: 显示名称
+        sha256_hash: SHA256 哈希值
+        upload_url: 临时上传 URL
+        user_token: 上传用户的 token
+
+    Returns:
+        Dict[str, Any]: 创建的文件记录
+    """
+    try:
+        query = insert(FileRecord).values(
+            name=name,
+            display_name=display_name,
+            mime_type=mime_type,
+            size_bytes=size_bytes,
+            sha256_hash=sha256_hash,
+            state=state,
+            create_time=create_time,
+            update_time=update_time,
+            expiration_time=expiration_time,
+            uri=uri,
+            api_key=api_key,
+            upload_url=upload_url,
+            user_token=user_token,
+        )
+        await database.execute(query)
+
+        # 返回创建的记录
+        return await get_file_record_by_name(name)
+    except Exception as e:
+        logger.error(f"Failed to create file record: {str(e)}")
+        raise
+
+
+async def get_file_record_by_name(name: str) -> Optional[Dict[str, Any]]:
+    """
+    根据文件名获取文件记录
+
+    Args:
+        name: 文件名称（格式: files/{file_id}）
+
+    Returns:
+        Optional[Dict[str, Any]]: 文件记录，如果不存在则返回 None
+    """
+    try:
+        query = select(FileRecord).where(FileRecord.name == name)
+        result = await database.fetch_one(query)
+        return dict(result) if result else None
+    except Exception as e:
+        logger.error(f"Failed to get file record by name {name}: {str(e)}")
+        raise
+
+
+async def update_file_record_state(
+    file_name: str,
+    state: FileState,
+    update_time: Optional[datetime] = None,
+    upload_completed: Optional[datetime] = None,
+    sha256_hash: Optional[str] = None,
+) -> bool:
+    """
+    更新文件记录状态
+
+    Args:
+        file_name: 文件名
+        state: 新状态
+        update_time: 更新时间
+        upload_completed: 上传完成时间
+        sha256_hash: SHA256 哈希值
+
+    Returns:
+        bool: 是否更新成功
+    """
+    try:
+        values = {"state": state}
+        if update_time:
+            values["update_time"] = update_time
+        if upload_completed:
+            values["upload_completed"] = upload_completed
+        if sha256_hash:
+            values["sha256_hash"] = sha256_hash
+
+        query = update(FileRecord).where(FileRecord.name == file_name).values(**values)
+        result = await database.execute(query)
+
+        if result:
+            logger.info(f"Updated file record state for {file_name} to {state}")
+            return True
+
+        logger.warning(f"File record not found for update: {file_name}")
+        return False
+    except Exception as e:
+        logger.error(f"Failed to update file record state: {str(e)}")
+        return False
+
+
+async def list_file_records(
+    user_token: Optional[str] = None,
+    api_key: Optional[str] = None,
+    page_size: int = 10,
+    page_token: Optional[str] = None,
+) -> tuple[List[Dict[str, Any]], Optional[str]]:
+    """
+    列出文件记录
+
+    Args:
+        user_token: 用户 token（如果提供，只返回该用户的文件）
+        api_key: API Key（如果提供，只返回使用该 key 的文件）
+        page_size: 每页大小
+        page_token: 分页标记（偏移量）
+
+    Returns:
+        tuple[List[Dict[str, Any]], Optional[str]]: (文件列表, 下一页标记)
+    """
+    try:
+        logger.debug(
+            f"list_file_records called with page_size={page_size}, page_token={page_token}"
+        )
+        query = select(FileRecord).where(
+            FileRecord.expiration_time > datetime.now(timezone.utc)
+        )
+
+        if user_token:
+            query = query.where(FileRecord.user_token == user_token)
+        if api_key:
+            query = query.where(FileRecord.api_key == api_key)
+
+        # 使用偏移量进行分页
+        offset = 0
+        if page_token:
+            try:
+                offset = int(page_token)
+            except ValueError:
+                logger.warning(f"Invalid page token: {page_token}")
+                offset = 0
+
+        # 按ID升序排列，使用 OFFSET 和 LIMIT
+        query = query.order_by(FileRecord.id).offset(offset).limit(page_size + 1)
+
+        results = await database.fetch_all(query)
+
+        logger.debug(f"Query returned {len(results)} records")
+        if results:
+            logger.debug(
+                f"First record ID: {results[0]['id']}, Last record ID: {results[-1]['id']}"
+            )
+
+        # 处理分页
+        has_next = len(results) > page_size
+        if has_next:
+            results = results[:page_size]
+            # 下一页的偏移量是当前偏移量加上本页返回的记录数
+            next_offset = offset + page_size
+            next_page_token = str(next_offset)
+            logger.debug(
+                f"Has next page, offset={offset}, page_size={page_size}, next_page_token={next_page_token}"
+            )
+        else:
+            next_page_token = None
+            logger.debug(f"No next page, returning {len(results)} results")
+
+        return [dict(row) for row in results], next_page_token
+    except Exception as e:
+        logger.error(f"Failed to list file records: {str(e)}")
+        raise
+
+
+async def delete_file_record(name: str) -> bool:
+    """
+    删除文件记录
+
+    Args:
+        name: 文件名称
+
+    Returns:
+        bool: 是否删除成功
+    """
+    try:
+        query = delete(FileRecord).where(FileRecord.name == name)
+        await database.execute(query)
+        return True
+    except Exception as e:
+        logger.error(f"Failed to delete file record: {str(e)}")
+        return False
+
+
+async def delete_expired_file_records() -> List[Dict[str, Any]]:
+    """
+    删除已过期的文件记录
+
+    Returns:
+        List[Dict[str, Any]]: 删除的记录列表
+    """
+    try:
+        # 先获取要删除的记录
+        query = select(FileRecord).where(
+            FileRecord.expiration_time <= datetime.now(timezone.utc)
+        )
+        expired_records = await database.fetch_all(query)
+
+        if not expired_records:
+            return []
+
+        # 执行删除
+        delete_query = delete(FileRecord).where(
+            FileRecord.expiration_time <= datetime.now(timezone.utc)
+        )
+        await database.execute(delete_query)
+
+        logger.info(f"Deleted {len(expired_records)} expired file records")
+        return [dict(record) for record in expired_records]
+    except Exception as e:
+        logger.error(f"Failed to delete expired file records: {str(e)}")
+        raise
+
+
+async def get_file_api_key(name: str) -> Optional[str]:
+    """
+    获取文件对应的 API Key
+
+    Args:
+        name: 文件名称
+
+    Returns:
+        Optional[str]: API Key，如果文件不存在或已过期则返回 None
+    """
+    try:
+        query = select(FileRecord.api_key).where(
+            (FileRecord.name == name)
+            & (FileRecord.expiration_time > datetime.now(timezone.utc))
+        )
+        result = await database.fetch_one(query)
+        return result["api_key"] if result else None
+    except Exception as e:
+        logger.error(f"Failed to get file API key: {str(e)}")
+        raise

app/domain/file_models.py

@@ -0,0 +1,69 @@
+"""
+Files API 相关的领域模型
+"""
+from typing import Optional, Dict, Any, List
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+
+class FileUploadConfig(BaseModel):
+    """文件上传配置"""
+    mime_type: Optional[str] = Field(None, description="MIME 类型")
+    display_name: Optional[str] = Field(None, description="显示名称，最多40个字符")
+
+
+class CreateFileRequest(BaseModel):
+    """创建文件请求（用于初始化上传）"""
+    file: Optional[Dict[str, Any]] = Field(None, description="文件元数据")
+    
+
+class FileMetadata(BaseModel):
+    """文件元数据响应"""
+    name: str = Field(..., description="文件名称，格式: files/{file_id}")
+    displayName: Optional[str] = Field(None, description="显示名称")
+    mimeType: str = Field(..., description="MIME 类型")
+    sizeBytes: str = Field(..., description="文件大小（字节）")
+    createTime: str = Field(..., description="创建时间 (RFC3339)")
+    updateTime: str = Field(..., description="更新时间 (RFC3339)")
+    expirationTime: str = Field(..., description="过期时间 (RFC3339)")
+    sha256Hash: Optional[str] = Field(None, description="SHA256 哈希值")
+    uri: str = Field(..., description="文件访问 URI")
+    state: str = Field(..., description="文件状态")
+    
+    class Config:
+        json_encoders = {
+            datetime: lambda v: v.isoformat() + "Z"
+        }
+
+
+class ListFilesRequest(BaseModel):
+    """列出文件请求参数"""
+    pageSize: Optional[int] = Field(10, ge=1, le=100, description="每页大小")
+    pageToken: Optional[str] = Field(None, description="分页标记")
+
+
+class ListFilesResponse(BaseModel):
+    """列出文件响应"""
+    files: List[FileMetadata] = Field(default_factory=list, description="文件列表")
+    nextPageToken: Optional[str] = Field(None, description="下一页标记")
+
+
+class UploadInitResponse(BaseModel):
+    """上传初始化响应（内部使用）"""
+    file_metadata: FileMetadata
+    upload_url: str
+
+
+class FileKeyMapping(BaseModel):
+    """文件与 API Key 的映射关系（内部使用）"""
+    file_name: str
+    api_key: str
+    user_token: str
+    created_at: datetime
+    expires_at: datetime
+
+
+class DeleteFileResponse(BaseModel):
+    """删除文件响应"""
+    success: bool = Field(..., description="是否删除成功")
+    message: Optional[str] = Field(None, description="消息")

app/domain/gemini_models.py

@@ -0,0 +1,115 @@
+from typing import Any, Dict, List, Literal, Optional, Union
+
+from pydantic import BaseModel, Field
+
+from app.core.constants import DEFAULT_TEMPERATURE, DEFAULT_TOP_K, DEFAULT_TOP_P
+
+
+class SafetySetting(BaseModel):
+    category: Optional[
+        Literal[
+            "HARM_CATEGORY_HATE_SPEECH",
+            "HARM_CATEGORY_DANGEROUS_CONTENT",
+            "HARM_CATEGORY_HARASSMENT",
+            "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+            "HARM_CATEGORY_CIVIC_INTEGRITY",
+        ]
+    ] = None
+    threshold: Optional[
+        Literal[
+            "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
+            "BLOCK_LOW_AND_ABOVE",
+            "BLOCK_MEDIUM_AND_ABOVE",
+            "BLOCK_ONLY_HIGH",
+            "BLOCK_NONE",
+            "OFF",
+        ]
+    ] = None
+
+
+class GenerationConfig(BaseModel):
+    stopSequences: Optional[List[str]] = None
+    responseMimeType: Optional[str] = None
+    responseSchema: Optional[Dict[str, Any]] = None
+    candidateCount: Optional[int] = 1
+    maxOutputTokens: Optional[int] = None
+    temperature: Optional[float] = DEFAULT_TEMPERATURE
+    topP: Optional[float] = DEFAULT_TOP_P
+    topK: Optional[int] = DEFAULT_TOP_K
+    presencePenalty: Optional[float] = None
+    frequencyPenalty: Optional[float] = None
+    responseLogprobs: Optional[bool] = None
+    logprobs: Optional[int] = None
+    thinkingConfig: Optional[Dict[str, Any]] = None
+    # TTS相关字段
+    responseModalities: Optional[List[str]] = None
+    speechConfig: Optional[Dict[str, Any]] = None
+
+
+class SystemInstruction(BaseModel):
+    role: Optional[str] = "system"
+    parts: Union[List[Dict[str, Any]], Dict[str, Any]]
+
+
+class GeminiContent(BaseModel):
+    role: Optional[str] = None
+    parts: List[Dict[str, Any]]
+
+
+class GeminiRequest(BaseModel):
+    contents: List[GeminiContent] = []
+    tools: Optional[Union[List[Dict[str, Any]], Dict[str, Any]]] = []
+    safetySettings: Optional[List[SafetySetting]] = Field(
+        default=None, alias="safety_settings"
+    )
+    generationConfig: Optional[GenerationConfig] = Field(
+        default=None, alias="generation_config"
+    )
+    systemInstruction: Optional[SystemInstruction] = Field(
+        default=None, alias="system_instruction"
+    )
+
+    class Config:
+        populate_by_name = True
+
+
+class ResetSelectedKeysRequest(BaseModel):
+    keys: List[str]
+    key_type: str
+
+
+class VerifySelectedKeysRequest(BaseModel):
+    keys: List[str]
+
+
+class GeminiEmbedContent(BaseModel):
+    """嵌入内容模型"""
+
+    parts: List[Dict[str, str]]
+
+
+class GeminiEmbedRequest(BaseModel):
+    """单一嵌入请求模型"""
+
+    content: GeminiEmbedContent
+    taskType: Optional[
+        Literal[
+            "TASK_TYPE_UNSPECIFIED",
+            "RETRIEVAL_QUERY",
+            "RETRIEVAL_DOCUMENT",
+            "SEMANTIC_SIMILARITY",
+            "CLASSIFICATION",
+            "CLUSTERING",
+            "QUESTION_ANSWERING",
+            "FACT_VERIFICATION",
+            "CODE_RETRIEVAL_QUERY",
+        ]
+    ] = None
+    title: Optional[str] = None
+    outputDimensionality: Optional[int] = None
+
+
+class GeminiBatchEmbedRequest(BaseModel):
+    """批量嵌入请求模型"""
+
+    requests: List[GeminiEmbedRequest]

app/domain/image_models.py

@@ -0,0 +1,20 @@
+from typing import Union
+
+
+class ImageMetadata:
+    def __init__(self, width: int, height: int, filename: str, size: int, url: str, delete_url: Union[str, None] = None):
+        self.width = width
+        self.height = height
+        self.filename = filename
+        self.size = size
+        self.url = url
+        self.delete_url = delete_url
+class UploadResponse:
+    def __init__(self, success: bool, code: str, message: str, data: ImageMetadata):
+        self.success = success
+        self.code = code
+        self.message = message
+        self.data = data
+class ImageUploader:
+    def upload(self, file: bytes, filename: str) -> UploadResponse:
+        raise NotImplementedError

app/domain/openai_models.py

@@ -0,0 +1,43 @@
+from pydantic import BaseModel
+from typing import Any, Dict, List, Optional, Union
+
+from app.core.constants import DEFAULT_MODEL, DEFAULT_TEMPERATURE, DEFAULT_TOP_K, DEFAULT_TOP_P
+
+
+class ChatRequest(BaseModel):
+    messages: List[dict]
+    model: str = DEFAULT_MODEL
+    temperature: Optional[float] = DEFAULT_TEMPERATURE
+    stream: Optional[bool] = False
+    max_tokens: Optional[int] = None
+    top_p: Optional[float] = DEFAULT_TOP_P
+    top_k: Optional[int] = DEFAULT_TOP_K
+    n: Optional[int] = 1
+    stop: Optional[Union[List[str],str]] = None
+    reasoning_effort: Optional[str] = None
+    tools: Optional[Union[List[Dict[str, Any]], Dict[str, Any]]] = []
+    tool_choice: Optional[str] = None
+    response_format: Optional[dict] = None
+
+
+class EmbeddingRequest(BaseModel):
+    input: Union[str, List[str]]
+    model: str = "text-embedding-004"
+    encoding_format: Optional[str] = "float"
+
+
+class ImageGenerationRequest(BaseModel):
+    model: str = "imagen-3.0-generate-002"
+    prompt: str = ""
+    n: int = 1
+    size: Optional[str] = "1024x1024"
+    quality: Optional[str] = None
+    style: Optional[str] = None
+    response_format: Optional[str] = "url"
+
+
+class TTSRequest(BaseModel):
+    model: str = "gemini-2.5-flash-preview-tts"
+    input: str
+    voice: str = "Kore"
+    response_format: Optional[str] = "wav"

app/exception/exceptions.py

@@ -0,0 +1,140 @@
+"""
+异常处理模块，定义应用程序中使用的自定义异常和异常处理器
+"""
+
+from fastapi import FastAPI, Request
+from fastapi.exceptions import RequestValidationError
+from fastapi.responses import JSONResponse
+from starlette.exceptions import HTTPException as StarletteHTTPException
+
+from app.log.logger import get_exceptions_logger
+
+logger = get_exceptions_logger()
+
+
+class APIError(Exception):
+    """API错误基类"""
+
+    def __init__(self, status_code: int, detail: str, error_code: str = None):
+        self.status_code = status_code
+        self.detail = detail
+        self.error_code = error_code or "api_error"
+        super().__init__(self.detail)
+
+
+class AuthenticationError(APIError):
+    """认证错误"""
+
+    def __init__(self, detail: str = "Authentication failed"):
+        super().__init__(
+            status_code=401, detail=detail, error_code="authentication_error"
+        )
+
+
+class AuthorizationError(APIError):
+    """授权错误"""
+
+    def __init__(self, detail: str = "Not authorized to access this resource"):
+        super().__init__(
+            status_code=403, detail=detail, error_code="authorization_error"
+        )
+
+
+class ResourceNotFoundError(APIError):
+    """资源未找到错误"""
+
+    def __init__(self, detail: str = "Resource not found"):
+        super().__init__(
+            status_code=404, detail=detail, error_code="resource_not_found"
+        )
+
+
+class ModelNotSupportedError(APIError):
+    """模型不支持错误"""
+
+    def __init__(self, model: str):
+        super().__init__(
+            status_code=400,
+            detail=f"Model {model} is not supported",
+            error_code="model_not_supported",
+        )
+
+
+class APIKeyError(APIError):
+    """API密钥错误"""
+
+    def __init__(self, detail: str = "Invalid or expired API key"):
+        super().__init__(status_code=401, detail=detail, error_code="api_key_error")
+
+
+class ServiceUnavailableError(APIError):
+    """服务不可用错误"""
+
+    def __init__(self, detail: str = "Service temporarily unavailable"):
+        super().__init__(
+            status_code=503, detail=detail, error_code="service_unavailable"
+        )
+
+
+def setup_exception_handlers(app: FastAPI) -> None:
+    """
+    设置应用程序的异常处理器
+
+    Args:
+        app: FastAPI应用程序实例
+    """
+
+    @app.exception_handler(APIError)
+    async def api_error_handler(request: Request, exc: APIError):
+        """处理API错误"""
+        logger.error(f"API Error: {exc.detail} (Code: {exc.error_code})")
+        return JSONResponse(
+            status_code=exc.status_code,
+            content={"error": {"code": exc.error_code, "message": exc.detail}},
+        )
+
+    @app.exception_handler(StarletteHTTPException)
+    async def http_exception_handler(request: Request, exc: StarletteHTTPException):
+        """处理HTTP异常"""
+        logger.error(f"HTTP Exception: {exc.detail} (Status: {exc.status_code})")
+        return JSONResponse(
+            status_code=exc.status_code,
+            content={"error": {"code": "http_error", "message": exc.detail}},
+        )
+
+    @app.exception_handler(RequestValidationError)
+    async def validation_exception_handler(
+        request: Request, exc: RequestValidationError
+    ):
+        """处理请求验证错误"""
+        error_details = []
+        for error in exc.errors():
+            error_details.append(
+                {"loc": error["loc"], "msg": error["msg"], "type": error["type"]}
+            )
+
+        logger.error(f"Validation Error: {error_details}")
+        return JSONResponse(
+            status_code=422,
+            content={
+                "error": {
+                    "code": "validation_error",
+                    "message": "Request validation failed",
+                    "details": error_details,
+                }
+            },
+        )
+
+    @app.exception_handler(Exception)
+    async def general_exception_handler(request: Request, exc: Exception):
+        """处理通用异常"""
+        logger.exception(f"Unhandled Exception: {str(exc)}")
+        return JSONResponse(
+            status_code=500,
+            content={
+                "error": {
+                    "code": "internal_server_error",
+                    "message": "An unexpected error occurred",
+                }
+            },
+        )

app/handler/error_handler.py

@@ -0,0 +1,32 @@
+from contextlib import asynccontextmanager
+from fastapi import HTTPException
+import logging
+
+@asynccontextmanager
+async def handle_route_errors(logger: logging.Logger, operation_name: str, success_message: str = None, failure_message: str = None):
+    """
+    一个异步上下文管理器，用于统一处理 FastAPI 路由中的常见错误和日志记录。
+
+    Args:
+        logger: 用于记录日志的 Logger 实例。
+        operation_name: 操作的名称，用于日志记录和错误详情。
+        success_message: 操作成功时记录的自定义消息 (可选)。
+        failure_message: 操作失败时记录的自定义消息 (可选)。
+    """
+    default_success_msg = f"{operation_name} request successful"
+    default_failure_msg = f"{operation_name} request failed"
+
+    logger.info("-" * 50 + operation_name + "-" * 50)
+    try:
+        yield
+        logger.info(success_message or default_success_msg)
+    except HTTPException as http_exc:
+        # 如果已经是 HTTPException，直接重新抛出，保留原始状态码和详情
+        logger.error(f"{failure_message or default_failure_msg}: {http_exc.detail} (Status: {http_exc.status_code})")
+        raise http_exc
+    except Exception as e:
+        # 对于其他所有异常，记录错误并抛出标准的 500 错误
+        logger.error(f"{failure_message or default_failure_msg}: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Internal server error during {operation_name}"
+        ) from e

app/handler/message_converter.py

@@ -0,0 +1,363 @@
+import base64
+import json
+import re
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+import requests
+
+from app.core.constants import (
+    AUDIO_FORMAT_TO_MIMETYPE,
+    DATA_URL_PATTERN,
+    IMAGE_URL_PATTERN,
+    MAX_AUDIO_SIZE_BYTES,
+    MAX_VIDEO_SIZE_BYTES,
+    SUPPORTED_AUDIO_FORMATS,
+    SUPPORTED_ROLES,
+    SUPPORTED_VIDEO_FORMATS,
+    VIDEO_FORMAT_TO_MIMETYPE,
+)
+from app.log.logger import get_message_converter_logger
+
+logger = get_message_converter_logger()
+
+
+class MessageConverter(ABC):
+    """消息转换器基类"""
+
+    @abstractmethod
+    def convert(
+        self, messages: List[Dict[str, Any]], model: str
+    ) -> tuple[List[Dict[str, Any]], Optional[Dict[str, Any]]]:
+        pass
+
+
+def _get_mime_type_and_data(base64_string):
+    """
+    从 base64 字符串中提取 MIME 类型和数据。
+
+    参数:
+        base64_string (str): 可能包含 MIME 类型信息的 base64 字符串
+
+    返回:
+        tuple: (mime_type, encoded_data)
+    """
+    # 检查字符串是否以 "data:" 格式开始
+    if base64_string.startswith("data:"):
+        # 提取 MIME 类型和数据
+        pattern = DATA_URL_PATTERN
+        match = re.match(pattern, base64_string)
+        if match:
+            mime_type = (
+                "image/jpeg" if match.group(1) == "image/jpg" else match.group(1)
+            )
+            encoded_data = match.group(2)
+            return mime_type, encoded_data
+
+    # 如果不是预期格式，假定它只是数据部分
+    return None, base64_string
+
+
+def _convert_image(image_url: str) -> Dict[str, Any]:
+    if image_url.startswith("data:image"):
+        mime_type, encoded_data = _get_mime_type_and_data(image_url)
+        return {"inline_data": {"mime_type": mime_type, "data": encoded_data}}
+    else:
+        encoded_data = _convert_image_to_base64(image_url)
+        return {"inline_data": {"mime_type": "image/png", "data": encoded_data}}
+
+
+def _convert_image_to_base64(url: str) -> str:
+    """
+    将图片URL转换为base64编码
+    Args:
+        url: 图片URL
+    Returns:
+        str: base64编码的图片数据
+    """
+    response = requests.get(url)
+    if response.status_code == 200:
+        # 将图片内容转换为base64
+        img_data = base64.b64encode(response.content).decode("utf-8")
+        return img_data
+    else:
+        raise Exception(f"Failed to fetch image: {response.status_code}")
+
+
+def _process_text_with_image(text: str, model: str) -> List[Dict[str, Any]]:
+    """
+    处理可能包含图片URL的文本，提取图片并转换为base64
+
+    Args:
+        text: 可能包含图片URL的文本
+
+    Returns:
+        List[Dict[str, Any]]: 包含文本和图片的部分列表
+    """
+    # 如果模型名中没有包含image，当作普通文本处理
+    if "image" not in model:
+        return [{"text": text}]
+    parts = []
+    img_url_match = re.search(IMAGE_URL_PATTERN, text)
+    if img_url_match:
+        # 提取URL
+        img_url = img_url_match.group(2)
+        # 先判断是否是base64url如果是，直接用，不过不是，再将URL对应的图片转换为base64
+        try:
+            base64_url_match = re.search(DATA_URL_PATTERN, img_url)
+            if base64_url_match:
+                parts.append(
+                    {
+                        "inline_data": {
+                            "mimeType": base64_url_match.group(1),
+                            "data": base64_url_match.group(2),
+                        }
+                    }
+                )
+            else:
+                base64_data = _convert_image_to_base64(img_url)
+                parts.append(
+                    {"inline_data": {"mimeType": "image/png", "data": base64_data}}
+                )
+        except Exception:
+            # 如果转换失败，回退到文本模式
+            parts.append({"text": text})
+    else:
+        # 没有图片URL，作为纯文本处理
+        parts.append({"text": text})
+    return parts
+
+
+class OpenAIMessageConverter(MessageConverter):
+    """OpenAI消息格式转换器"""
+
+    def _validate_media_data(
+        self, format: str, data: str, supported_formats: List[str], max_size: int
+    ) -> tuple[Optional[str], Optional[str]]:
+        """Validates format and size of Base64 media data."""
+        if format.lower() not in supported_formats:
+            logger.error(
+                f"Unsupported media format: {format}. Supported: {supported_formats}"
+            )
+            raise ValueError(f"Unsupported media format: {format}")
+
+        try:
+            decoded_data = base64.b64decode(data, validate=True)
+            if len(decoded_data) > max_size:
+                logger.error(
+                    f"Media data size ({len(decoded_data)} bytes) exceeds limit ({max_size} bytes)."
+                )
+                raise ValueError(
+                    f"Media data size exceeds limit of {max_size // 1024 // 1024}MB"
+                )
+            return data
+        except base64.binascii.Error as e:
+            logger.error(f"Invalid Base64 data provided: {e}")
+            raise ValueError("Invalid Base64 data")
+        except Exception as e:
+            logger.error(f"Error validating media data: {e}")
+            raise
+
+    def convert(
+        self, messages: List[Dict[str, Any]], model: str
+    ) -> tuple[List[Dict[str, Any]], Optional[Dict[str, Any]]]:
+        converted_messages = []
+        system_instruction_parts = []
+
+        for idx, msg in enumerate(messages):
+            role = msg.get("role", "")
+            parts = []
+
+            if "content" in msg and isinstance(msg["content"], list):
+                for content_item in msg["content"]:
+                    if not isinstance(content_item, dict):
+                        logger.warning(
+                            f"Skipping unexpected content item format: {type(content_item)}"
+                        )
+                        continue
+
+                    content_type = content_item.get("type")
+
+                    if content_type == "text" and content_item.get("text"):
+                        parts.append({"text": content_item["text"]})
+                    elif content_type == "image_url" and content_item.get(
+                        "image_url", {}
+                    ).get("url"):
+                        try:
+                            parts.append(
+                                _convert_image(content_item["image_url"]["url"])
+                            )
+                        except Exception as e:
+                            logger.error(
+                                f"Failed to convert image URL {content_item['image_url']['url']}: {e}"
+                            )
+                            parts.append(
+                                {
+                                    "text": f"[Error processing image: {content_item['image_url']['url']}]"
+                                }
+                            )
+                    elif content_type == "input_audio" and content_item.get(
+                        "input_audio"
+                    ):
+                        audio_info = content_item["input_audio"]
+                        audio_data = audio_info.get("data")
+                        audio_format = audio_info.get("format", "").lower()
+
+                        if not audio_data or not audio_format:
+                            logger.warning(
+                                "Skipping audio part due to missing data or format."
+                            )
+                            continue
+
+                        try:
+                            validated_data = self._validate_media_data(
+                                audio_format,
+                                audio_data,
+                                SUPPORTED_AUDIO_FORMATS,
+                                MAX_AUDIO_SIZE_BYTES,
+                            )
+
+                            # Get MIME type
+                            mime_type = AUDIO_FORMAT_TO_MIMETYPE.get(audio_format)
+                            if not mime_type:
+                                # Should not happen if format validation passed, but double-check
+                                logger.error(
+                                    f"Could not find MIME type for supported format: {audio_format}"
+                                )
+                                raise ValueError(
+                                    f"Internal error: MIME type mapping missing for {audio_format}"
+                                )
+
+                            parts.append(
+                                {
+                                    "inline_data": {
+                                        "mimeType": mime_type,
+                                        "data": validated_data,  # Use the validated Base64 data
+                                    }
+                                }
+                            )
+                            logger.debug(
+                                f"Successfully added audio part (format: {audio_format})"
+                            )
+
+                        except ValueError as e:
+                            logger.error(
+                                f"Skipping audio part due to validation error: {e}"
+                            )
+                            parts.append({"text": f"[Error processing audio: {e}]"})
+                        except Exception:
+                            logger.exception("Unexpected error processing audio part.")
+                            parts.append(
+                                {"text": "[Unexpected error processing audio]"}
+                            )
+
+                    elif content_type == "input_video" and content_item.get(
+                        "input_video"
+                    ):
+                        video_info = content_item["input_video"]
+                        video_data = video_info.get("data")
+                        video_format = video_info.get("format", "").lower()
+
+                        if not video_data or not video_format:
+                            logger.warning(
+                                "Skipping video part due to missing data or format."
+                            )
+                            continue
+
+                        try:
+                            validated_data = self._validate_media_data(
+                                video_format,
+                                video_data,
+                                SUPPORTED_VIDEO_FORMATS,
+                                MAX_VIDEO_SIZE_BYTES,
+                            )
+                            mime_type = VIDEO_FORMAT_TO_MIMETYPE.get(video_format)
+                            if not mime_type:
+                                raise ValueError(
+                                    f"Internal error: MIME type mapping missing for {video_format}"
+                                )
+
+                            parts.append(
+                                {
+                                    "inline_data": {
+                                        "mimeType": mime_type,
+                                        "data": validated_data,
+                                    }
+                                }
+                            )
+                            logger.debug(
+                                f"Successfully added video part (format: {video_format})"
+                            )
+
+                        except ValueError as e:
+                            logger.error(
+                                f"Skipping video part due to validation error: {e}"
+                            )
+                            parts.append({"text": f"[Error processing video: {e}]"})
+                        except Exception:
+                            logger.exception("Unexpected error processing video part.")
+                            parts.append(
+                                {"text": "[Unexpected error processing video]"}
+                            )
+
+                    else:
+                        # Log unrecognized but present types
+                        if content_type:
+                            logger.warning(
+                                f"Unsupported content type or missing data in structured content: {content_type}"
+                            )
+
+            elif (
+                "content" in msg and isinstance(msg["content"], str) and msg["content"]
+            ):
+                parts.extend(_process_text_with_image(msg["content"], model))
+            elif "tool_calls" in msg and isinstance(msg["tool_calls"], list):
+                # Keep existing tool call processing
+                for tool_call in msg["tool_calls"]:
+                    function_call = tool_call.get("function", {})
+                    # Sanitize arguments loading
+                    arguments_str = function_call.get("arguments", "{}")
+                    try:
+                        function_call["args"] = json.loads(arguments_str)
+                    except json.JSONDecodeError:
+                        logger.warning(
+                            f"Failed to decode tool call arguments: {arguments_str}"
+                        )
+                        function_call["args"] = {}
+                    if "arguments" in function_call:
+                        if "arguments" in function_call:
+                            del function_call["arguments"]
+
+                    parts.append({"functionCall": function_call})
+
+            if role not in SUPPORTED_ROLES:
+                if role == "tool":
+                    role = "user"
+                else:
+                    # 如果是最后一条消息，则认为是用户消息
+                    if idx == len(messages) - 1:
+                        role = "user"
+                    else:
+                        role = "model"
+            if parts:
+                if role == "system":
+                    text_only_parts = [p for p in parts if "text" in p]
+                    if len(text_only_parts) != len(parts):
+                        logger.warning(
+                            "Non-text parts found in system message; discarding them."
+                        )
+                    if text_only_parts:
+                        system_instruction_parts.extend(text_only_parts)
+
+                else:
+                    converted_messages.append({"role": role, "parts": parts})
+
+        system_instruction = (
+            None
+            if not system_instruction_parts
+            else {
+                "role": "system",
+                "parts": system_instruction_parts,
+            }
+        )
+        return converted_messages, system_instruction

app/handler/response_handler.py

@@ -0,0 +1,439 @@
+import base64
+import json
+import random
+import string
+import time
+import uuid
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+from app.config.config import settings
+from app.log.logger import get_openai_logger
+from app.utils.helpers import is_image_upload_configured
+from app.utils.uploader import ImageUploaderFactory
+
+logger = get_openai_logger()
+
+
+class ResponseHandler(ABC):
+    """响应处理器基类"""
+
+    @abstractmethod
+    def handle_response(
+        self, response: Dict[str, Any], model: str, stream: bool = False
+    ) -> Dict[str, Any]:
+        pass
+
+
+class GeminiResponseHandler(ResponseHandler):
+    """Gemini响应处理器"""
+
+    def __init__(self):
+        self.thinking_first = True
+        self.thinking_status = False
+
+    def handle_response(
+        self,
+        response: Dict[str, Any],
+        model: str,
+        stream: bool = False,
+        usage_metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        if stream:
+            return _handle_gemini_stream_response(response, model, stream)
+        return _handle_gemini_normal_response(response, model, stream)
+
+
+def _handle_openai_stream_response(
+    response: Dict[str, Any],
+    model: str,
+    finish_reason: str,
+    usage_metadata: Optional[Dict[str, Any]],
+) -> Dict[str, Any]:
+    choices = []
+    candidates = response.get("candidates", [])
+
+    for candidate in candidates:
+        index = candidate.get("index", 0)
+        text, reasoning_content, tool_calls, _ = _extract_result(
+            {"candidates": [candidate]}, model, stream=True, gemini_format=False
+        )
+
+        if not text and not tool_calls and not reasoning_content:
+            delta = {}
+        else:
+            delta = {
+                "content": text,
+                "reasoning_content": reasoning_content,
+                "role": "assistant",
+            }
+            if tool_calls:
+                delta["tool_calls"] = tool_calls
+
+        choice = {"index": index, "delta": delta, "finish_reason": finish_reason}
+        choices.append(choice)
+
+    template_chunk = {
+        "id": f"chatcmpl-{uuid.uuid4()}",
+        "object": "chat.completion.chunk",
+        "created": int(time.time()),
+        "model": model,
+        "choices": choices,
+    }
+    if usage_metadata:
+        template_chunk["usage"] = {
+            "prompt_tokens": usage_metadata.get("promptTokenCount", 0),
+            "completion_tokens": usage_metadata.get("candidatesTokenCount", 0),
+            "total_tokens": usage_metadata.get("totalTokenCount", 0),
+        }
+    return template_chunk
+
+
+def _handle_openai_normal_response(
+    response: Dict[str, Any],
+    model: str,
+    finish_reason: str,
+    usage_metadata: Optional[Dict[str, Any]],
+) -> Dict[str, Any]:
+    choices = []
+    candidates = response.get("candidates", [])
+
+    for i, candidate in enumerate(candidates):
+        text, reasoning_content, tool_calls, _ = _extract_result(
+            {"candidates": [candidate]}, model, stream=False, gemini_format=False
+        )
+        choice = {
+            "index": i,
+            "message": {
+                "role": "assistant",
+                "content": text,
+                "reasoning_content": reasoning_content,
+                "tool_calls": tool_calls,
+            },
+            "finish_reason": finish_reason,
+        }
+        choices.append(choice)
+
+    return {
+        "id": f"chatcmpl-{uuid.uuid4()}",
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": model,
+        "choices": choices,
+        "usage": {
+            "prompt_tokens": usage_metadata.get("promptTokenCount", 0),
+            "completion_tokens": usage_metadata.get("candidatesTokenCount", 0),
+            "total_tokens": usage_metadata.get("totalTokenCount", 0),
+        },
+    }
+
+
+class OpenAIResponseHandler(ResponseHandler):
+    """OpenAI响应处理器"""
+
+    def __init__(self, config):
+        self.config = config
+        self.thinking_first = True
+        self.thinking_status = False
+
+    def handle_response(
+        self,
+        response: Dict[str, Any],
+        model: str,
+        stream: bool = False,
+        finish_reason: str = None,
+        usage_metadata: Optional[Dict[str, Any]] = None,
+    ) -> Optional[Dict[str, Any]]:
+        if stream:
+            return _handle_openai_stream_response(
+                response, model, finish_reason, usage_metadata
+            )
+        return _handle_openai_normal_response(
+            response, model, finish_reason, usage_metadata
+        )
+
+    def handle_image_chat_response(
+        self, image_str: str, model: str, stream=False, finish_reason="stop"
+    ):
+        if stream:
+            return _handle_openai_stream_image_response(image_str, model, finish_reason)
+        return _handle_openai_normal_image_response(image_str, model, finish_reason)
+
+
+def _handle_openai_stream_image_response(
+    image_str: str, model: str, finish_reason: str
+) -> Dict[str, Any]:
+    return {
+        "id": f"chatcmpl-{uuid.uuid4()}",
+        "object": "chat.completion.chunk",
+        "created": int(time.time()),
+        "model": model,
+        "choices": [
+            {
+                "index": 0,
+                "delta": {"content": image_str} if image_str else {},
+                "finish_reason": finish_reason,
+            }
+        ],
+    }
+
+
+def _handle_openai_normal_image_response(
+    image_str: str, model: str, finish_reason: str
+) -> Dict[str, Any]:
+    return {
+        "id": f"chatcmpl-{uuid.uuid4()}",
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": model,
+        "choices": [
+            {
+                "index": 0,
+                "message": {"role": "assistant", "content": image_str},
+                "finish_reason": finish_reason,
+            }
+        ],
+        "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0},
+    }
+
+
+def _extract_result(
+    response: Dict[str, Any],
+    model: str,
+    stream: bool = False,
+    gemini_format: bool = False,
+) -> tuple[str, Optional[str], List[Dict[str, Any]], Optional[bool]]:
+    text, reasoning_content, tool_calls, thought = "", "", [], None
+
+    if stream:
+        if response.get("candidates"):
+            candidate = response["candidates"][0]
+            content = candidate.get("content", {})
+            parts = content.get("parts", [])
+            if not parts:
+                logger.warning("No parts found in stream response")
+                return "", None, [], None
+
+            if "text" in parts[0]:
+                text = parts[0].get("text")
+                if "thought" in parts[0]:
+                    if not gemini_format and settings.SHOW_THINKING_PROCESS:
+                        reasoning_content = text
+                        text = ""
+                    thought = parts[0].get("thought")
+            elif "executableCode" in parts[0]:
+                text = _format_code_block(parts[0]["executableCode"])
+            elif "codeExecution" in parts[0]:
+                text = _format_code_block(parts[0]["codeExecution"])
+            elif "executableCodeResult" in parts[0]:
+                text = _format_execution_result(parts[0]["executableCodeResult"])
+            elif "codeExecutionResult" in parts[0]:
+                text = _format_execution_result(parts[0]["codeExecutionResult"])
+            elif "inlineData" in parts[0]:
+                text = _extract_image_data(parts[0])
+            else:
+                text = ""
+            text = _add_search_link_text(model, candidate, text)
+            tool_calls = _extract_tool_calls(parts, gemini_format)
+    else:
+        if response.get("candidates"):
+            candidate = response["candidates"][0]
+            text, reasoning_content = "", ""
+
+            # 使用安全的访问方式
+            content = candidate.get("content", {})
+
+            if content and isinstance(content, dict):
+                parts = content.get("parts", [])
+
+                if parts:
+                    for part in parts:
+                        if "text" in part:
+                            if "thought" in part and settings.SHOW_THINKING_PROCESS:
+                                reasoning_content += part["text"]
+                            else:
+                                text += part["text"]
+                            if "thought" in part and thought is None:
+                                thought = part.get("thought")
+                        elif "inlineData" in part:
+                            text += _extract_image_data(part)
+                else:
+                    logger.warning(f"No parts found in content for model: {model}")
+            else:
+                logger.error(f"Invalid content structure for model: {model}")
+
+            text = _add_search_link_text(model, candidate, text)
+
+            # 安全地获取 parts 用于工具调用提取
+            parts = candidate.get("content", {}).get("parts", [])
+            tool_calls = _extract_tool_calls(parts, gemini_format)
+        else:
+            logger.warning(f"No candidates found in response for model: {model}")
+            text = "暂无返回"
+
+    return text, reasoning_content, tool_calls, thought
+
+
+def _has_inline_image_part(response: Dict[str, Any]) -> bool:
+    try:
+        for c in response.get("candidates", []):
+            for p in c.get("content", {}).get("parts", []):
+                if isinstance(p, dict) and ("inlineData" in p):
+                    return True
+    except Exception:
+        return False
+    return False
+
+
+def _extract_image_data(part: dict) -> str:
+    image_uploader = None
+    if settings.UPLOAD_PROVIDER == "smms":
+        image_uploader = ImageUploaderFactory.create(
+            provider=settings.UPLOAD_PROVIDER, api_key=settings.SMMS_SECRET_TOKEN
+        )
+    elif settings.UPLOAD_PROVIDER == "picgo":
+        image_uploader = ImageUploaderFactory.create(
+            provider=settings.UPLOAD_PROVIDER, 
+            api_key=settings.PICGO_API_KEY,
+            api_url=settings.PICGO_API_URL
+        )
+    elif settings.UPLOAD_PROVIDER == "cloudflare_imgbed":
+        image_uploader = ImageUploaderFactory.create(
+            provider=settings.UPLOAD_PROVIDER,
+            base_url=settings.CLOUDFLARE_IMGBED_URL,
+            auth_code=settings.CLOUDFLARE_IMGBED_AUTH_CODE,
+            upload_folder=settings.CLOUDFLARE_IMGBED_UPLOAD_FOLDER,
+        )
+    current_date = time.strftime("%Y/%m/%d")
+    filename = f"{current_date}/{uuid.uuid4().hex[:8]}.png"
+    base64_data = part["inlineData"]["data"]
+    mime_type = part["inlineData"]["mimeType"]
+    # 将base64_data转成bytes数组
+    # Return empty string if no uploader is configured
+    if not is_image_upload_configured(settings):
+        return f"\n\n![image](data:{mime_type};base64,{base64_data})\n\n"
+    bytes_data = base64.b64decode(base64_data)
+    upload_response = image_uploader.upload(bytes_data, filename)
+    if upload_response.success:
+        text = f"\n\n![image]({upload_response.data.url})\n\n"
+    else:
+        text = f"\n\n![image](data:{mime_type};base64,{base64_data})\n\n"
+    return text
+
+
+def _extract_tool_calls(
+    parts: List[Dict[str, Any]], gemini_format: bool
+) -> List[Dict[str, Any]]:
+    """提取工具调用信息"""
+    if not parts or not isinstance(parts, list):
+        return []
+
+    letters = string.ascii_lowercase + string.digits
+    tool_calls = list()
+
+    for i in range(len(parts)):
+        part = parts[i]
+        if not part or not isinstance(part, dict):
+            continue
+
+        item = part.get("functionCall", {})
+        if not item or not isinstance(item, dict):
+            continue
+
+        if gemini_format:
+            tool_calls.append(part)
+        else:
+            id = f"call_{''.join(random.sample(letters, 32))}"
+            name = item.get("name", "")
+            arguments = json.dumps(item.get("args", None) or {})
+
+            tool_calls.append(
+                {
+                    "index": i,
+                    "id": id,
+                    "type": "function",
+                    "function": {"name": name, "arguments": arguments},
+                }
+            )
+
+    return tool_calls
+
+
+def _handle_gemini_stream_response(
+    response: Dict[str, Any], model: str, stream: bool
+) -> Dict[str, Any]:
+    # Early return raw Gemini response if no uploader configured and contains inline images
+    if not is_image_upload_configured(settings) and _has_inline_image_part(response):
+        return response
+
+    text, reasoning_content, tool_calls, thought = _extract_result(
+        response, model, stream=stream, gemini_format=True
+    )
+    if tool_calls:
+        content = {"parts": tool_calls, "role": "model"}
+    else:
+        part = {"text": text}
+        if thought is not None:
+            part["thought"] = thought
+        content = {"parts": [part], "role": "model"}
+    response["candidates"][0]["content"] = content
+    return response
+
+
+def _handle_gemini_normal_response(
+    response: Dict[str, Any], model: str, stream: bool
+) -> Dict[str, Any]:
+    # Early return raw Gemini response if no uploader configured and contains inline images
+    if not is_image_upload_configured(settings) and _has_inline_image_part(response):
+        return response
+
+    text, reasoning_content, tool_calls, thought = _extract_result(
+        response, model, stream=stream, gemini_format=True
+    )
+    parts = []
+    if tool_calls:
+        parts = tool_calls
+    else:
+        if thought is not None:
+            parts.append({"text": reasoning_content, "thought": thought})
+        part = {"text": text}
+        parts.append(part)
+    content = {"parts": parts, "role": "model"}
+    response["candidates"][0]["content"] = content
+    return response
+
+
+def _format_code_block(code_data: dict) -> str:
+    """格式化代码块输出"""
+    language = code_data.get("language", "").lower()
+    code = code_data.get("code", "").strip()
+    return f"""\n\n---\n\n【代码执行】\n```{language}\n{code}\n```\n"""
+
+
+def _add_search_link_text(model: str, candidate: dict, text: str) -> str:
+    if (
+        settings.SHOW_SEARCH_LINK
+        and model.endswith("-search")
+        and "groundingMetadata" in candidate
+        and "groundingChunks" in candidate["groundingMetadata"]
+    ):
+        grounding_chunks = candidate["groundingMetadata"]["groundingChunks"]
+        text += "\n\n---\n\n"
+        text += "**【引用来源】**\n\n"
+        for _, grounding_chunk in enumerate(grounding_chunks, 1):
+            if "web" in grounding_chunk:
+                text += _create_search_link(grounding_chunk["web"])
+        return text
+    else:
+        return text
+
+
+def _create_search_link(grounding_chunk: dict) -> str:
+    return f'\n- [{grounding_chunk["title"]}]({grounding_chunk["uri"]})'
+
+
+def _format_execution_result(result_data: dict) -> str:
+    """格式化执行结果输出"""
+    outcome = result_data.get("outcome", "")
+    output = result_data.get("output", "").strip()
+    return f"""\n【执行结果】\n> outcome: {outcome}\n\n【输出结果】\n```plaintext\n{output}\n```\n\n---\n\n"""

app/handler/retry_handler.py

@@ -0,0 +1,51 @@
+
+from functools import wraps
+from typing import Callable, TypeVar
+
+from app.config.config import settings
+from app.log.logger import get_retry_logger
+from app.utils.helpers import redact_key_for_logging
+
+T = TypeVar("T")
+logger = get_retry_logger()
+
+
+class RetryHandler:
+    """重试处理装饰器"""
+
+    def __init__(self, key_arg: str = "api_key"):
+        self.key_arg = key_arg
+
+    def __call__(self, func: Callable[..., T]) -> Callable[..., T]:
+        @wraps(func)
+        async def wrapper(*args, **kwargs) -> T:
+            last_exception = None
+
+            for attempt in range(settings.MAX_RETRIES):
+                retries = attempt + 1
+                try:
+                    return await func(*args, **kwargs)
+                except Exception as e:
+                    last_exception = e
+                    logger.warning(
+                        f"API call failed with error: {str(e)}. Attempt {retries} of {settings.MAX_RETRIES}"
+                    )
+
+                    # 从函数参数中获取 key_manager
+                    key_manager = kwargs.get("key_manager")
+                    if key_manager:
+                        old_key = kwargs.get(self.key_arg)
+                        new_key = await key_manager.handle_api_failure(old_key, retries)
+                        if new_key:
+                            kwargs[self.key_arg] = new_key
+                            logger.info(f"Switched to new API key: {redact_key_for_logging(new_key)}")
+                        else:
+                            logger.error(f"No valid API key available after {retries} retries.")
+                            break
+
+            logger.error(
+                f"All retry attempts failed, raising final exception: {str(last_exception)}"
+            )
+            raise last_exception
+
+        return wrapper

app/handler/stream_optimizer.py

@@ -0,0 +1,143 @@
+
+import asyncio
+import math
+from typing import Any, AsyncGenerator, Callable, List
+
+from app.config.config import settings
+from app.core.constants import (
+    DEFAULT_STREAM_CHUNK_SIZE,
+    DEFAULT_STREAM_LONG_TEXT_THRESHOLD,
+    DEFAULT_STREAM_MAX_DELAY,
+    DEFAULT_STREAM_MIN_DELAY,
+    DEFAULT_STREAM_SHORT_TEXT_THRESHOLD,
+)
+from app.log.logger import get_gemini_logger, get_openai_logger
+
+logger_openai = get_openai_logger()
+logger_gemini = get_gemini_logger()
+
+
+class StreamOptimizer:
+    """流式输出优化器
+
+    提供流式输出优化功能，包括智能延迟调整和长文本分块输出。
+    """
+
+    def __init__(
+        self,
+        logger=None,
+        min_delay: float = DEFAULT_STREAM_MIN_DELAY,
+        max_delay: float = DEFAULT_STREAM_MAX_DELAY,
+        short_text_threshold: int = DEFAULT_STREAM_SHORT_TEXT_THRESHOLD,
+        long_text_threshold: int = DEFAULT_STREAM_LONG_TEXT_THRESHOLD,
+        chunk_size: int = DEFAULT_STREAM_CHUNK_SIZE,
+    ):
+        """初始化流式输出优化器
+
+        参数:
+            logger: 日志记录器
+            min_delay: 最小延迟时间（秒）
+            max_delay: 最大延迟时间（秒）
+            short_text_threshold: 短文本阈值（字符数）
+            long_text_threshold: 长文本阈值（字符数）
+            chunk_size: 长文本分块大小（字符数）
+        """
+        self.logger = logger
+        self.min_delay = min_delay
+        self.max_delay = max_delay
+        self.short_text_threshold = short_text_threshold
+        self.long_text_threshold = long_text_threshold
+        self.chunk_size = chunk_size
+
+    def calculate_delay(self, text_length: int) -> float:
+        """根据文本长度计算延迟时间
+
+        参数:
+            text_length: 文本长度
+
+        返回:
+            延迟时间（秒）
+        """
+        if text_length <= self.short_text_threshold:
+            # 短文本使用较大延迟
+            return self.max_delay
+        elif text_length >= self.long_text_threshold:
+            # 长文本使用较小延迟
+            return self.min_delay
+        else:
+            # 中等长度文本使用线性插值计算延迟
+            # 使用对数函数使延迟变化更平滑
+            ratio = math.log(text_length / self.short_text_threshold) / math.log(
+                self.long_text_threshold / self.short_text_threshold
+            )
+            return self.max_delay - ratio * (self.max_delay - self.min_delay)
+
+    def split_text_into_chunks(self, text: str) -> List[str]:
+        """将文本分割成小块
+
+        参数:
+            text: 要分割的文本
+
+        返回:
+            文本块列表
+        """
+        return [
+            text[i : i + self.chunk_size] for i in range(0, len(text), self.chunk_size)
+        ]
+
+    async def optimize_stream_output(
+        self,
+        text: str,
+        create_response_chunk: Callable[[str], Any],
+        format_chunk: Callable[[Any], str],
+    ) -> AsyncGenerator[str, None]:
+        """优化流式输出
+
+        参数:
+            text: 要输出的文本
+            create_response_chunk: 创建响应块的函数，接收文本，返回响应块
+            format_chunk: 格式化响应块的函数，接收响应块，返回格式化后的字符串
+
+        返回:
+            异步生成器，生成格式化后的响应块
+        """
+        if not text:
+            return
+
+        # 计算智能延迟时间
+        delay = self.calculate_delay(len(text))
+
+        # 根据文本长度决定输出方式
+        if len(text) >= self.long_text_threshold:
+            # 长文本：分块输出
+            chunks = self.split_text_into_chunks(text)
+            for chunk_text in chunks:
+                chunk_response = create_response_chunk(chunk_text)
+                yield format_chunk(chunk_response)
+                await asyncio.sleep(delay)
+        else:
+            # 短文本：逐字符输出
+            for char in text:
+                char_chunk = create_response_chunk(char)
+                yield format_chunk(char_chunk)
+                await asyncio.sleep(delay)
+
+
+# 创建默认的优化器实例，可以直接导入使用
+openai_optimizer = StreamOptimizer(
+    logger=logger_openai,
+    min_delay=settings.STREAM_MIN_DELAY,
+    max_delay=settings.STREAM_MAX_DELAY,
+    short_text_threshold=settings.STREAM_SHORT_TEXT_THRESHOLD,
+    long_text_threshold=settings.STREAM_LONG_TEXT_THRESHOLD,
+    chunk_size=settings.STREAM_CHUNK_SIZE,
+)
+
+gemini_optimizer = StreamOptimizer(
+    logger=logger_gemini,
+    min_delay=settings.STREAM_MIN_DELAY,
+    max_delay=settings.STREAM_MAX_DELAY,
+    short_text_threshold=settings.STREAM_SHORT_TEXT_THRESHOLD,
+    long_text_threshold=settings.STREAM_LONG_TEXT_THRESHOLD,
+    chunk_size=settings.STREAM_CHUNK_SIZE,
+)

app/log/logger.py

@@ -0,0 +1,349 @@
+import logging
+import platform
+import re
+import sys
+from typing import Dict, Optional
+
+# ANSI转义序列颜色代码
+COLORS = {
+    "DEBUG": "\033[34m",  # 蓝色
+    "INFO": "\033[32m",  # 绿色
+    "WARNING": "\033[33m",  # 黄色
+    "ERROR": "\033[31m",  # 红色
+    "CRITICAL": "\033[1;31m",  # 红色加粗
+}
+
+
+# Windows系统启用ANSI支持
+if platform.system() == "Windows":
+    import ctypes
+
+    kernel32 = ctypes.windll.kernel32
+    kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
+
+
+class ColoredFormatter(logging.Formatter):
+    """
+    自定义的日志格式化器,添加颜色支持
+    """
+
+    def format(self, record):
+        # 获取对应级别的颜色代码
+        color = COLORS.get(record.levelname, "")
+        # 添加颜色代码和重置代码
+        record.levelname = f"{color}{record.levelname}\033[0m"
+        # 创建包含文件名和行号的固定宽度字符串
+        record.fileloc = f"[{record.filename}:{record.lineno}]"
+        return super().format(record)
+
+
+class AccessLogFormatter(logging.Formatter):
+    """
+    Custom access log formatter that redacts API keys in URLs
+    """
+
+    # API key patterns to match in URLs
+    API_KEY_PATTERNS = [
+        r"\bAIza[0-9A-Za-z_-]{35}",  # Google API keys (like Gemini)
+        r"\bsk-[0-9A-Za-z_-]{20,}",  # OpenAI and general sk- prefixed keys
+    ]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # Compile regex patterns for better performance
+        self.compiled_patterns = [
+            re.compile(pattern) for pattern in self.API_KEY_PATTERNS
+        ]
+
+    def format(self, record):
+        # Format the record normally first
+        formatted_msg = super().format(record)
+
+        # Redact API keys in the formatted message
+        return self._redact_api_keys_in_message(formatted_msg)
+
+    def _redact_api_keys_in_message(self, message: str) -> str:
+        """
+        Replace API keys in log message with redacted versions
+        """
+        try:
+            for pattern in self.compiled_patterns:
+
+                def replace_key(match):
+                    key = match.group(0)
+                    return redact_key_for_logging(key)
+
+                message = pattern.sub(replace_key, message)
+
+            return message
+        except Exception as e:
+            # Log the error but don't expose the original message in case it contains keys
+            import logging
+
+            logger = logging.getLogger(__name__)
+            logger.error(f"Error redacting API keys in access log: {e}")
+            return "[LOG_REDACTION_ERROR]"
+
+
+def redact_key_for_logging(key: str) -> str:
+    """
+    Redacts API key for secure logging by showing only first and last 6 characters.
+
+    Args:
+        key: API key to redact
+
+    Returns:
+        str: Redacted key in format "first6...last6" or descriptive placeholder for edge cases
+    """
+    if not key:
+        return key
+
+    if len(key) <= 12:
+        return f"{key[:3]}...{key[-3:]}"
+    else:
+        return f"{key[:6]}...{key[-6:]}"
+
+
+# 日志格式 - 使用 fileloc 并设置固定宽度 (例如 30)
+FORMATTER = ColoredFormatter(
+    "%(asctime)s | %(levelname)-17s | %(fileloc)-30s | %(message)s"
+)
+
+# 日志级别映射
+LOG_LEVELS = {
+    "debug": logging.DEBUG,
+    "info": logging.INFO,
+    "warning": logging.WARNING,
+    "error": logging.ERROR,
+    "critical": logging.CRITICAL,
+}
+
+
+class Logger:
+    def __init__(self):
+        pass
+
+    _loggers: Dict[str, logging.Logger] = {}
+
+    @staticmethod
+    def setup_logger(name: str) -> logging.Logger:
+        """
+        设置并获取logger
+        :param name: logger名称
+        :return: logger实例
+        """
+        # 导入 settings 对象
+        from app.config.config import settings
+
+        # 从全局配置获取日志级别
+        log_level_str = settings.LOG_LEVEL.lower()
+        level = LOG_LEVELS.get(log_level_str, logging.INFO)
+
+        if name in Logger._loggers:
+            # 如果 logger 已存在，检查并更新其级别（如果需要）
+            existing_logger = Logger._loggers[name]
+            if existing_logger.level != level:
+                existing_logger.setLevel(level)
+            return existing_logger
+
+        logger = logging.getLogger(name)
+        logger.setLevel(level)
+        logger.propagate = False
+
+        # 添加控制台输出
+        console_handler = logging.StreamHandler(sys.stdout)
+        console_handler.setFormatter(FORMATTER)
+        logger.addHandler(console_handler)
+
+        Logger._loggers[name] = logger
+        return logger
+
+    @staticmethod
+    def get_logger(name: str) -> Optional[logging.Logger]:
+        """
+        获取已存在的logger
+        :param name: logger名称
+        :return: logger实例或None
+        """
+        return Logger._loggers.get(name)
+
+    @staticmethod
+    def update_log_levels(log_level: str):
+        """
+        根据当前��全局配置更新所有已创建 logger 的日志级别。
+        """
+        log_level_str = log_level.lower()
+        new_level = LOG_LEVELS.get(log_level_str, logging.INFO)
+
+        updated_count = 0
+        for logger_name, logger_instance in Logger._loggers.items():
+            if logger_instance.level != new_level:
+                logger_instance.setLevel(new_level)
+                # 可选：记录级别变更日志，但注意避免在日志模块内部产生过多日志
+                # print(f"Updated log level for logger '{logger_name}' to {log_level_str.upper()}")
+                updated_count += 1
+
+
+# 预定义的loggers
+def get_openai_logger():
+    return Logger.setup_logger("openai")
+
+
+def get_gemini_logger():
+    return Logger.setup_logger("gemini")
+
+
+def get_chat_logger():
+    return Logger.setup_logger("chat")
+
+
+def get_model_logger():
+    return Logger.setup_logger("model")
+
+
+def get_security_logger():
+    return Logger.setup_logger("security")
+
+
+def get_key_manager_logger():
+    return Logger.setup_logger("key_manager")
+
+
+def get_main_logger():
+    return Logger.setup_logger("main")
+
+
+def get_embeddings_logger():
+    return Logger.setup_logger("embeddings")
+
+
+def get_request_logger():
+    return Logger.setup_logger("request")
+
+
+def get_retry_logger():
+    return Logger.setup_logger("retry")
+
+
+def get_image_create_logger():
+    return Logger.setup_logger("image_create")
+
+
+def get_exceptions_logger():
+    return Logger.setup_logger("exceptions")
+
+
+def get_application_logger():
+    return Logger.setup_logger("application")
+
+
+def get_initialization_logger():
+    return Logger.setup_logger("initialization")
+
+
+def get_middleware_logger():
+    return Logger.setup_logger("middleware")
+
+
+def get_routes_logger():
+    return Logger.setup_logger("routes")
+
+
+def get_config_routes_logger():
+    return Logger.setup_logger("config_routes")
+
+
+def get_config_logger():
+    return Logger.setup_logger("config")
+
+
+def get_database_logger():
+    return Logger.setup_logger("database")
+
+
+def get_log_routes_logger():
+    return Logger.setup_logger("log_routes")
+
+
+def get_stats_logger():
+    return Logger.setup_logger("stats")
+
+
+def get_update_logger():
+    return Logger.setup_logger("update_service")
+
+
+def get_scheduler_routes():
+    return Logger.setup_logger("scheduler_routes")
+
+
+def get_message_converter_logger():
+    return Logger.setup_logger("message_converter")
+
+
+def get_api_client_logger():
+    return Logger.setup_logger("api_client")
+
+
+def get_openai_compatible_logger():
+    return Logger.setup_logger("openai_compatible")
+
+
+def get_error_log_logger():
+    return Logger.setup_logger("error_log")
+
+
+def get_request_log_logger():
+    return Logger.setup_logger("request_log")
+
+
+def get_files_logger():
+    return Logger.setup_logger("files")
+
+
+def get_vertex_express_logger():
+    return Logger.setup_logger("vertex_express")
+
+
+def get_gemini_embedding_logger():
+    return Logger.setup_logger("gemini_embedding")
+
+
+def setup_access_logging():
+    """
+    Configure uvicorn access logging with API key redaction
+
+    This function sets up a custom access log formatter that automatically
+    redacts API keys in HTTP access logs. It works by:
+
+    1. Intercepting uvicorn's access log messages
+    2. Using regex patterns to find API keys in URLs
+    3. Replacing them with redacted versions (first6...last6)
+
+    Supported API key formats:
+    - Google/Gemini API keys: AIza[35 chars]
+    - OpenAI API keys: sk-[48 chars]
+    - General sk- prefixed keys: sk-[20+ chars]
+
+    Usage:
+    - Automatically called in main.py when running with uvicorn
+    - For production deployment with gunicorn, ensure this is called in startup
+    """
+    # Get the uvicorn access logger
+    access_logger = logging.getLogger("uvicorn.access")
+
+    # Remove existing handlers to avoid duplicate logs
+    for handler in access_logger.handlers[:]:
+        access_logger.removeHandler(handler)
+
+    # Create new handler with our custom formatter that includes timestamp and log level
+    handler = logging.StreamHandler(sys.stdout)
+    access_formatter = AccessLogFormatter("%(asctime)s | %(levelname)-8s | %(message)s")
+    handler.setFormatter(access_formatter)
+
+    # Add the handler to uvicorn access logger
+    access_logger.addHandler(handler)
+    access_logger.setLevel(logging.INFO)
+    access_logger.propagate = False
+
+    return access_logger

app/main.py

@@ -0,0 +1,15 @@
+import uvicorn
+from dotenv import load_dotenv
+
+# 在导入应用程序配置之前加载 .env 文件到环境变量
+load_dotenv()
+
+from app.core.application import create_app
+from app.log.logger import get_main_logger
+
+app = create_app()
+
+if __name__ == "__main__":
+    logger = get_main_logger()
+    logger.info("Starting application server...")
+    uvicorn.run(app, host="0.0.0.0", port=8001)

app/middleware/middleware.py

@@ -0,0 +1,81 @@
+"""
+中间件配置模块，负责设置和配置应用程序的中间件
+"""
+
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import RedirectResponse
+from starlette.middleware.base import BaseHTTPMiddleware
+
+# from app.middleware.request_logging_middleware import RequestLoggingMiddleware
+from app.middleware.smart_routing_middleware import SmartRoutingMiddleware
+from app.core.constants import API_VERSION
+from app.core.security import verify_auth_token
+from app.log.logger import get_middleware_logger
+
+logger = get_middleware_logger()
+
+
+class AuthMiddleware(BaseHTTPMiddleware):
+    """
+    认证中间件，处理未经身份验证的请求
+    """
+
+    async def dispatch(self, request: Request, call_next):
+        # 允许特定路径绕过身份验证
+        if (
+            request.url.path not in ["/", "/auth"]
+            and not request.url.path.startswith("/static")
+            and not request.url.path.startswith("/gemini")
+            and not request.url.path.startswith("/v1")
+            and not request.url.path.startswith(f"/{API_VERSION}")
+            and not request.url.path.startswith("/health")
+            and not request.url.path.startswith("/hf")
+            and not request.url.path.startswith("/openai")
+            and not request.url.path.startswith("/api/version/check")
+            and not request.url.path.startswith("/vertex-express")
+            and not request.url.path.startswith("/upload")
+        ):
+
+            auth_token = request.cookies.get("auth_token")
+            if not auth_token or not verify_auth_token(auth_token):
+                logger.warning(f"Unauthorized access attempt to {request.url.path}")
+                return RedirectResponse(url="/")
+            logger.debug("Request authenticated successfully")
+
+        response = await call_next(request)
+        return response
+
+
+def setup_middlewares(app: FastAPI) -> None:
+    """
+    设置应用程序的中间件
+
+    Args:
+        app: FastAPI应用程序实例
+    """
+    # 添加智能路由中间件（必须在认证中间件之前）
+    app.add_middleware(SmartRoutingMiddleware)
+
+    # 添加认证中间件
+    app.add_middleware(AuthMiddleware)
+
+    # 添加请求日志中间件（可选，默认注释掉）
+    # app.add_middleware(RequestLoggingMiddleware)
+
+    # 配置CORS中间件
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=[
+            "GET",
+            "POST",
+            "PUT",
+            "DELETE",
+            "OPTIONS",
+        ],
+        allow_headers=["*"],
+        expose_headers=["*"],
+        max_age=600,
+    )

app/middleware/request_logging_middleware.py

@@ -0,0 +1,40 @@
+import json
+
+from fastapi import Request
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from app.log.logger import get_request_logger
+
+logger = get_request_logger()
+
+
+# 添加中间件类
+class RequestLoggingMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        # 记录请求路径
+        logger.info(f"Request path: {request.url.path}")
+
+        # 获取并记录请求体
+        try:
+            body = await request.body()
+            if body:
+                body_str = body.decode()
+                # 尝试格式化JSON
+                try:
+                    formatted_body = json.loads(body_str)
+                    logger.info(
+                        f"Formatted request body:\n{json.dumps(formatted_body, indent=2, ensure_ascii=False)}"
+                    )
+                except json.JSONDecodeError:
+                    logger.error("Request body is not valid JSON.")
+        except Exception as e:
+            logger.error(f"Error reading request body: {str(e)}")
+
+        # 重置请求的接收器，以便后续处理器可以继续读取请求体
+        async def receive():
+            return {"type": "http.request", "body": body, "more_body": False}
+
+        request._receive = receive
+
+        response = await call_next(request)
+        return response

app/middleware/smart_routing_middleware.py

@@ -0,0 +1,210 @@
+from fastapi import Request
+from starlette.middleware.base import BaseHTTPMiddleware
+from app.config.config import settings
+from app.log.logger import get_main_logger
+import re
+
+logger = get_main_logger()
+
+class SmartRoutingMiddleware(BaseHTTPMiddleware):
+    def __init__(self, app):
+        super().__init__(app)
+        # 简化的路由规则 - 直接根据检测结果路由
+        pass
+
+    async def dispatch(self, request: Request, call_next):
+        if not settings.URL_NORMALIZATION_ENABLED:
+            return await call_next(request)
+        logger.debug(f"request: {request}")
+        original_path = str(request.url.path)
+        method = request.method
+        
+        # 尝试修复URL
+        fixed_path, fix_info = self.fix_request_url(original_path, method, request)
+
+        if fixed_path != original_path:
+            logger.info(f"URL fixed: {method} {original_path} → {fixed_path}")
+            if fix_info:
+                logger.debug(f"Fix details: {fix_info}")
+
+            # 重写请求路径
+            request.scope["path"] = fixed_path
+            request.scope["raw_path"] = fixed_path.encode()
+        
+        return await call_next(request)
+
+    def fix_request_url(self, path: str, method: str, request: Request) -> tuple:
+        """简化的URL修复逻辑"""
+
+        # 首先检查是否已经是正确的格式，如果是则不处理
+        if self.is_already_correct_format(path):
+            return path, None
+
+        # 1. 最高优先级：包含generateContent → Gemini格式
+        if "generatecontent" in path.lower() or "v1beta/models" in path.lower():
+            return self.fix_gemini_by_operation(path, method, request)
+
+        # 2. 第二优先级：包含/openai/ → OpenAI格式
+        if "/openai/" in path.lower():
+            return self.fix_openai_by_operation(path, method)
+
+        # 3. 第三优先级：包含/v1/ → v1格式
+        if "/v1/" in path.lower():
+            return self.fix_v1_by_operation(path, method)
+
+        # 4. 第四优先级：包含/chat/completions → chat功能
+        if "/chat/completions" in path.lower():
+            return "/v1/chat/completions", {"type": "v1_chat"}
+
+        # 5. 默认：原样传递
+        return path, None
+
+    def is_already_correct_format(self, path: str) -> bool:
+        """检查是否已经是正确的API格式"""
+        # 检查是否已经是正确的端点格式
+        correct_patterns = [
+            r"^/v1beta/models/[^/:]+:(generate|streamGenerate)Content$",  # Gemini原生
+            r"^/gemini/v1beta/models/[^/:]+:(generate|streamGenerate)Content$",  # Gemini带前缀
+            r"^/v1beta/models$",  # Gemini模型列表
+            r"^/gemini/v1beta/models$",  # Gemini带前缀的模型列表
+            r"^/v1/(chat/completions|models|embeddings|images/generations|audio/speech)$",  # v1格式
+            r"^/openai/v1/(chat/completions|models|embeddings|images/generations|audio/speech)$",  # OpenAI格式
+            r"^/hf/v1/(chat/completions|models|embeddings|images/generations|audio/speech)$",  # HF格式
+            r"^/vertex-express/v1beta/models/[^/:]+:(generate|streamGenerate)Content$",  # Vertex Express Gemini格式
+            r"^/vertex-express/v1beta/models$",  # Vertex Express模型列表
+            r"^/vertex-express/v1/(chat/completions|models|embeddings|images/generations)$",  # Vertex Express OpenAI格式
+        ]
+
+        for pattern in correct_patterns:
+            if re.match(pattern, path):
+                return True
+
+        return False
+
+    def fix_gemini_by_operation(
+        self, path: str, method: str, request: Request
+    ) -> tuple:
+        """根据Gemini操作修复，考虑端点偏好"""
+        if method == "GET":
+            return "/v1beta/models", {
+                "role": "gemini_models",
+            }
+
+        # 提取模型名称
+        try:
+            model_name = self.extract_model_name(path, request)
+        except ValueError:
+            # 无法提取模型名称，返回原路径不做处理
+            return path, None
+
+        # 检测是否为流式请求
+        is_stream = self.detect_stream_request(path, request)
+
+        # 检查是否有vertex-express偏好
+        if "/vertex-express/" in path.lower():
+            if is_stream:
+                target_url = (
+                    f"/vertex-express/v1beta/models/{model_name}:streamGenerateContent"
+                )
+            else:
+                target_url = (
+                    f"/vertex-express/v1beta/models/{model_name}:generateContent"
+                )
+
+            fix_info = {
+                "rule": (
+                    "vertex_express_generate"
+                    if not is_stream
+                    else "vertex_express_stream"
+                ),
+                "preference": "vertex_express_format",
+                "is_stream": is_stream,
+                "model": model_name,
+            }
+        else:
+            # 标准Gemini端点
+            if is_stream:
+                target_url = f"/v1beta/models/{model_name}:streamGenerateContent"
+            else:
+                target_url = f"/v1beta/models/{model_name}:generateContent"
+
+            fix_info = {
+                "rule": "gemini_generate" if not is_stream else "gemini_stream",
+                "preference": "gemini_format",
+                "is_stream": is_stream,
+                "model": model_name,
+            }
+
+        return target_url, fix_info
+
+    def fix_openai_by_operation(self, path: str, method: str) -> tuple:
+        """根据操作类型修复OpenAI格式"""
+        if method == "POST":
+            if "chat" in path.lower() or "completion" in path.lower():
+                return "/openai/v1/chat/completions", {"type": "openai_chat"}
+            elif "embedding" in path.lower():
+                return "/openai/v1/embeddings", {"type": "openai_embeddings"}
+            elif "image" in path.lower():
+                return "/openai/v1/images/generations", {"type": "openai_images"}
+            elif "audio" in path.lower():
+                return "/openai/v1/audio/speech", {"type": "openai_audio"}
+        elif method == "GET":
+            if "model" in path.lower():
+                return "/openai/v1/models", {"type": "openai_models"}
+
+        return path, None
+
+    def fix_v1_by_operation(self, path: str, method: str) -> tuple:
+        """根据操作类型修复v1格式"""
+        if method == "POST":
+            if "chat" in path.lower() or "completion" in path.lower():
+                return "/v1/chat/completions", {"type": "v1_chat"}
+            elif "embedding" in path.lower():
+                return "/v1/embeddings", {"type": "v1_embeddings"}
+            elif "image" in path.lower():
+                return "/v1/images/generations", {"type": "v1_images"}
+            elif "audio" in path.lower():
+                return "/v1/audio/speech", {"type": "v1_audio"}
+        elif method == "GET":
+            if "model" in path.lower():
+                return "/v1/models", {"type": "v1_models"}
+
+        return path, None
+
+    def detect_stream_request(self, path: str, request: Request) -> bool:
+        """检测是否为流式请求"""
+        # 1. 路径中包含stream关键词
+        if "stream" in path.lower():
+            return True
+
+        # 2. 查询参数
+        if request.query_params.get("stream") == "true":
+            return True
+
+        return False
+
+    def extract_model_name(self, path: str, request: Request) -> str:
+        """从请求中提取模型名称，用于构建Gemini API URL"""
+        # 1. 从请求体中提取
+        try:
+            if hasattr(request, "_body") and request._body:
+                import json
+
+                body = json.loads(request._body.decode())
+                if "model" in body and body["model"]:
+                    return body["model"]
+        except Exception:
+            pass
+
+        # 2. 从查询参数中提取
+        model_param = request.query_params.get("model")
+        if model_param:
+            return model_param
+
+        # 3. 从路径中提取（用于已包含模型名称的路径）
+        match = re.search(r"/models/([^/:]+)", path, re.IGNORECASE)
+        if match:
+            return match.group(1)
+
+        # 4. 如果无法提取模型名称，抛出异常
+        raise ValueError("Unable to extract model name from request")

app/router/config_routes.py

@@ -0,0 +1,225 @@
+"""
+配置路由模块
+"""
+
+from typing import Any, Dict, List
+
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import RedirectResponse
+from pydantic import BaseModel, Field
+
+from app.core.security import verify_auth_token
+from app.log.logger import Logger, get_config_routes_logger
+from app.service.config.config_service import ConfigService
+from app.service.proxy.proxy_check_service import get_proxy_check_service, ProxyCheckResult
+from app.utils.helpers import redact_key_for_logging
+
+router = APIRouter(prefix="/api/config", tags=["config"])
+
+logger = get_config_routes_logger()
+
+
+@router.get("", response_model=Dict[str, Any])
+async def get_config(request: Request):
+    auth_token = request.cookies.get("auth_token")
+    if not auth_token or not verify_auth_token(auth_token):
+        logger.warning("Unauthorized access attempt to config page")
+        return RedirectResponse(url="/", status_code=302)
+    return await ConfigService.get_config()
+
+
+@router.put("", response_model=Dict[str, Any])
+async def update_config(config_data: Dict[str, Any], request: Request):
+    auth_token = request.cookies.get("auth_token")
+    if not auth_token or not verify_auth_token(auth_token):
+        logger.warning("Unauthorized access attempt to config page")
+        return RedirectResponse(url="/", status_code=302)
+    try:
+        result = await ConfigService.update_config(config_data)
+        # 配置更新成功后，立即更新所有 logger 的级别
+        Logger.update_log_levels(config_data["LOG_LEVEL"])
+        logger.info("Log levels updated after configuration change.")
+        return result
+    except Exception as e:
+        logger.error(f"Error updating config or log levels: {e}", exc_info=True)
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.post("/reset", response_model=Dict[str, Any])
+async def reset_config(request: Request):
+    auth_token = request.cookies.get("auth_token")
+    if not auth_token or not verify_auth_token(auth_token):
+        logger.warning("Unauthorized access attempt to config page")
+        return RedirectResponse(url="/", status_code=302)
+    try:
+        return await ConfigService.reset_config()
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+class DeleteKeysRequest(BaseModel):
+    keys: List[str] = Field(..., description="List of API keys to delete")
+
+
+@router.delete("/keys/{key_to_delete}", response_model=Dict[str, Any])
+async def delete_single_key(key_to_delete: str, request: Request):
+    auth_token = request.cookies.get("auth_token")
+    if not auth_token or not verify_auth_token(auth_token):
+        logger.warning(f"Unauthorized attempt to delete key: {redact_key_for_logging(key_to_delete)}")
+        return RedirectResponse(url="/", status_code=302)
+    try:
+        logger.info(f"Attempting to delete key: {redact_key_for_logging(key_to_delete)}")
+        result = await ConfigService.delete_key(key_to_delete)
+        if not result.get("success"):
+            raise HTTPException(
+                status_code=(
+                    404 if "not found" in result.get("message", "").lower() else 400
+                ),
+                detail=result.get("message"),
+            )
+        return result
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        logger.error(f"Error deleting key '{redact_key_for_logging(key_to_delete)}': {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Error deleting key: {str(e)}")
+
+
+@router.post("/keys/delete-selected", response_model=Dict[str, Any])
+async def delete_selected_keys_route(
+    delete_request: DeleteKeysRequest, request: Request
+):
+    auth_token = request.cookies.get("auth_token")
+    if not auth_token or not verify_auth_token(auth_token):
+        logger.warning("Unauthorized attempt to bulk delete keys")
+        return RedirectResponse(url="/", status_code=302)
+
+    if not delete_request.keys:
+        logger.warning("Attempt to bulk delete keys with an empty list.")
+        raise HTTPException(status_code=400, detail="No keys provided for deletion.")
+
+    try:
+        logger.info(f"Attempting to bulk delete {len(delete_request.keys)} keys.")
+        result = await ConfigService.delete_selected_keys(delete_request.keys)
+        if not result.get("success") and result.get("deleted_count", 0) == 0:
+            raise HTTPException(
+                status_code=400, detail=result.get("message", "Failed to delete keys.")
+            )
+        return result
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        logger.error(f"Error bulk deleting keys: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500, detail=f"Error bulk deleting keys: {str(e)}"
+        )
+
+
+@router.get("/ui/models")
+async def get_ui_models(request: Request):
+    auth_token_cookie = request.cookies.get("auth_token")
+    if not auth_token_cookie or not verify_auth_token(auth_token_cookie):
+        logger.warning("Unauthorized access attempt to /api/config/ui/models")
+        raise HTTPException(status_code=403, detail="Not authenticated")
+
+    try:
+        models = await ConfigService.fetch_ui_models()
+        return models
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        logger.error(f"Unexpected error in /ui/models endpoint: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500,
+            detail=f"An unexpected error occurred while fetching UI models: {str(e)}",
+        )
+
+
+class ProxyCheckRequest(BaseModel):
+    """Proxy check request"""
+    proxy: str = Field(..., description="Proxy address to check")
+    use_cache: bool = Field(True, description="Whether to use cached results")
+
+
+class ProxyBatchCheckRequest(BaseModel):
+    """Batch proxy check request"""
+    proxies: List[str] = Field(..., description="List of proxy addresses to check")
+    use_cache: bool = Field(True, description="Whether to use cached results")
+    max_concurrent: int = Field(5, description="Maximum concurrent check count", ge=1, le=10)
+
+
+@router.post("/proxy/check", response_model=ProxyCheckResult)
+async def check_single_proxy(proxy_request: ProxyCheckRequest, request: Request):
+    """Check if a single proxy is available"""
+    auth_token = request.cookies.get("auth_token")
+    if not auth_token or not verify_auth_token(auth_token):
+        logger.warning("Unauthorized access attempt to proxy check")
+        return RedirectResponse(url="/", status_code=302)
+    
+    try:
+        logger.info(f"Checking single proxy: {proxy_request.proxy}")
+        proxy_service = get_proxy_check_service()
+        result = await proxy_service.check_single_proxy(
+            proxy_request.proxy, 
+            proxy_request.use_cache
+        )
+        return result
+    except Exception as e:
+        logger.error(f"Proxy check failed: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Proxy check failed: {str(e)}")
+
+
+@router.post("/proxy/check-all", response_model=List[ProxyCheckResult])
+async def check_all_proxies(batch_request: ProxyBatchCheckRequest, request: Request):
+    """Check multiple proxies availability"""
+    auth_token = request.cookies.get("auth_token")
+    if not auth_token or not verify_auth_token(auth_token):
+        logger.warning("Unauthorized access attempt to batch proxy check")
+        return RedirectResponse(url="/", status_code=302)
+    
+    try:
+        logger.info(f"Batch checking {len(batch_request.proxies)} proxies")
+        proxy_service = get_proxy_check_service()
+        results = await proxy_service.check_multiple_proxies(
+            batch_request.proxies,
+            batch_request.use_cache,
+            batch_request.max_concurrent
+        )
+        return results
+    except Exception as e:
+        logger.error(f"Batch proxy check failed: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Batch proxy check failed: {str(e)}")
+
+
+@router.get("/proxy/cache-stats")
+async def get_proxy_cache_stats(request: Request):
+    """Get proxy check cache statistics"""
+    auth_token = request.cookies.get("auth_token")
+    if not auth_token or not verify_auth_token(auth_token):
+        logger.warning("Unauthorized access attempt to proxy cache stats")
+        return RedirectResponse(url="/", status_code=302)
+    
+    try:
+        proxy_service = get_proxy_check_service()
+        stats = proxy_service.get_cache_stats()
+        return stats
+    except Exception as e:
+        logger.error(f"Get proxy cache stats failed: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Get cache stats failed: {str(e)}")
+
+
+@router.post("/proxy/clear-cache")
+async def clear_proxy_cache(request: Request):
+    """Clear proxy check cache"""
+    auth_token = request.cookies.get("auth_token")
+    if not auth_token or not verify_auth_token(auth_token):
+        logger.warning("Unauthorized access attempt to clear proxy cache")
+        return RedirectResponse(url="/", status_code=302)
+    
+    try:
+        proxy_service = get_proxy_check_service()
+        proxy_service.clear_cache()
+        return {"success": True, "message": "Proxy check cache cleared"}
+    except Exception as e:
+        logger.error(f"Clear proxy cache failed: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Clear cache failed: {str(e)}")

app/router/error_log_routes.py

@@ -0,0 +1,271 @@
+"""
+日志路由模块
+"""
+
+from datetime import datetime
+from typing import Dict, List, Optional
+
+from fastapi import (
+    APIRouter,
+    Body,
+    HTTPException,
+    Path,
+    Query,
+    Request,
+    Response,
+    status,
+)
+from pydantic import BaseModel
+
+from app.core.security import verify_auth_token
+from app.log.logger import get_log_routes_logger
+from app.service.error_log import error_log_service
+
+router = APIRouter(prefix="/api/logs", tags=["logs"])
+
+logger = get_log_routes_logger()
+
+
+class ErrorLogListItem(BaseModel):
+    id: int
+    gemini_key: Optional[str] = None
+    error_type: Optional[str] = None
+    error_code: Optional[int] = None
+    model_name: Optional[str] = None
+    request_time: Optional[datetime] = None
+
+
+class ErrorLogListResponse(BaseModel):
+    logs: List[ErrorLogListItem]
+    total: int
+
+
+@router.get("/errors", response_model=ErrorLogListResponse)
+async def get_error_logs_api(
+    request: Request,
+    limit: int = Query(10, ge=1, le=1000),
+    offset: int = Query(0, ge=0),
+    key_search: Optional[str] = Query(
+        None, description="Search term for Gemini key (partial match)"
+    ),
+    error_search: Optional[str] = Query(
+        None, description="Search term for error type or log message"
+    ),
+    error_code_search: Optional[str] = Query(
+        None, description="Search term for error code"
+    ),
+    start_date: Optional[datetime] = Query(
+        None, description="Start datetime for filtering"
+    ),
+    end_date: Optional[datetime] = Query(
+        None, description="End datetime for filtering"
+    ),
+    sort_by: str = Query(
+        "id", description="Field to sort by (e.g., 'id', 'request_time')"
+    ),
+    sort_order: str = Query("desc", description="Sort order ('asc' or 'desc')"),
+):
+    """
+    获取错误日志列表 (返回错误码)，支持过滤和排序
+
+    Args:
+        request: 请求对象
+        limit: 限制数量
+        offset: 偏移量
+        key_search: 密钥搜索
+        error_search: 错误搜索 (可能搜索类型或日志内容，由DB层决定)
+        error_code_search: 错误码搜索
+        start_date: 开始日期
+        end_date: 结束日期
+        sort_by: 排序字段
+        sort_order: 排序顺序
+
+    Returns:
+        ErrorLogListResponse: An object containing the list of logs (with error_code) and the total count.
+    """
+    auth_token = request.cookies.get("auth_token")
+    if not auth_token or not verify_auth_token(auth_token):
+        logger.warning("Unauthorized access attempt to error logs list")
+        raise HTTPException(status_code=401, detail="Not authenticated")
+
+    try:
+        result = await error_log_service.process_get_error_logs(
+            limit=limit,
+            offset=offset,
+            key_search=key_search,
+            error_search=error_search,
+            error_code_search=error_code_search,
+            start_date=start_date,
+            end_date=end_date,
+            sort_by=sort_by,
+            sort_order=sort_order,
+        )
+        logs_data = result["logs"]
+        total_count = result["total"]
+
+        validated_logs = [ErrorLogListItem(**log) for log in logs_data]
+        return ErrorLogListResponse(logs=validated_logs, total=total_count)
+    except Exception as e:
+        logger.exception(f"Failed to get error logs list: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Failed to get error logs list: {str(e)}"
+        )
+
+
+class ErrorLogDetailResponse(BaseModel):
+    id: int
+    gemini_key: Optional[str] = None
+    error_type: Optional[str] = None
+    error_log: Optional[str] = None
+    request_msg: Optional[str] = None
+    model_name: Optional[str] = None
+    request_time: Optional[datetime] = None
+    error_code: Optional[int] = None
+
+
+@router.get("/errors/{log_id}/details", response_model=ErrorLogDetailResponse)
+async def get_error_log_detail_api(request: Request, log_id: int = Path(..., ge=1)):
+    """
+    根据日志 ID 获取错误日志的详细信息 (包括 error_log 和 request_msg)
+    """
+    auth_token = request.cookies.get("auth_token")
+    if not auth_token or not verify_auth_token(auth_token):
+        logger.warning(
+            f"Unauthorized access attempt to error log details for ID: {log_id}"
+        )
+        raise HTTPException(status_code=401, detail="Not authenticated")
+
+    try:
+        log_details = await error_log_service.process_get_error_log_details(
+            log_id=log_id
+        )
+        if not log_details:
+            raise HTTPException(status_code=404, detail="Error log not found")
+
+        return ErrorLogDetailResponse(**log_details)
+    except HTTPException as http_exc:
+        raise http_exc
+    except Exception as e:
+        logger.exception(f"Failed to get error log details for ID {log_id}: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Failed to get error log details: {str(e)}"
+        )
+
+
+@router.get("/errors/lookup", response_model=ErrorLogDetailResponse)
+async def lookup_error_log_by_info(
+    request: Request,
+    gemini_key: str = Query(..., description="完整的 Gemini key"),
+    timestamp: datetime = Query(..., description="请求时间 (ISO8601)"),
+    status_code: Optional[int] = Query(None, description="错误码 (可选)"),
+    window_seconds: int = Query(
+        100, ge=1, le=300, description="时间窗口(秒), 默认100秒"
+    ),
+):
+    """
+    通过 key / 错误码 / 时间窗口 查找最匹配的一条错误日志详情。
+    """
+    auth_token = request.cookies.get("auth_token")
+    if not auth_token or not verify_auth_token(auth_token):
+        logger.warning("Unauthorized access attempt to lookup error log by info")
+        raise HTTPException(status_code=401, detail="Not authenticated")
+
+    try:
+        detail = await error_log_service.process_find_error_log_by_info(
+            gemini_key=gemini_key,
+            timestamp=timestamp,
+            status_code=status_code,
+            window_seconds=window_seconds,
+        )
+        if not detail:
+            raise HTTPException(status_code=404, detail="No matching error log found")
+        return ErrorLogDetailResponse(**detail)
+    except HTTPException as http_exc:
+        raise http_exc
+    except Exception as e:
+        logger.exception(
+            f"Failed to lookup error log by info for key=***{gemini_key[-4:] if gemini_key else ''}: {str(e)}"
+        )
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+
+@router.delete("/errors", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_error_logs_bulk_api(
+    request: Request, payload: Dict[str, List[int]] = Body(...)
+):
+    """
+    批量删除错误日志 (异步)
+    """
+    auth_token = request.cookies.get("auth_token")
+    if not auth_token or not verify_auth_token(auth_token):
+        logger.warning("Unauthorized access attempt to bulk delete error logs")
+        raise HTTPException(status_code=401, detail="Not authenticated")
+
+    log_ids = payload.get("ids")
+    if not log_ids:
+        raise HTTPException(status_code=400, detail="No log IDs provided for deletion.")
+
+    try:
+        deleted_count = await error_log_service.process_delete_error_logs_by_ids(
+            log_ids
+        )
+        # 注意：异步函数返回的是尝试删除的数量，可能不是精确值
+        logger.info(
+            f"Attempted bulk deletion for {deleted_count} error logs with IDs: {log_ids}"
+        )
+        return Response(status_code=status.HTTP_204_NO_CONTENT)
+    except Exception as e:
+        logger.exception(f"Error bulk deleting error logs with IDs {log_ids}: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail="Internal server error during bulk deletion"
+        )
+
+
+@router.delete("/errors/all", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_all_error_logs_api(request: Request):
+    """
+    删除所有错误日志 (异步)
+    """
+    auth_token = request.cookies.get("auth_token")
+    if not auth_token or not verify_auth_token(auth_token):
+        logger.warning("Unauthorized access attempt to delete all error logs")
+        raise HTTPException(status_code=401, detail="Not authenticated")
+
+    try:
+        await error_log_service.process_delete_all_error_logs()
+        logger.info("Successfully deleted all error logs.")
+        # No body needed for 204 response
+        return Response(status_code=status.HTTP_204_NO_CONTENT)
+    except Exception as e:
+        logger.exception(f"Error deleting all error logs: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail="Internal server error during deletion of all logs"
+        )
+
+
+@router.delete("/errors/{log_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_error_log_api(request: Request, log_id: int = Path(..., ge=1)):
+    """
+    删除单个错误日志 (异步)
+    """
+    auth_token = request.cookies.get("auth_token")
+    if not auth_token or not verify_auth_token(auth_token):
+        logger.warning(f"Unauthorized access attempt to delete error log ID: {log_id}")
+        raise HTTPException(status_code=401, detail="Not authenticated")
+
+    try:
+        success = await error_log_service.process_delete_error_log_by_id(log_id)
+        if not success:
+            # 服务层现在在未找到时返回 False，我们在这里转换为 404
+            raise HTTPException(
+                status_code=404, detail=f"Error log with ID {log_id} not found"
+            )
+        logger.info(f"Successfully deleted error log with ID: {log_id}")
+        return Response(status_code=status.HTTP_204_NO_CONTENT)
+    except HTTPException as http_exc:
+        raise http_exc
+    except Exception as e:
+        logger.exception(f"Error deleting error log with ID {log_id}: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail="Internal server error during deletion"
+        )

app/router/files_routes.py

@@ -0,0 +1,296 @@
+"""
+Files API 路由
+"""
+from typing import Optional
+from fastapi import APIRouter, Request, Query, Depends, Header, HTTPException
+from fastapi.responses import JSONResponse
+
+from app.config.config import settings
+from app.domain.file_models import (
+    FileMetadata, 
+    ListFilesResponse, 
+    DeleteFileResponse
+)
+from app.log.logger import get_files_logger
+from app.core.security import SecurityService
+from app.service.files.files_service import get_files_service
+from app.service.files.file_upload_handler import get_upload_handler
+from app.utils.helpers import redact_key_for_logging
+
+logger = get_files_logger()
+
+router = APIRouter()
+security_service = SecurityService()
+
+
+@router.post("/upload/v1beta/files")
+async def upload_file_init(
+    request: Request,
+    auth_token: str = Depends(security_service.verify_key_or_goog_api_key),
+    x_goog_upload_protocol: Optional[str] = Header(None),
+    x_goog_upload_command: Optional[str] = Header(None),
+    x_goog_upload_header_content_length: Optional[str] = Header(None),
+    x_goog_upload_header_content_type: Optional[str] = Header(None),
+):
+    """初始化文件上传"""
+    logger.debug(f"Upload file request: {request.method=}, {request.url=}, {auth_token=}, {x_goog_upload_protocol=}, {x_goog_upload_command=}, {x_goog_upload_header_content_length=}, {x_goog_upload_header_content_type=}")
+    
+    # 檢查是否是實際的上傳請求（有 upload_id）
+    if request.query_params.get("upload_id") and x_goog_upload_command in ["upload", "upload, finalize"]:
+        logger.debug("This is an upload request, not initialization. Redirecting to handle_upload.")
+        return await handle_upload(
+            upload_path="v1beta/files",
+            request=request,
+            key=request.query_params.get("key"),
+            auth_token=auth_token
+        )
+    
+    try:
+        # 使用认证 token 作为 user_token
+        user_token = auth_token
+        # 获取请求体
+        body = await request.body()
+        
+        # 构建请求主机 URL
+        request_host = f"{request.url.scheme}://{request.url.netloc}"
+        logger.info(f"Request host: {request_host}")
+        
+        # 准备请求头
+        headers = {
+            "x-goog-upload-protocol": x_goog_upload_protocol or "resumable",
+            "x-goog-upload-command": x_goog_upload_command or "start",
+        }
+        
+        if x_goog_upload_header_content_length:
+            headers["x-goog-upload-header-content-length"] = x_goog_upload_header_content_length
+        if x_goog_upload_header_content_type:
+            headers["x-goog-upload-header-content-type"] = x_goog_upload_header_content_type
+        
+        # 调用服务
+        files_service = await get_files_service()
+        response_data, response_headers = await files_service.initialize_upload(
+            headers=headers,
+            body=body,
+            user_token=user_token,
+            request_host=request_host  # 傳遞請求主機
+        )
+
+        logger.info(f"Upload initialization response: {response_data}")
+        logger.info(f"Upload initialization response headers: {response_headers}")
+        
+        logger.info(f"Upload initialization response headers: {response_data}")
+        # 返回响应
+        return JSONResponse(
+            content=response_data,
+            headers=response_headers
+        )
+        
+    except HTTPException as e:
+        logger.error(f"Upload initialization failed: {e.detail}")
+        return JSONResponse(
+            content={"error": {"message": e.detail}},
+            status_code=e.status_code
+        )
+    except Exception as e:
+        logger.error(f"Unexpected error in upload initialization: {str(e)}")
+        return JSONResponse(
+            content={"error": {"message": "Internal server error"}},
+            status_code=500
+        )
+
+
+@router.get("/v1beta/files")
+async def list_files(
+    page_size: int = Query(10, ge=1, le=100, description="每页大小", alias="pageSize"),
+    page_token: Optional[str] = Query(None, description="分页标记", alias="pageToken"),
+    auth_token: str = Depends(security_service.verify_key_or_goog_api_key)
+) -> ListFilesResponse:
+    """列出文件"""
+    logger.debug(f"List files: {page_size=}, {page_token=}, {auth_token=}")
+    try:
+        # 使用认证 token 作为 user_token（如果启用用户隔离）
+        user_token = auth_token if settings.FILES_USER_ISOLATION_ENABLED else None
+        # 调用服务
+        files_service = await get_files_service()
+        return await files_service.list_files(
+            page_size=page_size,
+            page_token=page_token,
+            user_token=user_token
+        )
+        
+    except HTTPException as e:
+        logger.error(f"List files failed: {e.detail}")
+        return JSONResponse(
+            content={"error": {"message": e.detail}},
+            status_code=e.status_code
+        )
+    except Exception as e:
+        logger.error(f"Unexpected error in list files: {str(e)}")
+        return JSONResponse(
+            content={"error": {"message": "Internal server error"}},
+            status_code=500
+        )
+
+
+@router.get("/v1beta/files/{file_id:path}")
+async def get_file(
+    file_id: str,
+    auth_token: str = Depends(security_service.verify_key_or_goog_api_key)
+) -> FileMetadata:
+    """获取文件信息"""
+    logger.debug(f"Get file request: {file_id=}, {auth_token=}")
+    try:
+        # 使用认证 token 作为 user_token
+        user_token = auth_token
+        # 调用服务
+        files_service = await get_files_service()
+        return await files_service.get_file(f"files/{file_id}", user_token)
+        
+    except HTTPException as e:
+        logger.error(f"Get file failed: {e.detail}")
+        return JSONResponse(
+            content={"error": {"message": e.detail}},
+            status_code=e.status_code
+        )
+    except Exception as e:
+        logger.error(f"Unexpected error in get file: {str(e)}")
+        return JSONResponse(
+            content={"error": {"message": "Internal server error"}},
+            status_code=500
+        )
+
+
+@router.delete("/v1beta/files/{file_id:path}")
+async def delete_file(
+    file_id: str,
+    auth_token: str = Depends(security_service.verify_key_or_goog_api_key)
+) -> DeleteFileResponse:
+    """删除文件"""
+    logger.info(f"Delete file: {file_id=}, {auth_token=}")
+    try:
+        # 使用认证 token 作为 user_token
+        user_token = auth_token
+        # 调用服务
+        files_service = await get_files_service()
+        success = await files_service.delete_file(f"files/{file_id}", user_token)
+        
+        return DeleteFileResponse(
+            success=success,
+            message="File deleted successfully" if success else "Failed to delete file"
+        )
+        
+    except HTTPException as e:
+        logger.error(f"Delete file failed: {e.detail}")
+        return JSONResponse(
+            content={"error": {"message": e.detail}},
+            status_code=e.status_code
+        )
+    except Exception as e:
+        logger.error(f"Unexpected error in delete file: {str(e)}")
+        return JSONResponse(
+            content={"error": {"message": "Internal server error"}},
+            status_code=500
+        )
+
+
+# 处理上传请求的通配符路由
+@router.api_route("/upload/{upload_path:path}", methods=["GET", "POST", "PUT"])
+async def handle_upload(
+    upload_path: str,
+    request: Request,
+    key: Optional[str] = Query(None),  # 從查詢參數獲取 key
+    auth_token: str = Depends(security_service.verify_key_or_goog_api_key)
+):
+    """处理文件上传请求"""
+    try:
+        logger.info(f"Handling upload request: {request.method} {upload_path}, key={redact_key_for_logging(key)}")
+        
+        # 從查詢參數獲取 upload_id
+        upload_id = request.query_params.get("upload_id")
+        if not upload_id:
+            raise HTTPException(status_code=400, detail="Missing upload_id")
+        
+        # 從 session 獲取真實的 API key
+        files_service = await get_files_service()
+        session_info = await files_service.get_upload_session(upload_id)
+        if not session_info:
+            logger.error(f"No session found for upload_id: {upload_id}")
+            raise HTTPException(status_code=404, detail="Upload session not found")
+        
+        real_api_key = session_info["api_key"]
+        original_upload_url = session_info["upload_url"]
+        
+        # 使用真實的 API key 構建完整的 Google 上傳 URL
+        # 保留原始 URL 的所有參數，但使用真實的 API key
+        upload_url = original_upload_url
+        logger.info(f"Using real API key for upload: {redact_key_for_logging(real_api_key)}")
+        
+        # 代理上传请求
+        upload_handler = get_upload_handler()
+        return await upload_handler.proxy_upload_request(
+            request=request,
+            upload_url=upload_url,
+            files_service=files_service
+        )
+        
+    except HTTPException as e:
+        logger.error(f"Upload handling failed: {e.detail}")
+        return JSONResponse(
+            content={"error": {"message": e.detail}},
+            status_code=e.status_code
+        )
+    except Exception as e:
+        logger.error(f"Unexpected error in upload handling: {str(e)}")
+        return JSONResponse(
+            content={"error": {"message": "Internal server error"}},
+            status_code=500
+        )
+
+
+# 为兼容性添加 /gemini 前缀的路由
+@router.post("/gemini/upload/v1beta/files")
+async def gemini_upload_file_init(
+    request: Request,
+    auth_token: str = Depends(security_service.verify_key_or_goog_api_key),
+    x_goog_upload_protocol: Optional[str] = Header(None),
+    x_goog_upload_command: Optional[str] = Header(None),
+    x_goog_upload_header_content_length: Optional[str] = Header(None),
+    x_goog_upload_header_content_type: Optional[str] = Header(None),
+):
+    """初始化文件上传（Gemini 前缀）"""
+    return await upload_file_init(
+        request,
+        auth_token,
+        x_goog_upload_protocol,
+        x_goog_upload_command,
+        x_goog_upload_header_content_length,
+        x_goog_upload_header_content_type
+    )
+
+
+@router.get("/gemini/v1beta/files")
+async def gemini_list_files(
+    page_size: int = Query(10, ge=1, le=100, alias="pageSize"),
+    page_token: Optional[str] = Query(None, alias="pageToken"),
+    auth_token: str = Depends(security_service.verify_key_or_goog_api_key)
+) -> ListFilesResponse:
+    """列出文件（Gemini 前缀）"""
+    return await list_files(page_size, page_token, auth_token)
+
+
+@router.get("/gemini/v1beta/files/{file_id:path}")
+async def gemini_get_file(
+    file_id: str,
+    auth_token: str = Depends(security_service.verify_key_or_goog_api_key)
+) -> FileMetadata:
+    """获取文件信息（Gemini 前缀）"""
+    return await get_file(file_id, auth_token)
+
+
+@router.delete("/gemini/v1beta/files/{file_id:path}")
+async def gemini_delete_file(
+    file_id: str,
+    auth_token: str = Depends(security_service.verify_key_or_goog_api_key)
+) -> DeleteFileResponse:
+    """删除文件（Gemini 前缀）"""
+    return await delete_file(file_id, auth_token)

app/router/gemini_routes.py

@@ -0,0 +1,502 @@
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import StreamingResponse, JSONResponse
+from copy import deepcopy
+import asyncio
+from app.config.config import settings
+from app.log.logger import get_gemini_logger
+from app.core.security import SecurityService
+from app.domain.gemini_models import GeminiContent, GeminiRequest, ResetSelectedKeysRequest, VerifySelectedKeysRequest, GeminiEmbedRequest, GeminiBatchEmbedRequest
+from app.service.chat.gemini_chat_service import GeminiChatService
+from app.service.embedding.gemini_embedding_service import GeminiEmbeddingService
+from app.service.key.key_manager import KeyManager, get_key_manager_instance
+from app.service.tts.native.tts_routes import get_tts_chat_service
+from app.service.model.model_service import ModelService
+from app.handler.retry_handler import RetryHandler
+from app.handler.error_handler import handle_route_errors
+from app.core.constants import API_VERSION
+from app.utils.helpers import redact_key_for_logging
+
+router = APIRouter(prefix=f"/gemini/{API_VERSION}")
+router_v1beta = APIRouter(prefix=f"/{API_VERSION}")
+logger = get_gemini_logger()
+
+security_service = SecurityService()
+model_service = ModelService()
+
+
+async def get_key_manager():
+    """获取密钥管理器实例"""
+    return await get_key_manager_instance()
+
+
+async def get_next_working_key(key_manager: KeyManager = Depends(get_key_manager)):
+    """获取下一个可用的API密钥"""
+    return await key_manager.get_next_working_key()
+
+
+async def get_chat_service(key_manager: KeyManager = Depends(get_key_manager)):
+    """获取Gemini聊天服务实例"""
+    return GeminiChatService(settings.BASE_URL, key_manager)
+
+
+async def get_embedding_service(key_manager: KeyManager = Depends(get_key_manager)):
+    """获取Gemini嵌入服务实例"""
+    return GeminiEmbeddingService(settings.BASE_URL, key_manager)
+
+
+@router.get("/models")
+@router_v1beta.get("/models")
+async def list_models(
+    _=Depends(security_service.verify_key_or_goog_api_key),
+    key_manager: KeyManager = Depends(get_key_manager)
+):
+    """获取可用的 Gemini 模型列表，并根据配置添加衍生模型（搜索、图像、非思考）。"""
+    operation_name = "list_gemini_models"
+    logger.info("-" * 50 + operation_name + "-" * 50)
+    logger.info("Handling Gemini models list request")
+
+    try:
+        api_key = await key_manager.get_random_valid_key()
+        if not api_key:
+            raise HTTPException(status_code=503, detail="No valid API keys available to fetch models.")
+        logger.info(f"Using API key: {redact_key_for_logging(api_key)}")
+
+        models_data = await model_service.get_gemini_models(api_key)
+        if not models_data or "models" not in models_data:
+            raise HTTPException(status_code=500, detail="Failed to fetch base models list.")
+
+        models_json = deepcopy(models_data)
+        model_mapping = {x.get("name", "").split("/", maxsplit=1)[-1]: x for x in models_json.get("models", [])}
+
+        def add_derived_model(base_name, suffix, display_suffix):
+            model = model_mapping.get(base_name)
+            if not model:
+                logger.warning(f"Base model '{base_name}' not found for derived model '{suffix}'.")
+                return
+            item = deepcopy(model)
+            item["name"] = f"models/{base_name}{suffix}"
+            display_name = f'{item.get("displayName", base_name)}{display_suffix}'
+            item["displayName"] = display_name
+            item["description"] = display_name
+            models_json["models"].append(item)
+
+        if settings.SEARCH_MODELS:
+            for name in settings.SEARCH_MODELS:
+                add_derived_model(name, "-search", " For Search")
+        if settings.IMAGE_MODELS:
+            for name in settings.IMAGE_MODELS:
+                 add_derived_model(name, "-image", " For Image")
+        if settings.THINKING_MODELS:
+            for name in settings.THINKING_MODELS:
+                add_derived_model(name, "-non-thinking", " Non Thinking")
+
+        logger.info("Gemini models list request successful")
+        return models_json
+    except HTTPException as http_exc:
+        raise http_exc
+    except Exception as e:
+        logger.error(f"Error getting Gemini models list: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail="Internal server error while fetching Gemini models list"
+        ) from e
+
+
+@router.post("/models/{model_name}:generateContent")
+@router_v1beta.post("/models/{model_name}:generateContent")
+@RetryHandler(key_arg="api_key")
+async def generate_content(
+    model_name: str,
+    request: GeminiRequest,
+    _=Depends(security_service.verify_key_or_goog_api_key),
+    api_key: str = Depends(get_next_working_key),
+    key_manager: KeyManager = Depends(get_key_manager),
+    chat_service: GeminiChatService = Depends(get_chat_service)
+):
+    """处理 Gemini 非流式内容生成请求。"""
+    operation_name = "gemini_generate_content"
+    async with handle_route_errors(logger, operation_name, failure_message="Content generation failed"):
+        logger.info(f"Handling Gemini content generation request for model: {model_name}")
+        logger.debug(f"Request: \n{request.model_dump_json(indent=2)}")
+
+        # 检测是否为原生Gemini TTS请求
+        is_native_tts = False
+        if "tts" in model_name.lower() and request.generationConfig:
+            # 直接从解析后的request对象获取TTS配置
+            response_modalities = request.generationConfig.responseModalities or []
+            speech_config = request.generationConfig.speechConfig or {}
+
+            # 如果包含AUDIO模态和语音配置，则认为是原生TTS请求
+            if "AUDIO" in response_modalities and speech_config:
+                is_native_tts = True
+                logger.info("Detected native Gemini TTS request")
+                logger.info(f"TTS responseModalities: {response_modalities}")
+                logger.info(f"TTS speechConfig: {speech_config}")
+
+        logger.info(f"Using API key: {redact_key_for_logging(api_key)}")
+
+        if not await model_service.check_model_support(model_name):
+            raise HTTPException(status_code=400, detail=f"Model {model_name} is not supported")
+
+        # 所有原生TTS请求都使用TTS增强服务
+        if is_native_tts:
+            try:
+                logger.info("Using native TTS enhanced service")
+                tts_service = await get_tts_chat_service(key_manager)
+                response = await tts_service.generate_content(
+                    model=model_name,
+                    request=request,
+                    api_key=api_key
+                )
+                return response
+            except Exception as e:
+                logger.warning(f"Native TTS processing failed, falling back to standard service: {e}")
+
+        # 使用标准服务处理所有其他请求（非TTS）
+        response = await chat_service.generate_content(
+            model=model_name,
+            request=request,
+            api_key=api_key
+        )
+        return response
+
+
+@router.post("/models/{model_name}:streamGenerateContent")
+@router_v1beta.post("/models/{model_name}:streamGenerateContent")
+@RetryHandler(key_arg="api_key")
+async def stream_generate_content(
+    model_name: str,
+    request: GeminiRequest,
+    _=Depends(security_service.verify_key_or_goog_api_key),
+    api_key: str = Depends(get_next_working_key),
+    key_manager: KeyManager = Depends(get_key_manager),
+    chat_service: GeminiChatService = Depends(get_chat_service)
+):
+    """处理 Gemini 流式内容生成请求。"""
+    operation_name = "gemini_stream_generate_content"
+    async with handle_route_errors(logger, operation_name, failure_message="Streaming request initiation failed"):
+        logger.info(f"Handling Gemini streaming content generation for model: {model_name}")
+        logger.debug(f"Request: \n{request.model_dump_json(indent=2)}")
+        logger.info(f"Using API key: {redact_key_for_logging(api_key)}")
+
+        if not await model_service.check_model_support(model_name):
+            raise HTTPException(status_code=400, detail=f"Model {model_name} is not supported")
+
+        response_stream = chat_service.stream_generate_content(
+            model=model_name,
+            request=request,
+            api_key=api_key
+        )
+        return StreamingResponse(response_stream, media_type="text/event-stream")
+
+
+@router.post("/models/{model_name}:countTokens")
+@router_v1beta.post("/models/{model_name}:countTokens")
+@RetryHandler(key_arg="api_key")
+async def count_tokens(
+    model_name: str,
+    request: GeminiRequest,
+    _=Depends(security_service.verify_key_or_goog_api_key),
+    api_key: str = Depends(get_next_working_key),
+    key_manager: KeyManager = Depends(get_key_manager),
+    chat_service: GeminiChatService = Depends(get_chat_service)
+):
+    """处理 Gemini token 计数请求。"""
+    operation_name = "gemini_count_tokens"
+    async with handle_route_errors(logger, operation_name, failure_message="Token counting failed"):
+        logger.info(f"Handling Gemini token count request for model: {model_name}")
+        logger.debug(f"Request: \n{request.model_dump_json(indent=2)}")
+        logger.info(f"Using API key: {redact_key_for_logging(api_key)}")
+
+        if not await model_service.check_model_support(model_name):
+            raise HTTPException(status_code=400, detail=f"Model {model_name} is not supported")
+
+        response = await chat_service.count_tokens(
+            model=model_name,
+            request=request,
+            api_key=api_key
+        )
+        return response
+    
+@router.post("/models/{model_name}:embedContent")
+@router_v1beta.post("/models/{model_name}:embedContent")
+@RetryHandler(key_arg="api_key")
+async def embed_content(
+    model_name: str,
+    request: GeminiEmbedRequest,
+    _=Depends(security_service.verify_key_or_goog_api_key),
+    api_key: str = Depends(get_next_working_key),
+    key_manager: KeyManager = Depends(get_key_manager),
+    embedding_service: GeminiEmbeddingService = Depends(get_embedding_service)
+):
+    """处理 Gemini 单一嵌入请求"""
+    operation_name = "gemini_embed_content"
+    async with handle_route_errors(logger, operation_name, failure_message="Embedding content generation failed"):
+        logger.info(f"Handling Gemini embedding request for model: {model_name}")
+        logger.debug(f"Request: \n{request.model_dump_json(indent=2)}")
+        logger.info(f"Using API key: {redact_key_for_logging(api_key)}")
+
+        if not await model_service.check_model_support(model_name):
+            raise HTTPException(status_code=400, detail=f"Model {model_name} is not supported")
+
+        response = await embedding_service.embed_content(
+            model=model_name,
+            request=request,
+            api_key=api_key
+        )
+        return response
+
+
+@router.post("/models/{model_name}:batchEmbedContents")
+@router_v1beta.post("/models/{model_name}:batchEmbedContents")
+@RetryHandler(key_arg="api_key")
+async def batch_embed_contents(
+    model_name: str,
+    request: GeminiBatchEmbedRequest,
+    _=Depends(security_service.verify_key_or_goog_api_key),
+    api_key: str = Depends(get_next_working_key),
+    key_manager: KeyManager = Depends(get_key_manager),
+    embedding_service: GeminiEmbeddingService = Depends(get_embedding_service)
+):
+    """处理 Gemini 批量嵌入请求"""
+    operation_name = "gemini_batch_embed_contents"
+    async with handle_route_errors(logger, operation_name, failure_message="Batch embedding content generation failed"):
+        logger.info(f"Handling Gemini batch embedding request for model: {model_name}")
+        logger.debug(f"Request: \n{request.model_dump_json(indent=2)}")
+        logger.info(f"Using API key: {redact_key_for_logging(api_key)}")
+
+        if not await model_service.check_model_support(model_name):
+            raise HTTPException(status_code=400, detail=f"Model {model_name} is not supported")
+
+        response = await embedding_service.batch_embed_contents(
+            model=model_name,
+            request=request,
+            api_key=api_key
+        )
+        return response
+
+
+@router.post("/reset-all-fail-counts")
+async def reset_all_key_fail_counts(key_type: str = None, key_manager: KeyManager = Depends(get_key_manager)):
+    """批量重置Gemini API密钥的失败计数，可选择性地仅重置有效或无效密钥"""
+    logger.info("-" * 50 + "reset_all_gemini_key_fail_counts" + "-" * 50)
+    logger.info(f"Received reset request with key_type: {key_type}")
+    
+    try:
+        # 获取分类后的密钥
+        keys_by_status = await key_manager.get_keys_by_status()
+        valid_keys = keys_by_status.get("valid_keys", {})
+        invalid_keys = keys_by_status.get("invalid_keys", {})
+        
+        # 根据类型选择要重置的密钥
+        keys_to_reset = []
+        if key_type == "valid":
+            keys_to_reset = list(valid_keys.keys())
+            logger.info(f"Resetting only valid keys, count: {len(keys_to_reset)}")
+        elif key_type == "invalid":
+            keys_to_reset = list(invalid_keys.keys())
+            logger.info(f"Resetting only invalid keys, count: {len(keys_to_reset)}")
+        else:
+            # 重置所有密钥
+            await key_manager.reset_failure_counts()
+            return JSONResponse({"success": True, "message": "所有密钥的失败计数已重置"})
+        
+        # 批量重置指定类型的密钥
+        for key in keys_to_reset:
+            await key_manager.reset_key_failure_count(key)
+        
+        return JSONResponse({
+            "success": True,
+            "message": f"{key_type}密钥的失败计数已重置",
+            "reset_count": len(keys_to_reset)
+        })
+    except Exception as e:
+        logger.error(f"Failed to reset key failure counts: {str(e)}")
+        return JSONResponse({"success": False, "message": f"批量重置失败: {str(e)}"}, status_code=500)
+    
+    
+@router.post("/reset-selected-fail-counts")
+async def reset_selected_key_fail_counts(
+    request: ResetSelectedKeysRequest,
+    key_manager: KeyManager = Depends(get_key_manager)
+):
+    """批量重置选定Gemini API密钥的失败计数"""
+    logger.info("-" * 50 + "reset_selected_gemini_key_fail_counts" + "-" * 50)
+    keys_to_reset = request.keys
+    key_type = request.key_type
+    logger.info(f"Received reset request for {len(keys_to_reset)} selected {key_type} keys.")
+
+    if not keys_to_reset:
+        return JSONResponse({"success": False, "message": "没有提供需要重置的密钥"}, status_code=400)
+
+    reset_count = 0
+    errors = []
+
+    try:
+        for key in keys_to_reset:
+            try:
+                result = await key_manager.reset_key_failure_count(key)
+                if result:
+                    reset_count += 1
+                else:
+                    logger.warning(f"Key not found during selective reset: {redact_key_for_logging(key)}")
+            except Exception as key_error:
+                logger.error(f"Error resetting key {redact_key_for_logging(key)}: {str(key_error)}")
+                errors.append(f"Key {key}: {str(key_error)}")
+
+        if errors:
+             error_message = f"批量重置完成，但出现错误: {'; '.join(errors)}"
+             final_success = reset_count > 0
+             status_code = 207 if final_success and errors else 500
+             return JSONResponse({
+                 "success": final_success,
+                 "message": error_message,
+                 "reset_count": reset_count
+             }, status_code=status_code)
+
+        return JSONResponse({
+            "success": True,
+            "message": f"成功重置 {reset_count} 个选定 {key_type} 密钥的失败计数",
+            "reset_count": reset_count
+        })
+    except Exception as e:
+        logger.error(f"Failed to process reset selected key failure counts request: {str(e)}")
+        return JSONResponse({"success": False, "message": f"批量重置处理失败: {str(e)}"}, status_code=500)
+
+
+@router.post("/reset-fail-count/{api_key}")
+async def reset_key_fail_count(api_key: str, key_manager: KeyManager = Depends(get_key_manager)):
+    """重置指定Gemini API密钥的失败计数"""
+    logger.info("-" * 50 + "reset_gemini_key_fail_count" + "-" * 50)
+    logger.info(f"Resetting failure count for API key: {redact_key_for_logging(api_key)}")
+    
+    try:
+        result = await key_manager.reset_key_failure_count(api_key)
+        if result:
+            return JSONResponse({"success": True, "message": "失败计数已重置"})
+        return JSONResponse({"success": False, "message": "未找到指定密钥"}, status_code=404)
+    except Exception as e:
+        logger.error(f"Failed to reset key failure count: {str(e)}")
+        return JSONResponse({"success": False, "message": f"重置失败: {str(e)}"}, status_code=500)
+
+
+@router.post("/verify-key/{api_key}")
+async def verify_key(api_key: str, chat_service: GeminiChatService = Depends(get_chat_service), key_manager: KeyManager = Depends(get_key_manager)):
+    """验证Gemini API密钥的有效性"""
+    logger.info("-" * 50 + "verify_gemini_key" + "-" * 50)
+    logger.info("Verifying API key validity")
+    
+    try:
+        gemini_request = GeminiRequest(
+            contents=[
+                GeminiContent(
+                    role="user",
+                    parts=[{"text": "hi"}],
+                )
+            ],
+            generation_config={"temperature": 0.7, "topP": 1.0, "maxOutputTokens": 10}
+        )
+        
+        response = await chat_service.generate_content(
+            settings.TEST_MODEL,
+            gemini_request,
+            api_key
+        )
+        
+        if response:
+            # 如果密钥验证成功，则重置其失败计数
+            await key_manager.reset_key_failure_count(api_key)
+            return JSONResponse({"status": "valid"})
+    except Exception as e:
+        logger.error(f"Key verification failed: {str(e)}")
+        
+        async with key_manager.failure_count_lock:
+            if api_key in key_manager.key_failure_counts:
+                key_manager.key_failure_counts[api_key] += 1
+                logger.warning(f"Verification exception for key: {redact_key_for_logging(api_key)}, incrementing failure count")
+        
+        return JSONResponse({"status": "invalid", "error": str(e)})
+
+
+@router.post("/verify-selected-keys")
+async def verify_selected_keys(
+    request: VerifySelectedKeysRequest,
+    chat_service: GeminiChatService = Depends(get_chat_service),
+    key_manager: KeyManager = Depends(get_key_manager)
+):
+    """批量验证选定Gemini API密钥的有效性"""
+    logger.info("-" * 50 + "verify_selected_gemini_keys" + "-" * 50)
+    keys_to_verify = request.keys
+    logger.info(f"Received verification request for {len(keys_to_verify)} selected keys.")
+
+    if not keys_to_verify:
+        return JSONResponse({"success": False, "message": "没有提供需要验证的密钥"}, status_code=400)
+
+    successful_keys = []
+    failed_keys = {}
+
+    async def _verify_single_key(api_key: str):
+        """内部函数，用于验证单个密钥并处理异常"""
+        nonlocal successful_keys, failed_keys
+        try:
+            gemini_request = GeminiRequest(
+                contents=[GeminiContent(role="user", parts=[{"text": "hi"}])],
+                generation_config={"temperature": 0.7, "topP": 1.0, "maxOutputTokens": 10}
+            )
+            await chat_service.generate_content(
+                settings.TEST_MODEL,
+                gemini_request,
+                api_key
+            )
+            successful_keys.append(api_key)
+            # 如果密钥验证成功，则重置其失败计数
+            await key_manager.reset_key_failure_count(api_key)
+            return api_key, "valid", None
+        except Exception as e:
+            error_message = str(e)
+            logger.warning(f"Key verification failed for {redact_key_for_logging(api_key)}: {error_message}")
+            async with key_manager.failure_count_lock:
+                if api_key in key_manager.key_failure_counts:
+                    key_manager.key_failure_counts[api_key] += 1
+                    logger.warning(f"Bulk verification exception for key: {redact_key_for_logging(api_key)}, incrementing failure count")
+                else:
+                     key_manager.key_failure_counts[api_key] = 1
+                     logger.warning(f"Bulk verification exception for key: {redact_key_for_logging(api_key)}, initializing failure count to 1")
+            failed_keys[api_key] = error_message
+            return api_key, "invalid", error_message
+
+    tasks = [_verify_single_key(key) for key in keys_to_verify]
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+
+    for result in results:
+        if isinstance(result, Exception):
+            logger.error(f"An unexpected error occurred during bulk verification task: {result}")
+        elif result:
+             if not isinstance(result, Exception) and result:
+                 key, status, error = result
+             elif isinstance(result, Exception):
+                 logger.error(f"Task execution error during bulk verification: {result}")
+
+    valid_count = len(successful_keys)
+    invalid_count = len(failed_keys)
+    logger.info(f"Bulk verification finished. Valid: {valid_count}, Invalid: {invalid_count}")
+
+    if failed_keys:
+        message = f"批量验证完成。成功: {valid_count}, 失败: {invalid_count}。"
+        return JSONResponse({
+            "success": True,
+            "message": message,
+            "successful_keys": successful_keys,
+            "failed_keys": failed_keys,
+            "valid_count": valid_count,
+            "invalid_count": invalid_count
+        })
+    else:
+        message = f"批量验证成功完成。所有 {valid_count} 个密钥均有效。"
+        return JSONResponse({
+            "success": True,
+            "message": message,
+            "successful_keys": successful_keys,
+            "failed_keys": {},
+            "valid_count": valid_count,
+            "invalid_count": 0
+        })

app/router/key_routes.py

@@ -0,0 +1,83 @@
+from fastapi import APIRouter, Depends, Request
+from app.service.key.key_manager import KeyManager, get_key_manager_instance
+from app.core.security import verify_auth_token
+from fastapi.responses import JSONResponse
+
+router = APIRouter()
+
+@router.get("/api/keys")
+async def get_keys_paginated(
+    request: Request,
+    page: int = 1,
+    limit: int = 10,
+    search: str = None,
+    fail_count_threshold: int = None,
+    status: str = "all",  # 'valid', 'invalid', 'all'
+    key_manager: KeyManager = Depends(get_key_manager_instance),
+):
+    """
+    Get paginated, filtered, and searched keys.
+    """
+    auth_token = request.cookies.get("auth_token")
+    if not auth_token or not verify_auth_token(auth_token):
+        return JSONResponse(status_code=401, content={"detail": "Unauthorized"})
+
+    all_keys_with_status = await key_manager.get_all_keys_with_fail_count()
+
+    # Filter by status
+    if status == "valid":
+        keys_to_filter = all_keys_with_status["valid_keys"]
+    elif status == "invalid":
+        keys_to_filter = all_keys_with_status["invalid_keys"]
+    else:
+        # Combine both for 'all' status, which might be useful for a unified view if ever needed
+        keys_to_filter = {**all_keys_with_status["valid_keys"], **all_keys_with_status["invalid_keys"]}
+
+
+    # Further filtering (search and fail_count_threshold)
+    filtered_keys = {}
+    for key, fail_count in keys_to_filter.items():
+        search_match = True
+        if search:
+            search_match = search.lower() in key.lower()
+
+        fail_count_match = True
+        if fail_count_threshold is not None:
+            fail_count_match = fail_count >= fail_count_threshold
+
+        if search_match and fail_count_match:
+            filtered_keys[key] = fail_count
+
+    # Pagination
+    keys_list = list(filtered_keys.items())
+    total_items = len(keys_list)
+    start_index = (page - 1) * limit
+    end_index = start_index + limit
+    paginated_keys = dict(keys_list[start_index:end_index])
+
+    return {
+        "keys": paginated_keys,
+        "total_items": total_items,
+        "total_pages": (total_items + limit - 1) // limit,
+        "current_page": page,
+    }
+
+@router.get("/api/keys/all")
+async def get_all_keys(
+    request: Request,
+    key_manager: KeyManager = Depends(get_key_manager_instance),
+):
+    """
+    Get all keys (both valid and invalid) for bulk operations.
+    """
+    auth_token = request.cookies.get("auth_token")
+    if not auth_token or not verify_auth_token(auth_token):
+        return JSONResponse(status_code=401, content={"detail": "Unauthorized"})
+
+    all_keys_with_status = await key_manager.get_all_keys_with_fail_count()
+    
+    return {
+        "valid_keys": list(all_keys_with_status["valid_keys"].keys()),
+        "invalid_keys": list(all_keys_with_status["invalid_keys"].keys()),
+        "total_count": len(all_keys_with_status["valid_keys"]) + len(all_keys_with_status["invalid_keys"])
+    }

app/router/openai_compatiable_routes.py

@@ -0,0 +1,114 @@
+from fastapi import APIRouter, Depends
+from fastapi.responses import StreamingResponse
+
+from app.config.config import settings
+from app.core.security import SecurityService
+from app.domain.openai_models import (
+    ChatRequest,
+    EmbeddingRequest,
+    ImageGenerationRequest,
+)
+from app.handler.retry_handler import RetryHandler
+from app.handler.error_handler import handle_route_errors
+from app.log.logger import get_openai_compatible_logger
+from app.service.key.key_manager import KeyManager, get_key_manager_instance
+from app.service.openai_compatiable.openai_compatiable_service import OpenAICompatiableService
+from app.utils.helpers import redact_key_for_logging
+
+
+router = APIRouter()
+logger = get_openai_compatible_logger()
+
+security_service = SecurityService()
+
+async def get_key_manager():
+    return await get_key_manager_instance()
+
+
+async def get_next_working_key_wrapper(
+    key_manager: KeyManager = Depends(get_key_manager),
+):
+    return await key_manager.get_next_working_key()
+
+
+async def get_openai_service(key_manager: KeyManager = Depends(get_key_manager)):
+    """获取OpenAI聊天服务实例"""
+    return OpenAICompatiableService(settings.BASE_URL, key_manager)
+
+
+@router.get("/openai/v1/models")
+async def list_models(
+    _=Depends(security_service.verify_authorization),
+    key_manager: KeyManager = Depends(get_key_manager),
+    openai_service: OpenAICompatiableService = Depends(get_openai_service),
+):
+    """获取可用模型列表。"""
+    operation_name = "list_models"
+    async with handle_route_errors(logger, operation_name):
+        logger.info("Handling models list request")
+        api_key = await key_manager.get_random_valid_key()
+        logger.info(f"Using API key: {redact_key_for_logging(api_key)}")
+        return await openai_service.get_models(api_key)
+
+
+@router.post("/openai/v1/chat/completions")
+@RetryHandler(key_arg="api_key")
+async def chat_completion(
+    request: ChatRequest,
+    _=Depends(security_service.verify_authorization),
+    api_key: str = Depends(get_next_working_key_wrapper),
+    key_manager: KeyManager = Depends(get_key_manager),
+    openai_service: OpenAICompatiableService = Depends(get_openai_service),
+):
+    """处理聊天补全请求，支持流式响应和特定模型切换。"""
+    operation_name = "chat_completion"
+    is_image_chat = request.model == f"{settings.CREATE_IMAGE_MODEL}-chat"
+    current_api_key = api_key
+    if is_image_chat:
+        current_api_key = await key_manager.get_paid_key()
+
+    async with handle_route_errors(logger, operation_name):
+        logger.info(f"Handling chat completion request for model: {request.model}")
+        logger.debug(f"Request: \n{request.model_dump_json(indent=2)}")
+        logger.info(f"Using API key: {redact_key_for_logging(current_api_key)}")
+
+        if is_image_chat:
+            response = await openai_service.create_image_chat_completion(request, current_api_key)
+            return response
+        else:
+            response = await openai_service.create_chat_completion(request, current_api_key)
+            if request.stream:
+                return StreamingResponse(response, media_type="text/event-stream")
+            return response
+
+
+@router.post("/openai/v1/images/generations")
+async def generate_image(
+    request: ImageGenerationRequest,
+    _=Depends(security_service.verify_authorization),
+    openai_service: OpenAICompatiableService = Depends(get_openai_service),
+):
+    """处理图像生成请求。"""
+    operation_name = "generate_image"
+    async with handle_route_errors(logger, operation_name):
+        logger.info(f"Handling image generation request for prompt: {request.prompt}")
+        request.model = settings.CREATE_IMAGE_MODEL
+        return await openai_service.generate_images(request)
+
+
+@router.post("/openai/v1/embeddings")
+async def embedding(
+    request: EmbeddingRequest,
+    _=Depends(security_service.verify_authorization),
+    key_manager: KeyManager = Depends(get_key_manager),
+    openai_service: OpenAICompatiableService = Depends(get_openai_service),
+):
+    """处理文本嵌入请求。"""
+    operation_name = "embedding"
+    async with handle_route_errors(logger, operation_name):
+        logger.info(f"Handling embedding request for model: {request.model}")
+        api_key = await key_manager.get_next_working_key()
+        logger.info(f"Using API key: {redact_key_for_logging(api_key)}")
+        return await openai_service.create_embeddings(
+            input_text=request.input, model=request.model, api_key=api_key
+        )

app/router/openai_routes.py

@@ -0,0 +1,176 @@
+from fastapi import APIRouter, Depends, HTTPException, Response
+from fastapi.responses import StreamingResponse
+
+from app.config.config import settings
+from app.core.security import SecurityService
+from app.domain.openai_models import (
+    ChatRequest,
+    EmbeddingRequest,
+    ImageGenerationRequest,
+    TTSRequest,
+)
+from app.handler.retry_handler import RetryHandler
+from app.handler.error_handler import handle_route_errors
+from app.log.logger import get_openai_logger
+from app.service.chat.openai_chat_service import OpenAIChatService
+from app.service.embedding.embedding_service import EmbeddingService
+from app.service.image.image_create_service import ImageCreateService
+from app.service.tts.tts_service import TTSService
+from app.service.key.key_manager import KeyManager, get_key_manager_instance
+from app.service.model.model_service import ModelService
+from app.utils.helpers import redact_key_for_logging
+
+router = APIRouter()
+logger = get_openai_logger()
+
+security_service = SecurityService()
+model_service = ModelService()
+embedding_service = EmbeddingService()
+image_create_service = ImageCreateService()
+tts_service = TTSService()
+
+
+async def get_key_manager():
+    return await get_key_manager_instance()
+
+
+async def get_next_working_key_wrapper(
+    key_manager: KeyManager = Depends(get_key_manager),
+):
+    return await key_manager.get_next_working_key()
+
+
+async def get_openai_chat_service(key_manager: KeyManager = Depends(get_key_manager)):
+    """获取OpenAI聊天服务实例"""
+    return OpenAIChatService(settings.BASE_URL, key_manager)
+
+
+async def get_tts_service():
+    """获取TTS服务实例"""
+    return tts_service
+
+
+@router.get("/v1/models")
+@router.get("/hf/v1/models")
+async def list_models(
+    _=Depends(security_service.verify_authorization),
+    key_manager: KeyManager = Depends(get_key_manager),
+):
+    """获取可用的 OpenAI 模型列表 (兼容 Gemini 和 OpenAI)。"""
+    operation_name = "list_models"
+    async with handle_route_errors(logger, operation_name):
+        logger.info("Handling models list request")
+        api_key = await key_manager.get_random_valid_key()
+        logger.info(f"Using API key: {redact_key_for_logging(api_key)}")
+        return await model_service.get_gemini_openai_models(api_key)
+
+
+@router.post("/v1/chat/completions")
+@router.post("/hf/v1/chat/completions")
+@RetryHandler(key_arg="api_key")
+async def chat_completion(
+    request: ChatRequest,
+    _=Depends(security_service.verify_authorization),
+    api_key: str = Depends(get_next_working_key_wrapper),
+    key_manager: KeyManager = Depends(get_key_manager),
+    chat_service: OpenAIChatService = Depends(get_openai_chat_service),
+):
+    """处理 OpenAI 聊天补全请求，支持流式响应和特定模型切换。"""
+    operation_name = "chat_completion"
+    is_image_chat = request.model == f"{settings.CREATE_IMAGE_MODEL}-chat"
+    current_api_key = api_key
+    if is_image_chat:
+        current_api_key = await key_manager.get_paid_key()
+
+    async with handle_route_errors(logger, operation_name):
+        logger.info(f"Handling chat completion request for model: {request.model}")
+        logger.debug(f"Request: \n{request.model_dump_json(indent=2)}")
+        logger.info(f"Using API key: {redact_key_for_logging(current_api_key)}")
+
+        if not await model_service.check_model_support(request.model):
+            raise HTTPException(
+                status_code=400, detail=f"Model {request.model} is not supported"
+            )
+
+        if is_image_chat:
+            response = await chat_service.create_image_chat_completion(request, current_api_key)
+            if request.stream:
+                return StreamingResponse(response, media_type="text/event-stream")
+            return response
+        else:
+            response = await chat_service.create_chat_completion(request, current_api_key)
+            if request.stream:
+                return StreamingResponse(response, media_type="text/event-stream")
+            return response
+
+
+@router.post("/v1/images/generations")
+@router.post("/hf/v1/images/generations")
+async def generate_image(
+    request: ImageGenerationRequest,
+    _=Depends(security_service.verify_authorization),
+):
+    """处理 OpenAI 图像生成请求。"""
+    operation_name = "generate_image"
+    async with handle_route_errors(logger, operation_name):
+        logger.info(f"Handling image generation request for prompt: {request.prompt}")
+        response = image_create_service.generate_images(request)
+        return response
+
+
+@router.post("/v1/embeddings")
+@router.post("/hf/v1/embeddings")
+async def embedding(
+    request: EmbeddingRequest,
+    _=Depends(security_service.verify_authorization),
+    key_manager: KeyManager = Depends(get_key_manager),
+):
+    """处理 OpenAI 文本嵌入请求。"""
+    operation_name = "embedding"
+    async with handle_route_errors(logger, operation_name):
+        logger.info(f"Handling embedding request for model: {request.model}")
+        api_key = await key_manager.get_next_working_key()
+        logger.info(f"Using API key: {redact_key_for_logging(api_key)}")
+        response = await embedding_service.create_embedding(
+            input_text=request.input, model=request.model, api_key=api_key
+        )
+        return response
+
+
+@router.get("/v1/keys/list")
+@router.get("/hf/v1/keys/list")
+async def get_keys_list(
+    _=Depends(security_service.verify_auth_token),
+    key_manager: KeyManager = Depends(get_key_manager),
+):
+    """获取有效和无效的API key列表 (需要管理 Token 认证)。"""
+    operation_name = "get_keys_list"
+    async with handle_route_errors(logger, operation_name):
+        logger.info("Handling keys list request")
+        keys_status = await key_manager.get_keys_by_status()
+        return {
+            "status": "success",
+            "data": {
+                "valid_keys": keys_status["valid_keys"],
+                "invalid_keys": keys_status["invalid_keys"],
+            },
+            "total": len(keys_status["valid_keys"]) + len(keys_status["invalid_keys"]),
+        }
+
+
+@router.post("/v1/audio/speech")
+@router.post("/hf/v1/audio/speech")
+async def text_to_speech(
+    request: TTSRequest,
+    _=Depends(security_service.verify_authorization),
+    api_key: str = Depends(get_next_working_key_wrapper),
+    tts_service: TTSService = Depends(get_tts_service),
+):
+    """处理 OpenAI TTS 请求。"""
+    operation_name = "text_to_speech"
+    async with handle_route_errors(logger, operation_name):
+        logger.info(f"Handling TTS request for model: {request.model}")
+        logger.debug(f"Request: \n{request.model_dump_json(indent=2)}")
+        logger.info(f"Using API key: {redact_key_for_logging(api_key)}")
+        audio_data = await tts_service.create_tts(request, api_key)
+        return Response(content=audio_data, media_type="audio/wav")

app/router/routes.py

@@ -0,0 +1,287 @@
+"""
+路由配置模块，负责设置和配置应用程序的路由
+"""
+
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse, RedirectResponse
+from fastapi.templating import Jinja2Templates
+
+from app.config.config import settings
+from app.core.security import verify_auth_token
+from app.log.logger import get_routes_logger
+from app.router import (
+    config_routes,
+    error_log_routes,
+    files_routes,
+    gemini_routes,
+    key_routes,
+    openai_compatiable_routes,
+    openai_routes,
+    scheduler_routes,
+    stats_routes,
+    version_routes,
+    vertex_express_routes,
+)
+from app.service.key.key_manager import get_key_manager_instance
+from app.service.stats.stats_service import StatsService
+
+logger = get_routes_logger()
+
+templates = Jinja2Templates(directory="app/templates")
+
+
+def setup_routers(app: FastAPI) -> None:
+    """
+    设置应用程序的路由
+
+    Args:
+        app: FastAPI应用程序实例
+    """
+    app.include_router(openai_routes.router)
+    app.include_router(gemini_routes.router)
+    app.include_router(gemini_routes.router_v1beta)
+    app.include_router(config_routes.router)
+    app.include_router(error_log_routes.router)
+    app.include_router(scheduler_routes.router)
+    app.include_router(stats_routes.router)
+    app.include_router(version_routes.router)
+    app.include_router(openai_compatiable_routes.router)
+    app.include_router(vertex_express_routes.router)
+    app.include_router(files_routes.router)
+    app.include_router(key_routes.router)
+
+    setup_page_routes(app)
+
+    setup_health_routes(app)
+    setup_api_stats_routes(app)
+
+
+def setup_page_routes(app: FastAPI) -> None:
+    """
+    设置页面相关的路由
+
+    Args:
+        app: FastAPI应用程序实例
+    """
+
+    @app.get("/", response_class=HTMLResponse)
+    async def auth_page(request: Request):
+        """认证页面"""
+        return templates.TemplateResponse("auth.html", {"request": request})
+
+    @app.post("/auth")
+    async def authenticate(request: Request):
+        """处理认证请求"""
+        try:
+            form = await request.form()
+            auth_token = form.get("auth_token")
+            if not auth_token:
+                logger.warning("Authentication attempt with empty token")
+                return RedirectResponse(url="/", status_code=302)
+
+            if verify_auth_token(auth_token):
+                logger.info("Successful authentication")
+                response = RedirectResponse(url="/keys", status_code=302)
+                response.set_cookie(
+                    key="auth_token",
+                    value=auth_token,
+                    httponly=True,
+                    max_age=settings.ADMIN_SESSION_EXPIRE,
+                )
+                return response
+            logger.warning("Failed authentication attempt with invalid token")
+            return RedirectResponse(url="/", status_code=302)
+        except Exception as e:
+            logger.error(f"Authentication error: {str(e)}")
+            return RedirectResponse(url="/", status_code=302)
+
+    @app.get("/keys", response_class=HTMLResponse)
+    async def keys_page(request: Request):
+        """密钥管理页面"""
+        try:
+            auth_token = request.cookies.get("auth_token")
+            if not auth_token or not verify_auth_token(auth_token):
+                logger.warning("Unauthorized access attempt to keys page")
+                return RedirectResponse(url="/", status_code=302)
+
+            key_manager = await get_key_manager_instance()
+            keys_status = await key_manager.get_keys_by_status()
+            total_keys = len(keys_status["valid_keys"]) + len(
+                keys_status["invalid_keys"]
+            )
+            valid_key_count = len(keys_status["valid_keys"])
+            invalid_key_count = len(keys_status["invalid_keys"])
+
+            stats_service = StatsService()
+            api_stats = await stats_service.get_api_usage_stats()
+            logger.info(f"API stats retrieved: {api_stats}")
+
+            logger.info(f"Keys status retrieved successfully. Total keys: {total_keys}")
+            return templates.TemplateResponse(
+                "keys_status.html",
+                {
+                    "request": request,
+                    "valid_keys": {},
+                    "invalid_keys": {},
+                    "total_keys": total_keys,
+                    "valid_key_count": valid_key_count,
+                    "invalid_key_count": invalid_key_count,
+                    "api_stats": api_stats,
+                },
+            )
+        except Exception as e:
+            logger.error(f"Error retrieving keys status or API stats: {str(e)}")
+            # Even if there's an error, render the page with whatever data is available
+            # or with empty/default values, so the frontend can still load.
+            return templates.TemplateResponse(
+                "keys_status.html",
+                {
+                    "request": request,
+                    "valid_keys": {},
+                    "invalid_keys": {},
+                    "total_keys": 0,
+                    "valid_key_count": 0,
+                    "invalid_key_count": 0,
+                    "api_stats": {  # Provide a default structure for api_stats
+                        "calls_1m": {"total": 0, "success": 0, "failure": 0},
+                        "calls_1h": {"total": 0, "success": 0, "failure": 0},
+                        "calls_24h": {"total": 0, "success": 0, "failure": 0},
+                        "calls_month": {"total": 0, "success": 0, "failure": 0},
+                    },
+                },
+            )
+
+    @app.get("/config", response_class=HTMLResponse)
+    async def config_page(request: Request):
+        """配置编辑页面"""
+        try:
+            auth_token = request.cookies.get("auth_token")
+            if not auth_token or not verify_auth_token(auth_token):
+                logger.warning("Unauthorized access attempt to config page")
+                return RedirectResponse(url="/", status_code=302)
+
+            logger.info("Config page accessed successfully")
+            return templates.TemplateResponse(
+                "config_editor.html", {"request": request}
+            )
+        except Exception as e:
+            logger.error(f"Error accessing config page: {str(e)}")
+            raise
+
+    @app.get("/logs", response_class=HTMLResponse)
+    async def logs_page(request: Request):
+        """错误日志页面"""
+        try:
+            auth_token = request.cookies.get("auth_token")
+            if not auth_token or not verify_auth_token(auth_token):
+                logger.warning("Unauthorized access attempt to logs page")
+                return RedirectResponse(url="/", status_code=302)
+
+            logger.info("Logs page accessed successfully")
+            return templates.TemplateResponse("error_logs.html", {"request": request})
+        except Exception as e:
+            logger.error(f"Error accessing logs page: {str(e)}")
+            raise
+
+
+def setup_health_routes(app: FastAPI) -> None:
+    """
+    设置健康检查相关的路由
+
+    Args:
+        app: FastAPI应用程序实例
+    """
+
+    @app.get("/health")
+    async def health_check(request: Request):
+        """健康检查端点"""
+        logger.info("Health check endpoint called")
+        return {"status": "healthy"}
+
+
+def setup_api_stats_routes(app: FastAPI) -> None:
+    """
+    设置 API 统计相关的路由
+
+    Args:
+        app: FastAPI应用程序实例
+    """
+
+    @app.get("/api/stats/details")
+    async def api_stats_details(request: Request, period: str):
+        """获取指定时间段内的 API 调用详情"""
+        try:
+            auth_token = request.cookies.get("auth_token")
+            if not auth_token or not verify_auth_token(auth_token):
+                logger.warning("Unauthorized access attempt to API stats details")
+                return {"error": "Unauthorized"}, 401
+
+            logger.info(f"Fetching API call details for period: {period}")
+            stats_service = StatsService()
+            details = await stats_service.get_api_call_details(period)
+            return details
+        except ValueError as e:
+            logger.warning(
+                f"Invalid period requested for API stats details: {period} - {str(e)}"
+            )
+            return {"error": str(e)}, 400
+        except Exception as e:
+            logger.error(
+                f"Error fetching API stats details for period {period}: {str(e)}"
+            )
+            return {"error": "Internal server error"}, 500
+
+    @app.get("/api/stats/attention-keys")
+    async def api_stats_attention_keys(
+        request: Request, limit: int = 20, status_code: int = 429
+    ):
+        """返回最近24小时指定错误码次数最多的Key（仅包含内存Key列表中的）。默认错误码429。"""
+        try:
+            auth_token = request.cookies.get("auth_token")
+            if not auth_token or not verify_auth_token(auth_token):
+                logger.warning("Unauthorized access attempt to attention-keys")
+                return {"error": "Unauthorized"}, 401
+
+            # 支持所有标准HTTP状态码范围
+            # if not isinstance(status_code, int) or status_code < 100 or status_code > 599:
+            #     return {"error": f"Unsupported status_code: {status_code}"}, 400
+
+            key_manager = await get_key_manager_instance()
+            keys_status = await key_manager.get_keys_by_status()
+            in_memory_keys = set(keys_status.get("valid_keys", [])) | set(
+                keys_status.get("invalid_keys", [])
+            )
+            stats_service = StatsService()
+            data = await stats_service.get_attention_keys_last_24h(
+                in_memory_keys, limit, status_code
+            )
+            return data
+        except Exception as e:
+            logger.error(f"Error fetching attention keys: {e}")
+            return {"error": "Internal server error"}, 500
+
+    @app.get("/api/stats/key-details")
+    async def api_stats_key_details(request: Request, key: str, period: str):
+        """获取指定密钥在指定时间段内的调用详情"""
+        try:
+            auth_token = request.cookies.get("auth_token")
+            if not auth_token or not verify_auth_token(auth_token):
+                logger.warning("Unauthorized access attempt to API key stats details")
+                return {"error": "Unauthorized"}, 401
+
+            logger.info(
+                f"Fetching key call details for key=...{key[-4:] if key else ''}, period: {period}"
+            )
+            stats_service = StatsService()
+            details = await stats_service.get_key_call_details(key, period)
+            return details
+        except ValueError as e:
+            logger.warning(
+                f"Invalid period requested for key stats details: {period} - {str(e)}"
+            )
+            return {"error": str(e)}, 400
+        except Exception as e:
+            logger.error(
+                f"Error fetching key stats details for period {period}: {str(e)}"
+            )
+            return {"error": "Internal server error"}, 500

app/router/scheduler_routes.py

@@ -0,0 +1,57 @@
+"""
+定时任务控制路由模块
+"""
+
+from fastapi import APIRouter, Request, HTTPException, status
+from fastapi.responses import JSONResponse
+
+from app.core.security import verify_auth_token
+from app.scheduler.scheduled_tasks import start_scheduler, stop_scheduler
+from app.log.logger import get_scheduler_routes
+
+logger = get_scheduler_routes()
+
+router = APIRouter(
+    prefix="/api/scheduler",
+    tags=["Scheduler"]
+)
+
+async def verify_token(request: Request):
+    auth_token = request.cookies.get("auth_token")
+    if not auth_token or not verify_auth_token(auth_token):
+        logger.warning("Unauthorized access attempt to scheduler API")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Not authenticated",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+@router.post("/start", summary="启动定时任务")
+async def start_scheduler_endpoint(request: Request):
+    """Start the background scheduler task"""
+    await verify_token(request)
+    try:
+        logger.info("Received request to start scheduler.")
+        start_scheduler()
+        return JSONResponse(content={"message": "Scheduler started successfully."}, status_code=status.HTTP_200_OK)
+    except Exception as e:
+        logger.error(f"Error starting scheduler: {str(e)}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to start scheduler: {str(e)}"
+        )
+
+@router.post("/stop", summary="停止定时任务")
+async def stop_scheduler_endpoint(request: Request):
+    """Stop the background scheduler task"""
+    await verify_token(request)
+    try:
+        logger.info("Received request to stop scheduler.")
+        stop_scheduler()
+        return JSONResponse(content={"message": "Scheduler stopped successfully."}, status_code=status.HTTP_200_OK)
+    except Exception as e:
+        logger.error(f"Error stopping scheduler: {str(e)}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to stop scheduler: {str(e)}"
+        )

app/router/stats_routes.py

@@ -0,0 +1,56 @@
+from fastapi import APIRouter, Depends, HTTPException, Request
+from starlette import status
+from app.core.security import verify_auth_token
+from app.service.stats.stats_service import StatsService
+from app.log.logger import get_stats_logger
+from app.utils.helpers import redact_key_for_logging
+
+logger = get_stats_logger()
+
+
+async def verify_token(request: Request):
+    auth_token = request.cookies.get("auth_token")
+    if not auth_token or not verify_auth_token(auth_token):
+        logger.warning("Unauthorized access attempt to scheduler API")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Not authenticated",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+router = APIRouter(
+    prefix="/api",
+    tags=["stats"],
+    dependencies=[Depends(verify_token)]
+)
+
+stats_service = StatsService()
+
+@router.get("/key-usage-details/{key}",
+            summary="获取指定密钥最近24小时的模型调用次数",
+            description="根据提供的 API 密钥，返回过去24小时内每个模型被调用的次数统计。")
+async def get_key_usage_details(key: str):
+    """
+    Retrieves the model usage count for a specific API key within the last 24 hours.
+
+    Args:
+        key: The API key to get usage details for.
+
+    Returns:
+        A dictionary with model names as keys and their call counts as values.
+        Example: {"gemini-pro": 10, "gemini-1.5-pro-latest": 5}
+
+    Raises:
+        HTTPException: If an error occurs during data retrieval.
+    """
+    try:
+        usage_details = await stats_service.get_key_usage_details_last_24h(key)
+        if usage_details is None:
+            return {}
+        return usage_details
+    except Exception as e:
+        logger.error(f"Error fetching key usage details for key {redact_key_for_logging(key)}: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"获取密钥使用详情时出错: {e}"
+        )

app/router/version_routes.py

@@ -0,0 +1,37 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+from typing import Optional
+
+from app.service.update.update_service import check_for_updates
+from app.utils.helpers import get_current_version
+from app.log.logger import get_update_logger
+
+router = APIRouter(prefix="/api/version", tags=["Version"])
+logger = get_update_logger()
+
+class VersionInfo(BaseModel):
+    current_version: str = Field(..., description="当前应用程序版本")
+    latest_version: Optional[str] = Field(None, description="可用的最新版本")
+    update_available: bool = Field(False, description="是否有可用更新")
+    error_message: Optional[str] = Field(None, description="检查更新时发生的错误信息")
+
+@router.get("/check", response_model=VersionInfo, summary="检查应用程序更新")
+async def get_version_info():
+    """
+    检查当前应用程序版本与最新的 GitHub release 版本。
+    """
+    try:
+        current_version = get_current_version()
+        update_available, latest_version, error_message = await check_for_updates()
+
+        logger.info(f"Version check API result: current={current_version}, latest={latest_version}, available={update_available}, error='{error_message}'")
+
+        return VersionInfo(
+            current_version=current_version,
+            latest_version=latest_version,
+            update_available=update_available,
+            error_message=error_message
+        )
+    except Exception as e:
+        logger.error(f"Error in /api/version/check endpoint: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail="检查版本信息时发生内部错误")

app/router/vertex_express_routes.py

@@ -0,0 +1,147 @@
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import StreamingResponse
+from copy import deepcopy
+from app.config.config import settings
+from app.log.logger import get_vertex_express_logger
+from app.core.security import SecurityService
+from app.domain.gemini_models import GeminiRequest
+from app.service.chat.vertex_express_chat_service import GeminiChatService
+from app.service.key.key_manager import KeyManager, get_key_manager_instance
+from app.service.model.model_service import ModelService
+from app.handler.retry_handler import RetryHandler
+from app.handler.error_handler import handle_route_errors
+from app.core.constants import API_VERSION
+from app.utils.helpers import redact_key_for_logging
+
+router = APIRouter(prefix=f"/vertex-express/{API_VERSION}")
+logger = get_vertex_express_logger()
+
+security_service = SecurityService()
+model_service = ModelService()
+
+
+async def get_key_manager():
+    """获取密钥管理器实例"""
+    return await get_key_manager_instance()
+
+
+async def get_next_working_key(key_manager: KeyManager = Depends(get_key_manager)):
+    """获取下一个可用的API密钥"""
+    return await key_manager.get_next_working_vertex_key()
+
+
+async def get_chat_service(key_manager: KeyManager = Depends(get_key_manager)):
+    """获取Gemini聊天服务实例"""
+    return GeminiChatService(settings.VERTEX_EXPRESS_BASE_URL, key_manager)
+
+
+@router.get("/models")
+async def list_models(
+    _=Depends(security_service.verify_key_or_goog_api_key),
+    key_manager: KeyManager = Depends(get_key_manager)
+):
+    """获取可用的 Gemini 模型列表，并根据配置添加衍生模型（搜索、图像、非思考）。"""
+    operation_name = "list_gemini_models"
+    logger.info("-" * 50 + operation_name + "-" * 50)
+    logger.info("Handling Gemini models list request")
+
+    try:
+        api_key = await key_manager.get_random_valid_key()
+        if not api_key:
+            raise HTTPException(status_code=503, detail="No valid API keys available to fetch models.")
+        logger.info(f"Using API key: {redact_key_for_logging(api_key)}")
+
+        models_data = await model_service.get_gemini_models(api_key)
+        if not models_data or "models" not in models_data:
+            raise HTTPException(status_code=500, detail="Failed to fetch base models list.")
+
+        models_json = deepcopy(models_data)
+        model_mapping = {x.get("name", "").split("/", maxsplit=1)[-1]: x for x in models_json.get("models", [])}
+
+        def add_derived_model(base_name, suffix, display_suffix):
+            model = model_mapping.get(base_name)
+            if not model:
+                logger.warning(f"Base model '{base_name}' not found for derived model '{suffix}'.")
+                return
+            item = deepcopy(model)
+            item["name"] = f"models/{base_name}{suffix}"
+            display_name = f'{item.get("displayName", base_name)}{display_suffix}'
+            item["displayName"] = display_name
+            item["description"] = display_name
+            models_json["models"].append(item)
+
+        if settings.SEARCH_MODELS:
+            for name in settings.SEARCH_MODELS:
+                add_derived_model(name, "-search", " For Search")
+        if settings.IMAGE_MODELS:
+            for name in settings.IMAGE_MODELS:
+                 add_derived_model(name, "-image", " For Image")
+        if settings.THINKING_MODELS:
+            for name in settings.THINKING_MODELS:
+                add_derived_model(name, "-non-thinking", " Non Thinking")
+
+        logger.info("Gemini models list request successful")
+        return models_json
+    except HTTPException as http_exc:
+        raise http_exc
+    except Exception as e:
+        logger.error(f"Error getting Gemini models list: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail="Internal server error while fetching Gemini models list"
+        ) from e
+
+
+@router.post("/models/{model_name}:generateContent")
+@RetryHandler(key_arg="api_key")
+async def generate_content(
+    model_name: str,
+    request: GeminiRequest,
+    _=Depends(security_service.verify_key_or_goog_api_key),
+    api_key: str = Depends(get_next_working_key),
+    key_manager: KeyManager = Depends(get_key_manager),
+    chat_service: GeminiChatService = Depends(get_chat_service)
+):
+    """处理 Gemini 非流式内容生成请求。"""
+    operation_name = "gemini_generate_content"
+    async with handle_route_errors(logger, operation_name, failure_message="Content generation failed"):
+        logger.info(f"Handling Gemini content generation request for model: {model_name}")
+        logger.debug(f"Request: \n{request.model_dump_json(indent=2)}")
+        logger.info(f"Using API key: {redact_key_for_logging(api_key)}")
+
+        if not await model_service.check_model_support(model_name):
+            raise HTTPException(status_code=400, detail=f"Model {model_name} is not supported")
+
+        response = await chat_service.generate_content(
+            model=model_name,
+            request=request,
+            api_key=api_key
+        )
+        return response
+
+
+@router.post("/models/{model_name}:streamGenerateContent")
+@RetryHandler(key_arg="api_key")
+async def stream_generate_content(
+    model_name: str,
+    request: GeminiRequest,
+    _=Depends(security_service.verify_key_or_goog_api_key),
+    api_key: str = Depends(get_next_working_key),
+    key_manager: KeyManager = Depends(get_key_manager),
+    chat_service: GeminiChatService = Depends(get_chat_service)
+):
+    """处理 Gemini 流式内容生成请求。"""
+    operation_name = "gemini_stream_generate_content"
+    async with handle_route_errors(logger, operation_name, failure_message="Streaming request initiation failed"):
+        logger.info(f"Handling Gemini streaming content generation for model: {model_name}")
+        logger.debug(f"Request: \n{request.model_dump_json(indent=2)}")
+        logger.info(f"Using API key: {redact_key_for_logging(api_key)}")
+
+        if not await model_service.check_model_support(model_name):
+            raise HTTPException(status_code=400, detail=f"Model {model_name} is not supported")
+
+        response_stream = chat_service.stream_generate_content(
+            model=model_name,
+            request=request,
+            api_key=api_key
+        )
+        return StreamingResponse(response_stream, media_type="text/event-stream")

app/scheduler/scheduled_tasks.py

@@ -0,0 +1,195 @@
+
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+
+from app.config.config import settings
+from app.domain.gemini_models import GeminiContent, GeminiRequest
+from app.log.logger import Logger
+from app.service.chat.gemini_chat_service import GeminiChatService
+from app.service.error_log.error_log_service import delete_old_error_logs
+from app.service.key.key_manager import get_key_manager_instance
+from app.service.request_log.request_log_service import delete_old_request_logs_task
+from app.service.files.files_service import get_files_service
+from app.utils.helpers import redact_key_for_logging
+
+logger = Logger.setup_logger("scheduler")
+
+
+async def check_failed_keys():
+    """
+    定时检查失败次数大于0的API密钥，并尝试验证它们。
+    如果验证成功，重置失败计数；如果失败，增加失败计数。
+    """
+    logger.info("Starting scheduled check for failed API keys...")
+    try:
+        key_manager = await get_key_manager_instance()
+        # 确保 KeyManager 已经初始化
+        if not key_manager or not hasattr(key_manager, "key_failure_counts"):
+            logger.warning(
+                "KeyManager instance not available or not initialized. Skipping check."
+            )
+            return
+
+        # 创建 GeminiChatService 实例用于验证
+        # 注意：这里直接创建实例，而不是通过依赖注入，因为这是后台任务
+        chat_service = GeminiChatService(settings.BASE_URL, key_manager)
+
+        # 获取需要检查的 key 列表 (失败次数 > 0)
+        keys_to_check = []
+        async with key_manager.failure_count_lock:  # 访问共享数据需要加锁
+            # 复制一份以避免在迭代时修改字典
+            failure_counts_copy = key_manager.key_failure_counts.copy()
+            keys_to_check = [
+                key for key, count in failure_counts_copy.items() if count > 0
+            ]  # 检查所有失败次数大于0的key
+
+        if not keys_to_check:
+            logger.info("No keys with failure count > 0 found. Skipping verification.")
+            return
+
+        logger.info(
+            f"Found {len(keys_to_check)} keys with failure count > 0 to verify."
+        )
+
+        for key in keys_to_check:
+            # 隐藏部分 key 用于日志记录
+            log_key = redact_key_for_logging(key)
+            logger.info(f"Verifying key: {log_key}...")
+            try:
+                # 构造测试请求
+                gemini_request = GeminiRequest(
+                    contents=[
+                        GeminiContent(
+                            role="user",
+                            parts=[{"text": "hi"}],
+                        )
+                    ]
+                )
+                await chat_service.generate_content(
+                    settings.TEST_MODEL, gemini_request, key
+                )
+                logger.info(
+                    f"Key {log_key} verification successful. Resetting failure count."
+                )
+                await key_manager.reset_key_failure_count(key)
+            except Exception as e:
+                logger.warning(
+                    f"Key {log_key} verification failed: {str(e)}. Incrementing failure count."
+                )
+                # 直接操作计数器，需要加锁
+                async with key_manager.failure_count_lock:
+                    # 再次检查 key 是否存在且失败次数未达上限
+                    if (
+                        key in key_manager.key_failure_counts
+                        and key_manager.key_failure_counts[key]
+                        < key_manager.MAX_FAILURES
+                    ):
+                        key_manager.key_failure_counts[key] += 1
+                        logger.info(
+                            f"Failure count for key {log_key} incremented to {key_manager.key_failure_counts[key]}."
+                        )
+                    elif key in key_manager.key_failure_counts:
+                        logger.warning(
+                            f"Key {log_key} reached MAX_FAILURES ({key_manager.MAX_FAILURES}). Not incrementing further."
+                        )
+
+    except Exception as e:
+        logger.error(
+            f"An error occurred during the scheduled key check: {str(e)}", exc_info=True
+        )
+
+
+async def cleanup_expired_files():
+    """
+    定时清理过期的文件记录
+    """
+    logger.info("Starting scheduled cleanup for expired files...")
+    try:
+        files_service = await get_files_service()
+        deleted_count = await files_service.cleanup_expired_files()
+        
+        if deleted_count > 0:
+            logger.info(f"Successfully cleaned up {deleted_count} expired files.")
+        else:
+            logger.info("No expired files to clean up.")
+            
+    except Exception as e:
+        logger.error(
+            f"An error occurred during the scheduled file cleanup: {str(e)}", exc_info=True
+        )
+
+
+def setup_scheduler():
+    """设置并启动 APScheduler"""
+    scheduler = AsyncIOScheduler(timezone=str(settings.TIMEZONE))  # 从配置读取时区
+    # 添加检查失败密钥的定时任务
+    scheduler.add_job(
+        check_failed_keys,
+        "interval",
+        hours=settings.CHECK_INTERVAL_HOURS,
+        id="check_failed_keys_job",
+        name="Check Failed API Keys",
+    )
+    logger.info(
+        f"Key check job scheduled to run every {settings.CHECK_INTERVAL_HOURS} hour(s)."
+    )
+
+    # 新增：添加自动删除错误日志的定时任务，每天凌晨3点执行
+    scheduler.add_job(
+        delete_old_error_logs,
+        "cron",
+        hour=3,
+        minute=0,
+        id="delete_old_error_logs_job",
+        name="Delete Old Error Logs",
+    )
+    logger.info("Auto-delete error logs job scheduled to run daily at 3:00 AM.")
+
+    # 新增：添加自动删除请求日志的定时任务，每天凌晨3点05分执行
+    scheduler.add_job(
+        delete_old_request_logs_task,
+        "cron",
+        hour=3,
+        minute=5,
+        id="delete_old_request_logs_job",
+        name="Delete Old Request Logs",
+    )
+    logger.info(
+        f"Auto-delete request logs job scheduled to run daily at 3:05 AM, if enabled and AUTO_DELETE_REQUEST_LOGS_DAYS is set to {settings.AUTO_DELETE_REQUEST_LOGS_DAYS} days."
+    )
+    
+    # 新增：添加文件过期清理的定时任务，每小时执行一次
+    if getattr(settings, 'FILES_CLEANUP_ENABLED', True):
+        cleanup_interval = getattr(settings, 'FILES_CLEANUP_INTERVAL_HOURS', 1)
+        scheduler.add_job(
+            cleanup_expired_files,
+            "interval",
+            hours=cleanup_interval,
+            id="cleanup_expired_files_job",
+            name="Cleanup Expired Files",
+        )
+        logger.info(
+            f"File cleanup job scheduled to run every {cleanup_interval} hour(s)."
+        )
+
+    scheduler.start()
+    logger.info("Scheduler started with all jobs.")
+    return scheduler
+
+
+# 可以在这里添加一个全局的 scheduler 实例，以便在应用关闭时优雅地停止
+scheduler_instance = None
+
+
+def start_scheduler():
+    global scheduler_instance
+    if scheduler_instance is None or not scheduler_instance.running:
+        logger.info("Starting scheduler...")
+        scheduler_instance = setup_scheduler()
+    logger.info("Scheduler is already running.")
+
+
+def stop_scheduler():
+    global scheduler_instance
+    if scheduler_instance and scheduler_instance.running:
+        scheduler_instance.shutdown()
+        logger.info("Scheduler stopped.")

app/service/chat/gemini_chat_service.py

@@ -0,0 +1,555 @@
+# app/services/chat_service.py
+
+import datetime
+import json
+import re
+import time
+from typing import Any, AsyncGenerator, Dict, List
+
+from app.config.config import settings
+from app.core.constants import GEMINI_2_FLASH_EXP_SAFETY_SETTINGS
+from app.database.services import add_error_log, add_request_log, get_file_api_key
+from app.domain.gemini_models import GeminiRequest
+from app.handler.response_handler import GeminiResponseHandler
+from app.handler.stream_optimizer import gemini_optimizer
+from app.log.logger import get_gemini_logger
+from app.service.client.api_client import GeminiApiClient
+from app.service.key.key_manager import KeyManager
+from app.utils.helpers import redact_key_for_logging
+
+logger = get_gemini_logger()
+
+
+def _has_image_parts(contents: List[Dict[str, Any]]) -> bool:
+    """判断消息是否包含图片部分"""
+    for content in contents:
+        if "parts" in content:
+            for part in content["parts"]:
+                if "image_url" in part or "inline_data" in part:
+                    return True
+    return False
+
+
+def _extract_file_references(contents: List[Dict[str, Any]]) -> List[str]:
+    """從內容中提取文件引用"""
+    file_names = []
+    for content in contents:
+        if "parts" in content:
+            for part in content["parts"]:
+                if not isinstance(part, dict) or "fileData" not in part:
+                    continue
+                file_data = part["fileData"]
+                if "fileUri" not in file_data:
+                    continue
+                file_uri = file_data["fileUri"]
+                # 從 URI 中提取文件名
+                # 1. https://generativelanguage.googleapis.com/v1beta/files/{file_id}
+                match = re.match(
+                    rf"{re.escape(settings.BASE_URL)}/(files/.*)", file_uri
+                )
+                if not match:
+                    logger.warning(f"Invalid file URI: {file_uri}")
+                    continue
+                file_id = match.group(1)
+                file_names.append(file_id)
+                logger.info(f"Found file reference: {file_id}")
+    return file_names
+
+
+def _clean_json_schema_properties(obj: Any) -> Any:
+    """清理JSON Schema中Gemini API不支持的字段"""
+    if not isinstance(obj, dict):
+        return obj
+
+    # Gemini API不支持的JSON Schema字段
+    unsupported_fields = {
+        "exclusiveMaximum",
+        "exclusiveMinimum",
+        "const",
+        "examples",
+        "contentEncoding",
+        "contentMediaType",
+        "if",
+        "then",
+        "else",
+        "allOf",
+        "anyOf",
+        "oneOf",
+        "not",
+        "definitions",
+        "$schema",
+        "$id",
+        "$ref",
+        "$comment",
+        "readOnly",
+        "writeOnly",
+    }
+
+    cleaned = {}
+    for key, value in obj.items():
+        if key in unsupported_fields:
+            continue
+        if isinstance(value, dict):
+            cleaned[key] = _clean_json_schema_properties(value)
+        elif isinstance(value, list):
+            cleaned[key] = [_clean_json_schema_properties(item) for item in value]
+        else:
+            cleaned[key] = value
+
+    return cleaned
+
+
+def _build_tools(model: str, payload: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """构建工具"""
+
+    def _has_function_call(contents: List[Dict[str, Any]]) -> bool:
+        """检查内容中是否包含 functionCall"""
+        if not contents or not isinstance(contents, list):
+            return False
+        for content in contents:
+            if not content or not isinstance(content, dict) or "parts" not in content:
+                continue
+            parts = content.get("parts", [])
+            if not parts or not isinstance(parts, list):
+                continue
+            for part in parts:
+                if isinstance(part, dict) and "functionCall" in part:
+                    return True
+        return False
+
+    def _merge_tools(tools: List[Dict[str, Any]]) -> Dict[str, Any]:
+        record = dict()
+        for item in tools:
+            if not item or not isinstance(item, dict):
+                continue
+
+            for k, v in item.items():
+                if k == "functionDeclarations" and v and isinstance(v, list):
+                    functions = record.get("functionDeclarations", [])
+                    # 清理每个函数声明中的不支持字段
+                    cleaned_functions = []
+                    for func in v:
+                        if isinstance(func, dict):
+                            cleaned_func = _clean_json_schema_properties(func)
+                            cleaned_functions.append(cleaned_func)
+                        else:
+                            cleaned_functions.append(func)
+                    functions.extend(cleaned_functions)
+                    record["functionDeclarations"] = functions
+                else:
+                    record[k] = v
+        return record
+
+    def _is_structured_output_request(payload: Dict[str, Any]) -> bool:
+        """检查请求是否要求结构化JSON输出"""
+        try:
+            generation_config = payload.get("generationConfig", {})
+            return generation_config.get("responseMimeType") == "application/json"
+        except (AttributeError, TypeError):
+            return False
+
+    tool = dict()
+    if payload and isinstance(payload, dict) and "tools" in payload:
+        if payload.get("tools") and isinstance(payload.get("tools"), dict):
+            payload["tools"] = [payload.get("tools")]
+        items = payload.get("tools", [])
+        if items and isinstance(items, list):
+            tool.update(_merge_tools(items))
+
+    # "Tool use with a response mime type: 'application/json' is unsupported"
+    # Gemini API限制：不支持同时使用tools和结构化输出(response_mime_type='application/json')
+    # 当请求指定了JSON响应格式时，跳过所有工具的添加以避免API错误
+    has_structured_output = _is_structured_output_request(payload)
+    if not has_structured_output:
+        if (
+            settings.TOOLS_CODE_EXECUTION_ENABLED
+            and not (model.endswith("-search") or "-thinking" in model)
+            and not _has_image_parts(payload.get("contents", []))
+        ):
+            tool["codeExecution"] = {}
+
+        if model.endswith("-search"):
+            tool["googleSearch"] = {}
+
+        real_model = _get_real_model(model)
+        if real_model in settings.URL_CONTEXT_MODELS and settings.URL_CONTEXT_ENABLED:
+            tool["urlContext"] = {}
+
+    # 解决 "Tool use with function calling is unsupported" 问题
+    if tool.get("functionDeclarations") or _has_function_call(
+        payload.get("contents", [])
+    ):
+        tool.pop("googleSearch", None)
+        tool.pop("codeExecution", None)
+        tool.pop("urlContext", None)
+
+    return [tool] if tool else []
+
+
+def _get_real_model(model: str) -> str:
+    if model.endswith("-search"):
+        model = model[:-7]
+    if model.endswith("-image"):
+        model = model[:-6]
+    if model.endswith("-non-thinking"):
+        model = model[:-13]
+    if "-search" in model and "-non-thinking" in model:
+        model = model[:-20]
+    return model
+
+
+def _get_safety_settings(model: str) -> List[Dict[str, str]]:
+    """获取安全设置"""
+    if model == "gemini-2.0-flash-exp":
+        return GEMINI_2_FLASH_EXP_SAFETY_SETTINGS
+    return settings.SAFETY_SETTINGS
+
+
+def _filter_empty_parts(contents: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Filters out contents with empty or invalid parts."""
+    if not contents:
+        return []
+
+    filtered_contents = []
+    for content in contents:
+        if (
+            not content
+            or "parts" not in content
+            or not isinstance(content.get("parts"), list)
+        ):
+            continue
+
+        valid_parts = [
+            part for part in content["parts"] if isinstance(part, dict) and part
+        ]
+
+        if valid_parts:
+            new_content = content.copy()
+            new_content["parts"] = valid_parts
+            filtered_contents.append(new_content)
+
+    return filtered_contents
+
+
+def _build_payload(model: str, request: GeminiRequest) -> Dict[str, Any]:
+    """构建请求payload"""
+    request_dict = request.model_dump(exclude_none=False)
+    if request.generationConfig:
+        if request.generationConfig.maxOutputTokens is None:
+            # 如果未指定最大输出长度，则不传递该字段，解决截断的问题
+            if "maxOutputTokens" in request_dict["generationConfig"]:
+                request_dict["generationConfig"].pop("maxOutputTokens")
+
+    # 检查是否为TTS模型
+    is_tts_model = "tts" in model.lower()
+
+    if is_tts_model:
+        # TTS模型使用简化的payload，不包含tools和safetySettings
+        payload = {
+            "contents": _filter_empty_parts(request_dict.get("contents", [])),
+            "generationConfig": request_dict.get("generationConfig"),
+        }
+
+        # 只在有systemInstruction时才添加
+        if request_dict.get("systemInstruction"):
+            payload["systemInstruction"] = request_dict.get("systemInstruction")
+    else:
+        # 非TTS模型使用完整的payload
+        payload = {
+            "contents": _filter_empty_parts(request_dict.get("contents", [])),
+            "tools": _build_tools(model, request_dict),
+            "safetySettings": _get_safety_settings(model),
+            "generationConfig": request_dict.get("generationConfig"),
+            "systemInstruction": request_dict.get("systemInstruction"),
+        }
+
+    # 确保 generationConfig 不为 None
+    if payload["generationConfig"] is None:
+        payload["generationConfig"] = {}
+
+    if model.endswith("-image") or model.endswith("-image-generation"):
+        payload.pop("systemInstruction")
+        payload["generationConfig"]["responseModalities"] = ["Text", "Image"]
+
+    # 处理思考配置：优先使用客户端提供的配置，否则使���默认配置
+    client_thinking_config = None
+    if request.generationConfig and request.generationConfig.thinkingConfig:
+        client_thinking_config = request.generationConfig.thinkingConfig
+
+    if client_thinking_config is not None:
+        # 客户端提供了思考配置，直接使用
+        payload["generationConfig"]["thinkingConfig"] = client_thinking_config
+    else:
+        # 客户端没有提供思考配置，使用默认配置
+        if model.endswith("-non-thinking"):
+            if "gemini-2.5-pro" in model:
+                payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": 128}
+            else:
+                payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": 0}
+        elif _get_real_model(model) in settings.THINKING_BUDGET_MAP:
+            if settings.SHOW_THINKING_PROCESS:
+                payload["generationConfig"]["thinkingConfig"] = {
+                    "thinkingBudget": settings.THINKING_BUDGET_MAP.get(model, 1000),
+                    "includeThoughts": True,
+                }
+            else:
+                payload["generationConfig"]["thinkingConfig"] = {
+                    "thinkingBudget": settings.THINKING_BUDGET_MAP.get(model, 1000)
+                }
+
+    return payload
+
+
+class GeminiChatService:
+    """聊天服务"""
+
+    def __init__(self, base_url: str, key_manager: KeyManager):
+        self.api_client = GeminiApiClient(base_url, settings.TIME_OUT)
+        self.key_manager = key_manager
+        self.response_handler = GeminiResponseHandler()
+
+    def _extract_text_from_response(self, response: Dict[str, Any]) -> str:
+        """从响应中提取文本内容"""
+        if not response.get("candidates"):
+            return ""
+
+        candidate = response["candidates"][0]
+        content = candidate.get("content", {})
+        parts = content.get("parts", [])
+
+        if parts and "text" in parts[0]:
+            return parts[0].get("text", "")
+        return ""
+
+    def _create_char_response(
+        self, original_response: Dict[str, Any], text: str
+    ) -> Dict[str, Any]:
+        """创建包含指定文本的响应"""
+        response_copy = json.loads(json.dumps(original_response))
+        if response_copy.get("candidates") and response_copy["candidates"][0].get(
+            "content", {}
+        ).get("parts"):
+            response_copy["candidates"][0]["content"]["parts"][0]["text"] = text
+        return response_copy
+
+    async def generate_content(
+        self, model: str, request: GeminiRequest, api_key: str
+    ) -> Dict[str, Any]:
+        """生成内容"""
+        # 檢查並獲取文件專用的 API key（如果有文件）
+        file_names = _extract_file_references(request.model_dump().get("contents", []))
+        if file_names:
+            logger.info(f"Request contains file references: {file_names}")
+            file_api_key = await get_file_api_key(file_names[0])
+            if file_api_key:
+                logger.info(
+                    f"Found API key for file {file_names[0]}: {redact_key_for_logging(file_api_key)}"
+                )
+                api_key = file_api_key  # 使用文件的 API key
+            else:
+                logger.warning(
+                    f"No API key found for file {file_names[0]}, using default key: {redact_key_for_logging(api_key)}"
+                )
+
+        payload = _build_payload(model, request)
+        start_time = time.perf_counter()
+        request_datetime = datetime.datetime.now()
+        is_success = False
+        status_code = None
+        response = None
+
+        try:
+            response = await self.api_client.generate_content(payload, model, api_key)
+            is_success = True
+            status_code = 200
+            return self.response_handler.handle_response(response, model, stream=False)
+        except Exception as e:
+            is_success = False
+            error_log_msg = str(e)
+            logger.error(f"Normal API call failed with error: {error_log_msg}")
+            match = re.search(r"status code (\d+)", error_log_msg)
+            if match:
+                status_code = int(match.group(1))
+            else:
+                status_code = 500
+
+            await add_error_log(
+                gemini_key=api_key,
+                model_name=model,
+                error_type="gemini-chat-non-stream",
+                error_log=error_log_msg,
+                error_code=status_code,
+                request_msg=payload,
+                request_datetime=request_datetime,
+            )
+            raise e
+        finally:
+            end_time = time.perf_counter()
+            latency_ms = int((end_time - start_time) * 1000)
+            await add_request_log(
+                model_name=model,
+                api_key=api_key,
+                is_success=is_success,
+                status_code=status_code,
+                latency_ms=latency_ms,
+                request_time=request_datetime,
+            )
+
+    async def count_tokens(
+        self, model: str, request: GeminiRequest, api_key: str
+    ) -> Dict[str, Any]:
+        """计算token数量"""
+        # countTokens API只需要contents
+        payload = {
+            "contents": _filter_empty_parts(request.model_dump().get("contents", []))
+        }
+        start_time = time.perf_counter()
+        request_datetime = datetime.datetime.now()
+        is_success = False
+        status_code = None
+        response = None
+
+        try:
+            response = await self.api_client.count_tokens(payload, model, api_key)
+            is_success = True
+            status_code = 200
+            return response
+        except Exception as e:
+            is_success = False
+            error_log_msg = str(e)
+            logger.error(f"Count tokens API call failed with error: {error_log_msg}")
+            match = re.search(r"status code (\d+)", error_log_msg)
+            if match:
+                status_code = int(match.group(1))
+            else:
+                status_code = 500
+
+            await add_error_log(
+                gemini_key=api_key,
+                model_name=model,
+                error_type="gemini-count-tokens",
+                error_log=error_log_msg,
+                error_code=status_code,
+                request_msg=payload,
+            )
+            raise e
+        finally:
+            end_time = time.perf_counter()
+            latency_ms = int((end_time - start_time) * 1000)
+            await add_request_log(
+                model_name=model,
+                api_key=api_key,
+                is_success=is_success,
+                status_code=status_code,
+                latency_ms=latency_ms,
+                request_time=request_datetime,
+            )
+
+    async def stream_generate_content(
+        self, model: str, request: GeminiRequest, api_key: str
+    ) -> AsyncGenerator[str, None]:
+        """流式生成内容"""
+        # 檢查並獲取文件專用的 API key（如果有文件）
+        file_names = _extract_file_references(request.model_dump().get("contents", []))
+        if file_names:
+            logger.info(f"Request contains file references: {file_names}")
+            file_api_key = await get_file_api_key(file_names[0])
+            if file_api_key:
+                logger.info(
+                    f"Found API key for file {file_names[0]}: {redact_key_for_logging(file_api_key)}"
+                )
+                api_key = file_api_key  # 使用文件的 API key
+            else:
+                logger.warning(
+                    f"No API key found for file {file_names[0]}, using default key: {redact_key_for_logging(api_key)}"
+                )
+
+        retries = 0
+        max_retries = settings.MAX_RETRIES
+        payload = _build_payload(model, request)
+        is_success = False
+        status_code = None
+        final_api_key = api_key
+
+        while retries < max_retries:
+            request_datetime = datetime.datetime.now()
+            start_time = time.perf_counter()
+            current_attempt_key = api_key
+            final_api_key = current_attempt_key
+            try:
+                async for line in self.api_client.stream_generate_content(
+                    payload, model, current_attempt_key
+                ):
+                    # print(line)
+                    if line.startswith("data:"):
+                        line = line[6:]
+                        response_data = self.response_handler.handle_response(
+                            json.loads(line), model, stream=True
+                        )
+                        text = self._extract_text_from_response(response_data)
+                        # 如果有文本内容，且开启了流式输出优化器，则使用流式输出优化器处理
+                        if text and settings.STREAM_OPTIMIZER_ENABLED:
+                            # 使用流式输出优化器处理文本输出
+                            async for (
+                                optimized_chunk
+                            ) in gemini_optimizer.optimize_stream_output(
+                                text,
+                                lambda t: self._create_char_response(response_data, t),
+                                lambda c: "data: " + json.dumps(c) + "\n\n",
+                            ):
+                                yield optimized_chunk
+                        else:
+                            # 如果没有文本内容（如工具调用等），整块输出
+                            yield "data: " + json.dumps(response_data) + "\n\n"
+                logger.info("Streaming completed successfully")
+                is_success = True
+                status_code = 200
+                break
+            except Exception as e:
+                retries += 1
+                is_success = False
+                error_log_msg = str(e)
+                logger.warning(
+                    f"Streaming API call failed with error: {error_log_msg}. Attempt {retries} of {max_retries}"
+                )
+                match = re.search(r"status code (\d+)", error_log_msg)
+                if match:
+                    status_code = int(match.group(1))
+                else:
+                    status_code = 500
+
+                await add_error_log(
+                    gemini_key=current_attempt_key,
+                    model_name=model,
+                    error_type="gemini-chat-stream",
+                    error_log=error_log_msg,
+                    error_code=status_code,
+                    request_msg=payload,
+                    request_datetime=request_datetime,
+                )
+
+                api_key = await self.key_manager.handle_api_failure(
+                    current_attempt_key, retries
+                )
+                if api_key:
+                    logger.info(
+                        f"Switched to new API key: {redact_key_for_logging(api_key)}"
+                    )
+                else:
+                    logger.error(f"No valid API key available after {retries} retries.")
+                    break
+
+                if retries >= max_retries:
+                    logger.error(f"Max retries ({max_retries}) reached for streaming.")
+                    break
+            finally:
+                end_time = time.perf_counter()
+                latency_ms = int((end_time - start_time) * 1000)
+                await add_request_log(
+                    model_name=model,
+                    api_key=final_api_key,
+                    is_success=is_success,
+                    status_code=status_code,
+                    latency_ms=latency_ms,
+                    request_time=request_datetime,
+                )

app/service/chat/openai_chat_service.py

@@ -0,0 +1,745 @@
+# app/services/chat_service.py
+
+import asyncio
+import datetime
+import json
+import re
+import time
+from copy import deepcopy
+from typing import Any, AsyncGenerator, Dict, List, Optional, Union
+
+from app.config.config import settings
+from app.core.constants import GEMINI_2_FLASH_EXP_SAFETY_SETTINGS
+from app.database.services import (
+    add_error_log,
+    add_request_log,
+)
+from app.domain.openai_models import ChatRequest, ImageGenerationRequest
+from app.handler.message_converter import OpenAIMessageConverter
+from app.handler.response_handler import OpenAIResponseHandler
+from app.handler.stream_optimizer import openai_optimizer
+from app.log.logger import get_openai_logger
+from app.service.client.api_client import GeminiApiClient
+from app.service.image.image_create_service import ImageCreateService
+from app.service.key.key_manager import KeyManager
+
+logger = get_openai_logger()
+
+
+def _has_media_parts(messages: List[Dict[str, Any]]) -> bool:
+    """判断消息是否包含多媒体部分"""
+    for message in messages:
+        if "parts" in message:
+            for part in message["parts"]:
+                if "image_url" in part or "inline_data" in part:
+                    return True
+    return False
+
+
+def _clean_json_schema_properties(obj: Any) -> Any:
+    """清理JSON Schema中Gemini API不支持的字段"""
+    if not isinstance(obj, dict):
+        return obj
+
+    # Gemini API不支持的JSON Schema字段
+    unsupported_fields = {
+        "exclusiveMaximum",
+        "exclusiveMinimum",
+        "const",
+        "examples",
+        "contentEncoding",
+        "contentMediaType",
+        "if",
+        "then",
+        "else",
+        "allOf",
+        "anyOf",
+        "oneOf",
+        "not",
+        "definitions",
+        "$schema",
+        "$id",
+        "$ref",
+        "$comment",
+        "readOnly",
+        "writeOnly",
+    }
+
+    cleaned = {}
+    for key, value in obj.items():
+        if key in unsupported_fields:
+            continue
+        if isinstance(value, dict):
+            cleaned[key] = _clean_json_schema_properties(value)
+        elif isinstance(value, list):
+            cleaned[key] = [_clean_json_schema_properties(item) for item in value]
+        else:
+            cleaned[key] = value
+
+    return cleaned
+
+
+def _build_tools(
+    request: ChatRequest, messages: List[Dict[str, Any]]
+) -> List[Dict[str, Any]]:
+    """构建工具"""
+    tool = dict()
+    model = request.model
+
+    if (
+        settings.TOOLS_CODE_EXECUTION_ENABLED
+        and not (
+            model.endswith("-search")
+            or "-thinking" in model
+            or model.endswith("-image")
+            or model.endswith("-image-generation")
+        )
+        and not _has_media_parts(messages)
+    ):
+        tool["codeExecution"] = {}
+        logger.debug("Code execution tool enabled.")
+    elif _has_media_parts(messages):
+        logger.debug("Code execution tool disabled due to media parts presence.")
+
+    if model.endswith("-search"):
+        tool["googleSearch"] = {}
+
+    real_model = _get_real_model(model)
+    if real_model in settings.URL_CONTEXT_MODELS and settings.URL_CONTEXT_ENABLED:
+        tool["urlContext"] = {}
+
+    # 将 request 中的 tools 合并到 tools 中
+    if request.tools:
+        function_declarations = []
+        for item in request.tools:
+            if not item or not isinstance(item, dict):
+                continue
+
+            if item.get("type", "") == "function" and item.get("function"):
+                function = deepcopy(item.get("function"))
+                parameters = function.get("parameters", {})
+                if parameters.get("type") == "object" and not parameters.get(
+                    "properties", {}
+                ):
+                    function.pop("parameters", None)
+
+                # 清理函数中的不支持字段
+                function = _clean_json_schema_properties(function)
+                function_declarations.append(function)
+
+        if function_declarations:
+            # 按照 function 的 name 去重
+            names, functions = set(), []
+            for fc in function_declarations:
+                if fc.get("name") not in names:
+                    if fc.get("name") == "googleSearch":
+                        # cherry开启内置搜索时，添加googleSearch工具
+                        tool["googleSearch"] = {}
+                    else:
+                        # 其他函数，添加到functionDeclarations中
+                        names.add(fc.get("name"))
+                        functions.append(fc)
+
+            tool["functionDeclarations"] = functions
+
+    # 解决 "Tool use with function calling is unsupported" 问题
+    if tool.get("functionDeclarations"):
+        tool.pop("googleSearch", None)
+        tool.pop("codeExecution", None)
+        tool.pop("urlContext", None)
+
+    return [tool] if tool else []
+
+
+def _get_real_model(model: str) -> str:
+    if model.endswith("-search"):
+        model = model[:-7]
+    if model.endswith("-image"):
+        model = model[:-6]
+    if model.endswith("-non-thinking"):
+        model = model[:-13]
+    if "-search" in model and "-non-thinking" in model:
+        model = model[:-20]
+    return model
+
+
+def _get_safety_settings(model: str) -> List[Dict[str, str]]:
+    """获取安全设置"""
+    # if (
+    #     "2.0" in model
+    #     and "gemini-2.0-flash-thinking-exp" not in model
+    #     and "gemini-2.0-pro-exp" not in model
+    # ):
+    if model == "gemini-2.0-flash-exp":
+        return GEMINI_2_FLASH_EXP_SAFETY_SETTINGS
+    return settings.SAFETY_SETTINGS
+
+
+def _validate_and_set_max_tokens(
+    payload: Dict[str, Any], max_tokens: Optional[int], logger_instance
+) -> None:
+    """验证并设置 max_tokens 参数"""
+    if max_tokens is None:
+        return
+
+    # 参数验证和处理
+    if max_tokens <= 0:
+        logger_instance.warning(
+            f"Invalid max_tokens value: {max_tokens}, will not set maxOutputTokens"
+        )
+        # 不设置 maxOutputTokens，让 Gemini API 使用默认值
+    else:
+        payload["generationConfig"]["maxOutputTokens"] = max_tokens
+
+
+def _build_payload(
+    request: ChatRequest,
+    messages: List[Dict[str, Any]],
+    instruction: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """构建请求payload"""
+    payload = {
+        "contents": messages,
+        "generationConfig": {
+            "temperature": request.temperature,
+            "stopSequences": request.stop,
+            "topP": request.top_p,
+            "topK": request.top_k,
+        },
+        "tools": _build_tools(request, messages),
+        "safetySettings": _get_safety_settings(request.model),
+    }
+
+    # 处理 max_tokens 参数
+    _validate_and_set_max_tokens(payload, request.max_tokens, logger)
+
+    # 处理 n 参数
+    if request.n is not None and request.n > 0:
+        payload["generationConfig"]["candidateCount"] = request.n
+
+    if request.model.endswith("-image") or request.model.endswith("-image-generation"):
+        payload["generationConfig"]["responseModalities"] = ["Text", "Image"]
+
+    if request.model.endswith("-non-thinking"):
+        if "gemini-2.5-pro" in request.model:
+            payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": 128}
+        else:
+            payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": 0}
+
+    elif _get_real_model(request.model) in settings.THINKING_BUDGET_MAP:
+        if settings.SHOW_THINKING_PROCESS:
+            payload["generationConfig"]["thinkingConfig"] = {
+                "thinkingBudget": settings.THINKING_BUDGET_MAP.get(request.model, 1000),
+                "includeThoughts": True,
+            }
+        else:
+            payload["generationConfig"]["thinkingConfig"] = {
+                "thinkingBudget": settings.THINKING_BUDGET_MAP.get(request.model, 1000)
+            }
+
+    if (
+        instruction
+        and isinstance(instruction, dict)
+        and instruction.get("role") == "system"
+        and instruction.get("parts")
+        and not request.model.endswith("-image")
+        and not request.model.endswith("-image-generation")
+    ):
+        payload["systemInstruction"] = instruction
+
+    return payload
+
+
+class OpenAIChatService:
+    """聊天服务"""
+
+    def __init__(self, base_url: str, key_manager: KeyManager = None):
+        self.message_converter = OpenAIMessageConverter()
+        self.response_handler = OpenAIResponseHandler(config=None)
+        self.api_client = GeminiApiClient(base_url, settings.TIME_OUT)
+        self.key_manager = key_manager
+        self.image_create_service = ImageCreateService()
+
+    def _extract_text_from_openai_chunk(self, chunk: Dict[str, Any]) -> str:
+        """从OpenAI响应块中提取文本内容"""
+        if not chunk.get("choices"):
+            return ""
+
+        choice = chunk["choices"][0]
+        if "delta" in choice and "content" in choice["delta"]:
+            return choice["delta"]["content"]
+        return ""
+
+    def _create_char_openai_chunk(
+        self, original_chunk: Dict[str, Any], text: str
+    ) -> Dict[str, Any]:
+        """创建包含指定文本的OpenAI响应块"""
+        chunk_copy = json.loads(json.dumps(original_chunk))
+        if chunk_copy.get("choices") and "delta" in chunk_copy["choices"][0]:
+            chunk_copy["choices"][0]["delta"]["content"] = text
+        return chunk_copy
+
+    async def create_chat_completion(
+        self,
+        request: ChatRequest,
+        api_key: str,
+    ) -> Union[Dict[str, Any], AsyncGenerator[str, None]]:
+        """创建聊天完成"""
+        messages, instruction = self.message_converter.convert(
+            request.messages, request.model
+        )
+
+        payload = _build_payload(request, messages, instruction)
+
+        if request.stream:
+            return self._handle_stream_completion(request.model, payload, api_key)
+        return await self._handle_normal_completion(request.model, payload, api_key)
+
+    async def _handle_normal_completion(
+        self, model: str, payload: Dict[str, Any], api_key: str
+    ) -> Dict[str, Any]:
+        """处理普通聊天完成"""
+        start_time = time.perf_counter()
+        request_datetime = datetime.datetime.now()
+        is_success = False
+        status_code = None
+        response = None
+
+        try:
+            response = await self.api_client.generate_content(payload, model, api_key)
+            usage_metadata = response.get("usageMetadata", {})
+            is_success = True
+            status_code = 200
+
+            # 尝试处理响应，捕获可能的响应处理异常
+            try:
+                result = self.response_handler.handle_response(
+                    response,
+                    model,
+                    stream=False,
+                    finish_reason="stop",
+                    usage_metadata=usage_metadata,
+                )
+                return result
+            except Exception as response_error:
+                logger.error(
+                    f"Response processing failed for model {model}: {str(response_error)}"
+                )
+
+                # 记录详细的错误信息
+                if "parts" in str(response_error):
+                    logger.error("Response structure issue - missing or invalid parts")
+                    if response.get("candidates"):
+                        candidate = response["candidates"][0]
+                        content = candidate.get("content", {})
+                        logger.error(f"Content structure: {content}")
+
+                # 重新抛出异常
+                raise response_error
+
+        except Exception as e:
+            is_success = False
+            error_log_msg = str(e)
+            logger.error(f"API call failed for model {model}: {error_log_msg}")
+
+            # 特别记录 max_tokens 相关的错误
+            gen_config = payload.get("generationConfig", {})
+            if "maxOutputTokens" in gen_config:
+                logger.error(
+                    f"Request had maxOutputTokens: {gen_config['maxOutputTokens']}"
+                )
+
+            # 如果是响应处理错误，记录更多信息
+            if "parts" in error_log_msg:
+                logger.error("This is likely a response processing error")
+
+            match = re.search(r"status code (\d+)", error_log_msg)
+            status_code = int(match.group(1)) if match else 500
+
+            await add_error_log(
+                gemini_key=api_key,
+                model_name=model,
+                error_type="openai-chat-non-stream",
+                error_log=error_log_msg,
+                error_code=status_code,
+                request_msg=payload,
+                request_datetime=request_datetime,
+            )
+            raise e
+        finally:
+            end_time = time.perf_counter()
+            latency_ms = int((end_time - start_time) * 1000)
+            logger.info(
+                f"Normal completion finished - Success: {is_success}, Latency: {latency_ms}ms"
+            )
+
+            await add_request_log(
+                model_name=model,
+                api_key=api_key,
+                is_success=is_success,
+                status_code=status_code,
+                latency_ms=latency_ms,
+                request_time=request_datetime,
+            )
+
+    async def _fake_stream_logic_impl(
+        self, model: str, payload: Dict[str, Any], api_key: str
+    ) -> AsyncGenerator[str, None]:
+        """处理伪流式 (fake stream) 的核心逻辑"""
+        logger.info(
+            f"Fake streaming enabled for model: {model}. Calling non-streaming endpoint."
+        )
+
+        api_response_task = asyncio.create_task(
+            self.api_client.generate_content(payload, model, api_key)
+        )
+
+        i = 0
+        try:
+            while not api_response_task.done():
+                i = i + 1
+                """定期发送空数据以保持连接"""
+                if i >= settings.FAKE_STREAM_EMPTY_DATA_INTERVAL_SECONDS:
+                    i = 0
+                    empty_chunk = self.response_handler.handle_response(
+                        {},
+                        model,
+                        stream=True,
+                        finish_reason="stop",
+                        usage_metadata=None,
+                    )
+                    yield f"data: {json.dumps(empty_chunk)}\n\n"
+                    logger.debug("Sent empty data chunk for fake stream heartbeat.")
+                await asyncio.sleep(1)
+        finally:
+            response = await api_response_task
+
+        if response and response.get("candidates"):
+            response = self.response_handler.handle_response(
+                response,
+                model,
+                stream=True,
+                finish_reason="stop",
+                usage_metadata=response.get("usageMetadata", {}),
+            )
+            yield f"data: {json.dumps(response)}\n\n"
+            logger.info(f"Sent full response content for fake stream: {model}")
+        else:
+            error_message = "Failed to get response from model"
+            if response and isinstance(response, dict) and response.get("error"):
+                error_details = response.get("error")
+                if isinstance(error_details, dict):
+                    error_message = error_details.get("message", error_message)
+
+            logger.error(
+                f"No candidates or error in response for fake stream model {model}: {response}"
+            )
+            error_chunk = self.response_handler.handle_response(
+                {}, model, stream=True, finish_reason="stop", usage_metadata=None
+            )
+            yield f"data: {json.dumps(error_chunk)}\n\n"
+
+    async def _real_stream_logic_impl(
+        self, model: str, payload: Dict[str, Any], api_key: str
+    ) -> AsyncGenerator[str, None]:
+        """处理真实流式 (real stream) 的核心逻辑"""
+        tool_call_flag = False
+        usage_metadata = None
+        async for line in self.api_client.stream_generate_content(
+            payload, model, api_key
+        ):
+            if line.startswith("data:"):
+                chunk_str = line[6:]
+                if not chunk_str or chunk_str.isspace():
+                    logger.debug(
+                        f"Received empty data line for model {model}, skipping."
+                    )
+                    continue
+                try:
+                    chunk = json.loads(chunk_str)
+                    usage_metadata = chunk.get("usageMetadata", {})
+                except json.JSONDecodeError:
+                    logger.error(
+                        f"Failed to decode JSON from stream for model {model}: {chunk_str}"
+                    )
+                    continue
+                openai_chunk = self.response_handler.handle_response(
+                    chunk,
+                    model,
+                    stream=True,
+                    finish_reason=None,
+                    usage_metadata=usage_metadata,
+                )
+                if openai_chunk:
+                    text = self._extract_text_from_openai_chunk(openai_chunk)
+                    if text and settings.STREAM_OPTIMIZER_ENABLED:
+                        async for (
+                            optimized_chunk_data
+                        ) in openai_optimizer.optimize_stream_output(
+                            text,
+                            lambda t: self._create_char_openai_chunk(openai_chunk, t),
+                            lambda c: f"data: {json.dumps(c)}\n\n",
+                        ):
+                            yield optimized_chunk_data
+                    else:
+                        if openai_chunk.get("choices") and openai_chunk["choices"][
+                            0
+                        ].get("delta", {}).get("tool_calls"):
+                            tool_call_flag = True
+
+                        yield f"data: {json.dumps(openai_chunk)}\n\n"
+
+        if tool_call_flag:
+            yield f"data: {json.dumps(self.response_handler.handle_response({}, model, stream=True, finish_reason='tool_calls', usage_metadata=usage_metadata))}\n\n"
+        else:
+            yield f"data: {json.dumps(self.response_handler.handle_response({}, model, stream=True, finish_reason='stop', usage_metadata=usage_metadata))}\n\n"
+
+    async def _handle_stream_completion(
+        self, model: str, payload: Dict[str, Any], api_key: str
+    ) -> AsyncGenerator[str, None]:
+        """处理流式聊天完成，添加重试逻辑和假流式支持"""
+        retries = 0
+        max_retries = settings.MAX_RETRIES
+        is_success = False
+        status_code = None
+        final_api_key = api_key
+
+        while retries < max_retries:
+            start_time = time.perf_counter()
+            request_datetime = datetime.datetime.now()
+            current_attempt_key = final_api_key
+
+            try:
+                stream_generator = None
+                if settings.FAKE_STREAM_ENABLED:
+                    logger.info(
+                        f"Using fake stream logic for model: {model}, Attempt: {retries + 1}"
+                    )
+                    stream_generator = self._fake_stream_logic_impl(
+                        model, payload, current_attempt_key
+                    )
+                else:
+                    logger.info(
+                        f"Using real stream logic for model: {model}, Attempt: {retries + 1}"
+                    )
+                    stream_generator = self._real_stream_logic_impl(
+                        model, payload, current_attempt_key
+                    )
+
+                async for chunk_data in stream_generator:
+                    yield chunk_data
+
+                yield "data: [DONE]\n\n"
+                logger.info(
+                    f"Streaming completed successfully for model: {model}, FakeStream: {settings.FAKE_STREAM_ENABLED}, Attempt: {retries + 1}"
+                )
+                is_success = True
+                status_code = 200
+                break
+
+            except Exception as e:
+                retries += 1
+                is_success = False
+                error_log_msg = str(e)
+                logger.warning(
+                    f"Streaming API call failed with error: {error_log_msg}. Attempt {retries} of {max_retries} with key {current_attempt_key}"
+                )
+
+                match = re.search(r"status code (\d+)", error_log_msg)
+                if match:
+                    status_code = int(match.group(1))
+                else:
+                    if isinstance(e, asyncio.TimeoutError):
+                        status_code = 408
+                    else:
+                        status_code = 500
+
+                await add_error_log(
+                    gemini_key=current_attempt_key,
+                    model_name=model,
+                    error_type="openai-chat-stream",
+                    error_log=error_log_msg,
+                    error_code=status_code,
+                    request_msg=payload,
+                    request_datetime=request_datetime,
+                )
+
+                if self.key_manager:
+                    new_api_key = await self.key_manager.handle_api_failure(
+                        current_attempt_key, retries
+                    )
+                    if new_api_key and new_api_key != current_attempt_key:
+                        final_api_key = new_api_key
+                        logger.info(
+                            f"Switched to new API key for next attempt: {final_api_key}"
+                        )
+                    elif not new_api_key:
+                        logger.error(
+                            f"No valid API key available after {retries} retries, ceasing attempts for this request."
+                        )
+                        break
+                else:
+                    logger.error(
+                        "KeyManager not available, cannot switch API key. Ceasing attempts for this request."
+                    )
+                    break
+
+                if retries >= max_retries:
+                    logger.error(
+                        f"Max retries ({max_retries}) reached for streaming model {model}."
+                    )
+            finally:
+                end_time = time.perf_counter()
+                latency_ms = int((end_time - start_time) * 1000)
+                await add_request_log(
+                    model_name=model,
+                    api_key=current_attempt_key,
+                    is_success=is_success,
+                    status_code=status_code,
+                    latency_ms=latency_ms,
+                    request_time=request_datetime,
+                )
+
+        if not is_success:
+            logger.error(
+                f"Streaming failed permanently for model {model} after {retries} attempts."
+            )
+            yield f"data: {json.dumps({'error': f'Streaming failed after {retries} retries.'})}\n\n"
+            yield "data: [DONE]\n\n"
+
+    async def create_image_chat_completion(
+        self, request: ChatRequest, api_key: str
+    ) -> Union[Dict[str, Any], AsyncGenerator[str, None]]:
+
+        image_generate_request = ImageGenerationRequest()
+        image_generate_request.prompt = request.messages[-1]["content"]
+        image_res = self.image_create_service.generate_images_chat(
+            image_generate_request
+        )
+
+        if request.stream:
+            return self._handle_stream_image_completion(
+                request.model, image_res, api_key
+            )
+        else:
+            return await self._handle_normal_image_completion(
+                request.model, image_res, api_key
+            )
+
+    async def _handle_stream_image_completion(
+        self, model: str, image_data: str, api_key: str
+    ) -> AsyncGenerator[str, None]:
+        logger.info(f"Starting stream image completion for model: {model}")
+        start_time = time.perf_counter()
+        request_datetime = datetime.datetime.now()
+        is_success = False
+        status_code = None
+
+        try:
+            if image_data:
+                openai_chunk = self.response_handler.handle_image_chat_response(
+                    image_data, model, stream=True, finish_reason=None
+                )
+                if openai_chunk:
+                    # 提取文本内容
+                    text = self._extract_text_from_openai_chunk(openai_chunk)
+                    if text:
+                        # 使用流式输出优化器处理文本输出
+                        async for (
+                            optimized_chunk
+                        ) in openai_optimizer.optimize_stream_output(
+                            text,
+                            lambda t: self._create_char_openai_chunk(openai_chunk, t),
+                            lambda c: f"data: {json.dumps(c)}\n\n",
+                        ):
+                            yield optimized_chunk
+                    else:
+                        # 如果没有文本内容（如图片URL等），整块输出
+                        yield f"data: {json.dumps(openai_chunk)}\n\n"
+            yield f"data: {json.dumps(self.response_handler.handle_response({}, model, stream=True, finish_reason='stop'))}\n\n"
+            logger.info(
+                f"Stream image completion finished successfully for model: {model}"
+            )
+            is_success = True
+            status_code = 200
+            yield "data: [DONE]\n\n"
+        except Exception as e:
+            is_success = False
+            error_log_msg = f"Stream image completion failed for model {model}: {e}"
+            logger.error(error_log_msg)
+            status_code = 500
+            await add_error_log(
+                gemini_key=api_key,
+                model_name=model,
+                error_type="openai-image-stream",
+                error_log=error_log_msg,
+                error_code=status_code,
+                request_msg={"image_data_truncated": image_data[:1000]},
+                request_datetime=request_datetime,
+            )
+            yield f"data: {json.dumps({'error': error_log_msg})}\n\n"
+            yield "data: [DONE]\n\n"
+        finally:
+            end_time = time.perf_counter()
+            latency_ms = int((end_time - start_time) * 1000)
+            logger.info(
+                f"Stream image completion for model {model} took {latency_ms} ms. Success: {is_success}"
+            )
+            await add_request_log(
+                model_name=model,
+                api_key=api_key,
+                is_success=is_success,
+                status_code=status_code,
+                latency_ms=latency_ms,
+                request_time=request_datetime,
+            )
+
+    async def _handle_normal_image_completion(
+        self, model: str, image_data: str, api_key: str
+    ) -> Dict[str, Any]:
+        logger.info(f"Starting normal image completion for model: {model}")
+        start_time = time.perf_counter()
+        request_datetime = datetime.datetime.now()
+        is_success = False
+        status_code = None
+        result = None
+
+        try:
+            result = self.response_handler.handle_image_chat_response(
+                image_data, model, stream=False, finish_reason="stop"
+            )
+            logger.info(
+                f"Normal image completion finished successfully for model: {model}"
+            )
+            is_success = True
+            status_code = 200
+            return result
+        except Exception as e:
+            is_success = False
+            error_log_msg = f"Normal image completion failed for model {model}: {e}"
+            logger.error(error_log_msg)
+            status_code = 500
+            await add_error_log(
+                gemini_key=api_key,
+                model_name=model,
+                error_type="openai-image-non-stream",
+                error_log=error_log_msg,
+                error_code=status_code,
+                request_msg={"image_data_truncated": image_data[:1000]},
+                request_datetime=request_datetime,
+            )
+            raise e
+        finally:
+            end_time = time.perf_counter()
+            latency_ms = int((end_time - start_time) * 1000)
+            logger.info(
+                f"Normal image completion for model {model} took {latency_ms} ms. Success: {is_success}"
+            )
+            await add_request_log(
+                model_name=model,
+                api_key=api_key,
+                is_success=is_success,
+                status_code=status_code,
+                latency_ms=latency_ms,
+                request_time=request_datetime,
+            )

app/service/chat/vertex_express_chat_service.py

@@ -0,0 +1,403 @@
+# app/services/chat_service.py
+
+import datetime
+import json
+import re
+import time
+from typing import Any, AsyncGenerator, Dict, List
+
+from app.config.config import settings
+from app.core.constants import GEMINI_2_FLASH_EXP_SAFETY_SETTINGS
+from app.database.services import add_error_log, add_request_log
+from app.domain.gemini_models import GeminiRequest
+from app.handler.response_handler import GeminiResponseHandler
+from app.handler.stream_optimizer import gemini_optimizer
+from app.log.logger import get_gemini_logger
+from app.service.client.api_client import GeminiApiClient
+from app.service.key.key_manager import KeyManager
+from app.utils.helpers import redact_key_for_logging
+
+logger = get_gemini_logger()
+
+
+def _has_image_parts(contents: List[Dict[str, Any]]) -> bool:
+    """判断消息是否包含图片部分"""
+    for content in contents:
+        if "parts" in content:
+            for part in content["parts"]:
+                if "image_url" in part or "inline_data" in part:
+                    return True
+    return False
+
+
+def _clean_json_schema_properties(obj: Any) -> Any:
+    """清理JSON Schema中Gemini API不支持的字段"""
+    if not isinstance(obj, dict):
+        return obj
+
+    # Gemini API不支持的JSON Schema字段
+    unsupported_fields = {
+        "exclusiveMaximum",
+        "exclusiveMinimum",
+        "const",
+        "examples",
+        "contentEncoding",
+        "contentMediaType",
+        "if",
+        "then",
+        "else",
+        "allOf",
+        "anyOf",
+        "oneOf",
+        "not",
+        "definitions",
+        "$schema",
+        "$id",
+        "$ref",
+        "$comment",
+        "readOnly",
+        "writeOnly",
+    }
+
+    cleaned = {}
+    for key, value in obj.items():
+        if key in unsupported_fields:
+            continue
+        if isinstance(value, dict):
+            cleaned[key] = _clean_json_schema_properties(value)
+        elif isinstance(value, list):
+            cleaned[key] = [_clean_json_schema_properties(item) for item in value]
+        else:
+            cleaned[key] = value
+
+    return cleaned
+
+
+def _build_tools(model: str, payload: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """构建工具"""
+
+    def _has_function_call(contents: List[Dict[str, Any]]) -> bool:
+        """检查内容中是否包含 functionCall"""
+        if not contents or not isinstance(contents, list):
+            return False
+        for content in contents:
+            if not content or not isinstance(content, dict) or "parts" not in content:
+                continue
+            parts = content.get("parts", [])
+            if not parts or not isinstance(parts, list):
+                continue
+            for part in parts:
+                if isinstance(part, dict) and "functionCall" in part:
+                    return True
+        return False
+
+    def _merge_tools(tools: List[Dict[str, Any]]) -> Dict[str, Any]:
+        record = dict()
+        for item in tools:
+            if not item or not isinstance(item, dict):
+                continue
+
+            for k, v in item.items():
+                if k == "functionDeclarations" and v and isinstance(v, list):
+                    functions = record.get("functionDeclarations", [])
+                    # 清理每个函数声明中的不支持字段
+                    cleaned_functions = []
+                    for func in v:
+                        if isinstance(func, dict):
+                            cleaned_func = _clean_json_schema_properties(func)
+                            cleaned_functions.append(cleaned_func)
+                        else:
+                            cleaned_functions.append(func)
+                    functions.extend(cleaned_functions)
+                    record["functionDeclarations"] = functions
+                else:
+                    record[k] = v
+        return record
+
+    def _is_structured_output_request(payload: Dict[str, Any]) -> bool:
+        """检查请求是否要求结构化JSON输出"""
+        try:
+            generation_config = payload.get("generationConfig", {})
+            return generation_config.get("responseMimeType") == "application/json"
+        except (AttributeError, TypeError):
+            return False
+
+    tool = dict()
+    if payload and isinstance(payload, dict) and "tools" in payload:
+        if payload.get("tools") and isinstance(payload.get("tools"), dict):
+            payload["tools"] = [payload.get("tools")]
+        items = payload.get("tools", [])
+        if items and isinstance(items, list):
+            tool.update(_merge_tools(items))
+
+    # "Tool use with a response mime type: 'application/json' is unsupported"
+    # Gemini API限制：不支持同时使用tools和结构化输出(response_mime_type='application/json')
+    # 当请求指定了JSON响应格式时，跳过所有工具的添加以避免API错误
+    has_structured_output = _is_structured_output_request(payload)
+    if not has_structured_output:
+        if (
+            settings.TOOLS_CODE_EXECUTION_ENABLED
+            and not (model.endswith("-search") or "-thinking" in model)
+            and not _has_image_parts(payload.get("contents", []))
+        ):
+            tool["codeExecution"] = {}
+
+        if model.endswith("-search"):
+            tool["googleSearch"] = {}
+
+        real_model = _get_real_model(model)
+        if real_model in settings.URL_CONTEXT_MODELS and settings.URL_CONTEXT_ENABLED:
+            tool["urlContext"] = {}
+
+    # 解决 "Tool use with function calling is unsupported" 问题
+    if tool.get("functionDeclarations") or _has_function_call(
+        payload.get("contents", [])
+    ):
+        tool.pop("googleSearch", None)
+        tool.pop("codeExecution", None)
+        tool.pop("urlContext", None)
+
+    return [tool] if tool else []
+
+
+def _get_real_model(model: str) -> str:
+    if model.endswith("-search"):
+        model = model[:-7]
+    if model.endswith("-image"):
+        model = model[:-6]
+    if model.endswith("-non-thinking"):
+        model = model[:-13]
+    if "-search" in model and "-non-thinking" in model:
+        model = model[:-20]
+    return model
+
+
+def _get_safety_settings(model: str) -> List[Dict[str, str]]:
+    """获取安全设置"""
+    if model == "gemini-2.0-flash-exp":
+        return GEMINI_2_FLASH_EXP_SAFETY_SETTINGS
+    return settings.SAFETY_SETTINGS
+
+
+def _build_payload(model: str, request: GeminiRequest) -> Dict[str, Any]:
+    """构建请求payload"""
+    request_dict = request.model_dump(exclude_none=False)
+    if request.generationConfig:
+        if request.generationConfig.maxOutputTokens is None:
+            # 如果未指定最大输出长度，则不传递该字段，解决截断的问题
+            request_dict["generationConfig"].pop("maxOutputTokens")
+
+    payload = {
+        "contents": request_dict.get("contents", []),
+        "tools": _build_tools(model, request_dict),
+        "safetySettings": _get_safety_settings(model),
+        "generationConfig": request_dict.get("generationConfig"),
+        "systemInstruction": request_dict.get("systemInstruction"),
+    }
+
+    if model.endswith("-image") or model.endswith("-image-generation"):
+        payload.pop("systemInstruction")
+        payload["generationConfig"]["responseModalities"] = ["Text", "Image"]
+
+    # 处理思考配置：优先使用客户端提供的配置，否则使用默认配置
+    client_thinking_config = None
+    if request.generationConfig and request.generationConfig.thinkingConfig:
+        client_thinking_config = request.generationConfig.thinkingConfig
+
+    if client_thinking_config is not None:
+        # 客户端提供了思考配置，直接使用
+        payload["generationConfig"]["thinkingConfig"] = client_thinking_config
+    else:
+        # 客户端没有提供思考配置，使用默认配置
+        if model.endswith("-non-thinking"):
+            if "gemini-2.5-pro" in model:
+                payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": 128}
+            else:
+                payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": 0}
+        elif _get_real_model(model) in settings.THINKING_BUDGET_MAP:
+            if settings.SHOW_THINKING_PROCESS:
+                payload["generationConfig"]["thinkingConfig"] = {
+                    "thinkingBudget": settings.THINKING_BUDGET_MAP.get(model, 1000),
+                    "includeThoughts": True,
+                }
+            else:
+                payload["generationConfig"]["thinkingConfig"] = {
+                    "thinkingBudget": settings.THINKING_BUDGET_MAP.get(model, 1000)
+                }
+
+    return payload
+
+
+class GeminiChatService:
+    """聊天服务"""
+
+    def __init__(self, base_url: str, key_manager: KeyManager):
+        self.api_client = GeminiApiClient(base_url, settings.TIME_OUT)
+        self.key_manager = key_manager
+        self.response_handler = GeminiResponseHandler()
+
+    def _extract_text_from_response(self, response: Dict[str, Any]) -> str:
+        """从响应中提取文本内容"""
+        if not response.get("candidates"):
+            return ""
+
+        candidate = response["candidates"][0]
+        content = candidate.get("content", {})
+        parts = content.get("parts", [])
+
+        if parts and "text" in parts[0]:
+            return parts[0].get("text", "")
+        return ""
+
+    def _create_char_response(
+        self, original_response: Dict[str, Any], text: str
+    ) -> Dict[str, Any]:
+        """创建包含指定文本的响应"""
+        response_copy = json.loads(json.dumps(original_response))  # 深拷贝
+        if response_copy.get("candidates") and response_copy["candidates"][0].get(
+            "content", {}
+        ).get("parts"):
+            response_copy["candidates"][0]["content"]["parts"][0]["text"] = text
+        return response_copy
+
+    async def generate_content(
+        self, model: str, request: GeminiRequest, api_key: str
+    ) -> Dict[str, Any]:
+        """生成内容"""
+        payload = _build_payload(model, request)
+        start_time = time.perf_counter()
+        request_datetime = datetime.datetime.now()
+        is_success = False
+        status_code = None
+        response = None
+
+        try:
+            response = await self.api_client.generate_content(payload, model, api_key)
+            is_success = True
+            status_code = 200
+            return self.response_handler.handle_response(response, model, stream=False)
+        except Exception as e:
+            is_success = False
+            error_log_msg = str(e)
+            logger.error(f"Normal API call failed with error: {error_log_msg}")
+            match = re.search(r"status code (\d+)", error_log_msg)
+            if match:
+                status_code = int(match.group(1))
+            else:
+                status_code = 500
+
+            await add_error_log(
+                gemini_key=api_key,
+                model_name=model,
+                error_type="gemini-chat-non-stream",
+                error_log=error_log_msg,
+                error_code=status_code,
+                request_msg=payload,
+                request_datetime=request_datetime,
+            )
+            raise e
+        finally:
+            end_time = time.perf_counter()
+            latency_ms = int((end_time - start_time) * 1000)
+            await add_request_log(
+                model_name=model,
+                api_key=api_key,
+                is_success=is_success,
+                status_code=status_code,
+                latency_ms=latency_ms,
+                request_time=request_datetime,
+            )
+
+    async def stream_generate_content(
+        self, model: str, request: GeminiRequest, api_key: str
+    ) -> AsyncGenerator[str, None]:
+        """流式生成内容"""
+        retries = 0
+        max_retries = settings.MAX_RETRIES
+        payload = _build_payload(model, request)
+        is_success = False
+        status_code = None
+        final_api_key = api_key
+
+        while retries < max_retries:
+            request_datetime = datetime.datetime.now()
+            start_time = time.perf_counter()
+            current_attempt_key = api_key
+            final_api_key = current_attempt_key  # Update final key used
+            try:
+                async for line in self.api_client.stream_generate_content(
+                    payload, model, current_attempt_key
+                ):
+                    # print(line)
+                    if line.startswith("data:"):
+                        line = line[6:]
+                        response_data = self.response_handler.handle_response(
+                            json.loads(line), model, stream=True
+                        )
+                        text = self._extract_text_from_response(response_data)
+                        # 如果有文本内容，且开启了流式输出优化器，则使用流式输出优化器处理
+                        if text and settings.STREAM_OPTIMIZER_ENABLED:
+                            # 使用流式输出优化器处理文本输出
+                            async for (
+                                optimized_chunk
+                            ) in gemini_optimizer.optimize_stream_output(
+                                text,
+                                lambda t: self._create_char_response(response_data, t),
+                                lambda c: "data: " + json.dumps(c) + "\n\n",
+                            ):
+                                yield optimized_chunk
+                        else:
+                            # 如果没有文本内容（如工具调用等），整块输出
+                            yield "data: " + json.dumps(response_data) + "\n\n"
+                logger.info("Streaming completed successfully")
+                is_success = True
+                status_code = 200
+                break
+            except Exception as e:
+                retries += 1
+                is_success = False
+                error_log_msg = str(e)
+                logger.warning(
+                    f"Streaming API call failed with error: {error_log_msg}. Attempt {retries} of {max_retries}"
+                )
+                match = re.search(r"status code (\d+)", error_log_msg)
+                if match:
+                    status_code = int(match.group(1))
+                else:
+                    status_code = 500
+
+                await add_error_log(
+                    gemini_key=current_attempt_key,
+                    model_name=model,
+                    error_type="gemini-chat-stream",
+                    error_log=error_log_msg,
+                    error_code=status_code,
+                    request_msg=payload,
+                    request_datetime=request_datetime,
+                )
+
+                api_key = await self.key_manager.handle_api_failure(
+                    current_attempt_key, retries
+                )
+                if api_key:
+                    logger.info(
+                        f"Switched to new API key: {redact_key_for_logging(api_key)}"
+                    )
+                else:
+                    logger.error(f"No valid API key available after {retries} retries.")
+                    break
+
+                if retries >= max_retries:
+                    logger.error(f"Max retries ({max_retries}) reached for streaming.")
+                    break
+            finally:
+                end_time = time.perf_counter()
+                latency_ms = int((end_time - start_time) * 1000)
+                await add_request_log(
+                    model_name=model,
+                    api_key=final_api_key,
+                    is_success=is_success,
+                    status_code=status_code,
+                    latency_ms=latency_ms,
+                    request_time=request_datetime,
+                )

app/service/client/api_client.py

@@ -0,0 +1,356 @@
+# app/services/chat/api_client.py
+
+from typing import Dict, Any, AsyncGenerator, Optional
+import httpx
+import random
+from abc import ABC, abstractmethod
+from app.config.config import settings
+from app.log.logger import get_api_client_logger
+from app.core.constants import DEFAULT_TIMEOUT
+
+logger = get_api_client_logger()
+
+class ApiClient(ABC):
+    """API客户端基类"""
+
+    @abstractmethod
+    async def generate_content(self, payload: Dict[str, Any], model: str, api_key: str) -> Dict[str, Any]:
+        pass
+
+    @abstractmethod
+    async def stream_generate_content(self, payload: Dict[str, Any], model: str, api_key: str) -> AsyncGenerator[str, None]:
+        pass
+
+
+class GeminiApiClient(ApiClient):
+    """Gemini API客户端"""
+
+    def __init__(self, base_url: str, timeout: int = DEFAULT_TIMEOUT):
+        self.base_url = base_url
+        self.timeout = timeout
+
+    def _get_real_model(self, model: str) -> str:
+        if model.endswith("-search"):
+            model = model[:-7]
+        if model.endswith("-image"):
+            model = model[:-6]
+        if model.endswith("-non-thinking"):
+            model = model[:-13]
+        if "-search" in model and "-non-thinking" in model:
+            model = model[:-20]
+        return model
+
+    def _prepare_headers(self) -> Dict[str, str]:
+        headers = {}
+        if settings.CUSTOM_HEADERS:
+            headers.update(settings.CUSTOM_HEADERS)
+            logger.info(f"Using custom headers: {settings.CUSTOM_HEADERS}")
+        return headers
+
+    async def get_models(self, api_key: str) -> Optional[Dict[str, Any]]:
+        """获取可用的 Gemini 模型列表"""
+        timeout = httpx.Timeout(timeout=5)
+        
+        proxy_to_use = None
+        if settings.PROXIES:
+            if settings.PROXIES_USE_CONSISTENCY_HASH_BY_API_KEY:
+                proxy_to_use = settings.PROXIES[hash(api_key) % len(settings.PROXIES)]
+            else:
+                proxy_to_use = random.choice(settings.PROXIES)
+            logger.info(f"Using proxy for getting models: {proxy_to_use}")
+
+        headers = self._prepare_headers()
+        async with httpx.AsyncClient(timeout=timeout, proxy=proxy_to_use) as client:
+            url = f"{self.base_url}/models?key={api_key}&pageSize=1000"
+            try:
+                response = await client.get(url, headers=headers)
+                response.raise_for_status()
+                return response.json()
+            except httpx.HTTPStatusError as e:
+                logger.error(f"获取模型列表失败: {e.response.status_code}")
+                logger.error(e.response.text)
+                return None
+            except httpx.RequestError as e:
+                logger.error(f"请求模型列表失败: {e}")
+                return None
+            
+    async def generate_content(self, payload: Dict[str, Any], model: str, api_key: str) -> Dict[str, Any]:
+        timeout = httpx.Timeout(self.timeout, read=self.timeout)
+        model = self._get_real_model(model)
+        
+        proxy_to_use = None
+        if settings.PROXIES:
+            if settings.PROXIES_USE_CONSISTENCY_HASH_BY_API_KEY:
+                proxy_to_use = settings.PROXIES[hash(api_key) % len(settings.PROXIES)]
+            else:
+                proxy_to_use = random.choice(settings.PROXIES)
+            logger.info(f"Using proxy for getting models: {proxy_to_use}")
+            
+        headers = self._prepare_headers()
+        
+        async with httpx.AsyncClient(timeout=timeout, proxy=proxy_to_use) as client:
+            url = f"{self.base_url}/models/{model}:generateContent?key={api_key}"
+            
+            try:
+                response = await client.post(url, json=payload, headers=headers)
+                
+                if response.status_code != 200:
+                    error_content = response.text
+                    logger.error(f"API call failed - Status: {response.status_code}, Content: {error_content}")
+                    raise Exception(f"API call failed with status code {response.status_code}, {error_content}")
+                
+                response_data = response.json()
+                
+                # 检查响应结构的基本信息
+                if not response_data.get("candidates"):
+                    logger.warning("No candidates found in API response")
+                
+                return response_data
+                
+            except httpx.TimeoutException as e:
+                logger.error(f"Request timeout: {e}")
+                raise Exception(f"Request timeout: {e}")
+            except httpx.RequestError as e:
+                logger.error(f"Request error: {e}")
+                raise Exception(f"Request error: {e}")
+            except Exception as e:
+                logger.error(f"Unexpected error: {e}")
+                raise
+
+    async def stream_generate_content(self, payload: Dict[str, Any], model: str, api_key: str) -> AsyncGenerator[str, None]:
+        timeout = httpx.Timeout(self.timeout, read=self.timeout)
+        model = self._get_real_model(model)
+        
+        proxy_to_use = None
+        if settings.PROXIES:
+            if settings.PROXIES_USE_CONSISTENCY_HASH_BY_API_KEY:
+                proxy_to_use = settings.PROXIES[hash(api_key) % len(settings.PROXIES)]
+            else:
+                proxy_to_use = random.choice(settings.PROXIES)
+            logger.info(f"Using proxy for getting models: {proxy_to_use}")
+
+        headers = self._prepare_headers()
+        async with httpx.AsyncClient(timeout=timeout, proxy=proxy_to_use) as client:
+            url = f"{self.base_url}/models/{model}:streamGenerateContent?alt=sse&key={api_key}"
+            async with client.stream(method="POST", url=url, json=payload, headers=headers) as response:
+                if response.status_code != 200:
+                    error_content = await response.aread()
+                    error_msg = error_content.decode("utf-8")
+                    raise Exception(f"API call failed with status code {response.status_code}, {error_msg}")
+                async for line in response.aiter_lines():
+                    yield line
+
+    async def count_tokens(self, payload: Dict[str, Any], model: str, api_key: str) -> Dict[str, Any]:
+        timeout = httpx.Timeout(self.timeout, read=self.timeout)
+        model = self._get_real_model(model)
+
+        proxy_to_use = None
+        if settings.PROXIES:
+            if settings.PROXIES_USE_CONSISTENCY_HASH_BY_API_KEY:
+                proxy_to_use = settings.PROXIES[hash(api_key) % len(settings.PROXIES)]
+            else:
+                proxy_to_use = random.choice(settings.PROXIES)
+            logger.info(f"Using proxy for counting tokens: {proxy_to_use}")
+
+        headers = self._prepare_headers()
+        async with httpx.AsyncClient(timeout=timeout, proxy=proxy_to_use) as client:
+            url = f"{self.base_url}/models/{model}:countTokens?key={api_key}"
+            response = await client.post(url, json=payload, headers=headers)
+            if response.status_code != 200:
+                error_content = response.text
+                raise Exception(f"API call failed with status code {response.status_code}, {error_content}")
+            return response.json()
+
+    async def embed_content(self, payload: Dict[str, Any], model: str, api_key: str) -> Dict[str, Any]:
+        """单一嵌入内容生成"""
+        timeout = httpx.Timeout(self.timeout, read=self.timeout)
+        model = self._get_real_model(model)
+        
+        proxy_to_use = None
+        if settings.PROXIES:
+            if settings.PROXIES_USE_CONSISTENCY_HASH_BY_API_KEY:
+                proxy_to_use = settings.PROXIES[hash(api_key) % len(settings.PROXIES)]
+            else:
+                proxy_to_use = random.choice(settings.PROXIES)
+            logger.info(f"Using proxy for embedding: {proxy_to_use}")
+
+        headers = self._prepare_headers()
+        async with httpx.AsyncClient(timeout=timeout, proxy=proxy_to_use) as client:
+            url = f"{self.base_url}/models/{model}:embedContent?key={api_key}"
+            
+            try:
+                response = await client.post(url, json=payload, headers=headers)
+                
+                if response.status_code != 200:
+                    error_content = response.text
+                    logger.error(f"Embedding API call failed - Status: {response.status_code}, Content: {error_content}")
+                    raise Exception(f"API call failed with status code {response.status_code}, {error_content}")
+                
+                return response.json()
+                
+            except httpx.TimeoutException as e:
+                logger.error(f"Embedding request timeout: {e}")
+                raise Exception(f"Request timeout: {e}")
+            except httpx.RequestError as e:
+                logger.error(f"Embedding request error: {e}")
+                raise Exception(f"Request error: {e}")
+            except Exception as e:
+                logger.error(f"Unexpected embedding error: {e}")
+                raise
+
+    async def batch_embed_contents(self, payload: Dict[str, Any], model: str, api_key: str) -> Dict[str, Any]:
+        """批量嵌入内容生成"""
+        timeout = httpx.Timeout(self.timeout, read=self.timeout)
+        model = self._get_real_model(model)
+        
+        proxy_to_use = None
+        if settings.PROXIES:
+            if settings.PROXIES_USE_CONSISTENCY_HASH_BY_API_KEY:
+                proxy_to_use = settings.PROXIES[hash(api_key) % len(settings.PROXIES)]
+            else:
+                proxy_to_use = random.choice(settings.PROXIES)
+            logger.info(f"Using proxy for batch embedding: {proxy_to_use}")
+
+        headers = self._prepare_headers()
+        async with httpx.AsyncClient(timeout=timeout, proxy=proxy_to_use) as client:
+            url = f"{self.base_url}/models/{model}:batchEmbedContents?key={api_key}"
+            
+            try:
+                response = await client.post(url, json=payload, headers=headers)
+                
+                if response.status_code != 200:
+                    error_content = response.text
+                    logger.error(f"Batch embedding API call failed - Status: {response.status_code}, Content: {error_content}")
+                    raise Exception(f"API call failed with status code {response.status_code}, {error_content}")
+                
+                return response.json()
+                
+            except httpx.TimeoutException as e:
+                logger.error(f"Batch embedding request timeout: {e}")
+                raise Exception(f"Request timeout: {e}")
+            except httpx.RequestError as e:
+                logger.error(f"Batch embedding request error: {e}")
+                raise Exception(f"Request error: {e}")
+            except Exception as e:
+                logger.error(f"Unexpected batch embedding error: {e}")
+                raise
+
+
+class OpenaiApiClient(ApiClient):
+    """OpenAI API客户端"""
+
+    def __init__(self, base_url: str, timeout: int = DEFAULT_TIMEOUT):
+        self.base_url = base_url
+        self.timeout = timeout
+        
+    def _prepare_headers(self, api_key: str) -> Dict[str, str]:
+        headers = {"Authorization": f"Bearer {api_key}"}
+        if settings.CUSTOM_HEADERS:
+            headers.update(settings.CUSTOM_HEADERS)
+            logger.info(f"Using custom headers: {settings.CUSTOM_HEADERS}")
+        return headers
+
+    async def get_models(self, api_key: str) -> Dict[str, Any]:
+        timeout = httpx.Timeout(self.timeout, read=self.timeout)
+
+        proxy_to_use = None
+        if settings.PROXIES:
+            if settings.PROXIES_USE_CONSISTENCY_HASH_BY_API_KEY:
+                proxy_to_use = settings.PROXIES[hash(api_key) % len(settings.PROXIES)]
+            else:
+                proxy_to_use = random.choice(settings.PROXIES)
+            logger.info(f"Using proxy for getting models: {proxy_to_use}")
+
+        headers = self._prepare_headers(api_key)
+        async with httpx.AsyncClient(timeout=timeout, proxy=proxy_to_use) as client:
+            url = f"{self.base_url}/openai/models"
+            response = await client.get(url, headers=headers)
+            if response.status_code != 200:
+                error_content = response.text
+                raise Exception(f"API call failed with status code {response.status_code}, {error_content}")
+            return response.json()
+
+    async def generate_content(self, payload: Dict[str, Any], api_key: str) -> Dict[str, Any]:
+        timeout = httpx.Timeout(self.timeout, read=self.timeout)
+        logger.info(f"settings.PROXIES_USE_CONSISTENCY_HASH_BY_API_KEY: {settings.PROXIES_USE_CONSISTENCY_HASH_BY_API_KEY}")
+        proxy_to_use = None
+        if settings.PROXIES:
+            if settings.PROXIES_USE_CONSISTENCY_HASH_BY_API_KEY:
+                proxy_to_use = settings.PROXIES[hash(api_key) % len(settings.PROXIES)]
+            else:
+                proxy_to_use = random.choice(settings.PROXIES)
+            logger.info(f"Using proxy for getting models: {proxy_to_use}")
+
+        headers = self._prepare_headers(api_key)
+        async with httpx.AsyncClient(timeout=timeout, proxy=proxy_to_use) as client:
+            url = f"{self.base_url}/openai/chat/completions"
+            response = await client.post(url, json=payload, headers=headers)
+            if response.status_code != 200:
+                error_content = response.text
+                raise Exception(f"API call failed with status code {response.status_code}, {error_content}")
+            return response.json()
+
+    async def stream_generate_content(self, payload: Dict[str, Any], api_key: str) -> AsyncGenerator[str, None]:
+        timeout = httpx.Timeout(self.timeout, read=self.timeout)
+        proxy_to_use = None
+        if settings.PROXIES:
+            if settings.PROXIES_USE_CONSISTENCY_HASH_BY_API_KEY:
+                proxy_to_use = settings.PROXIES[hash(api_key) % len(settings.PROXIES)]
+            else:
+                proxy_to_use = random.choice(settings.PROXIES)
+            logger.info(f"Using proxy for getting models: {proxy_to_use}")
+
+        headers = self._prepare_headers(api_key)
+        async with httpx.AsyncClient(timeout=timeout, proxy=proxy_to_use) as client:
+            url = f"{self.base_url}/openai/chat/completions"
+            async with client.stream(method="POST", url=url, json=payload, headers=headers) as response:
+                if response.status_code != 200:
+                    error_content = await response.aread()
+                    error_msg = error_content.decode("utf-8")
+                    raise Exception(f"API call failed with status code {response.status_code}, {error_msg}")
+                async for line in response.aiter_lines():
+                    yield line
+    
+    async def create_embeddings(self, input: str, model: str, api_key: str) -> Dict[str, Any]:
+        timeout = httpx.Timeout(self.timeout, read=self.timeout)
+        
+        proxy_to_use = None
+        if settings.PROXIES:
+            if settings.PROXIES_USE_CONSISTENCY_HASH_BY_API_KEY:
+                proxy_to_use = settings.PROXIES[hash(api_key) % len(settings.PROXIES)]
+            else:
+                proxy_to_use = random.choice(settings.PROXIES)
+            logger.info(f"Using proxy for getting models: {proxy_to_use}")
+
+        headers = self._prepare_headers(api_key)
+        async with httpx.AsyncClient(timeout=timeout, proxy=proxy_to_use) as client:
+            url = f"{self.base_url}/openai/embeddings"
+            payload = {
+                "input": input,
+                "model": model,
+            }
+            response = await client.post(url, json=payload, headers=headers)
+            if response.status_code != 200:
+                error_content = response.text
+                raise Exception(f"API call failed with status code {response.status_code}, {error_content}")
+            return response.json()
+                    
+    async def generate_images(self, payload: Dict[str, Any], api_key: str) -> Dict[str, Any]:
+        timeout = httpx.Timeout(self.timeout, read=self.timeout)
+
+        proxy_to_use = None
+        if settings.PROXIES:
+            if settings.PROXIES_USE_CONSISTENCY_HASH_BY_API_KEY:
+                proxy_to_use = settings.PROXIES[hash(api_key) % len(settings.PROXIES)]
+            else:
+                proxy_to_use = random.choice(settings.PROXIES)
+            logger.info(f"Using proxy for getting models: {proxy_to_use}")
+
+        headers = self._prepare_headers(api_key)
+        async with httpx.AsyncClient(timeout=timeout, proxy=proxy_to_use) as client:
+            url = f"{self.base_url}/openai/images/generations"
+            response = await client.post(url, json=payload, headers=headers)
+            if response.status_code != 200:
+                error_content = response.text
+                raise Exception(f"API call failed with status code {response.status_code}, {error_content}")
+            return response.json()

app/service/config/config_service.py

@@ -0,0 +1,261 @@
+"""
+配置服务模块
+"""
+
+import datetime
+import json
+from typing import Any, Dict, List
+
+from dotenv import find_dotenv, load_dotenv
+from fastapi import HTTPException
+from sqlalchemy import insert, update
+
+from app.config.config import Settings as ConfigSettings
+from app.config.config import settings
+from app.database.connection import database
+from app.database.models import Settings
+from app.database.services import get_all_settings
+from app.log.logger import get_config_routes_logger
+from app.service.key.key_manager import (
+    get_key_manager_instance,
+    reset_key_manager_instance,
+)
+from app.service.model.model_service import ModelService
+
+logger = get_config_routes_logger()
+
+
+class ConfigService:
+    """配置服务类，用于管理应用程序配置"""
+
+    @staticmethod
+    async def get_config() -> Dict[str, Any]:
+        return settings.model_dump()
+
+    @staticmethod
+    async def update_config(config_data: Dict[str, Any]) -> Dict[str, Any]:
+        for key, value in config_data.items():
+            if hasattr(settings, key):
+                setattr(settings, key, value)
+                logger.debug(f"Updated setting in memory: {key}")
+
+        # 获取现有设置
+        existing_settings_raw: List[Dict[str, Any]] = await get_all_settings()
+        existing_settings_map: Dict[str, Dict[str, Any]] = {
+            s["key"]: s for s in existing_settings_raw
+        }
+        existing_keys = set(existing_settings_map.keys())
+
+        settings_to_update: List[Dict[str, Any]] = []
+        settings_to_insert: List[Dict[str, Any]] = []
+        now = datetime.datetime.now(datetime.timezone(datetime.timedelta(hours=8)))
+
+        # 准备要更新或插入的数据
+        for key, value in config_data.items():
+            # 处理不同类型的值
+            if isinstance(value, list):
+                db_value = json.dumps(value)
+            elif isinstance(value, dict):
+                db_value = json.dumps(value)
+            elif isinstance(value, bool):
+                db_value = str(value).lower()
+            else:
+                db_value = str(value)
+
+            # 仅当值发生变化时才更新
+            if key in existing_keys and existing_settings_map[key]["value"] == db_value:
+                continue
+
+            description = f"{key}配置项"
+
+            data = {
+                "key": key,
+                "value": db_value,
+                "description": description,
+                "updated_at": now,
+            }
+
+            if key in existing_keys:
+                data["description"] = existing_settings_map[key].get(
+                    "description", description
+                )
+                settings_to_update.append(data)
+            else:
+                data["created_at"] = now
+                settings_to_insert.append(data)
+
+        # 在事务中执行批量插入和更新
+        if settings_to_insert or settings_to_update:
+            try:
+                async with database.transaction():
+                    if settings_to_insert:
+                        query_insert = insert(Settings).values(settings_to_insert)
+                        await database.execute(query=query_insert)
+                        logger.info(
+                            f"Bulk inserted {len(settings_to_insert)} settings."
+                        )
+
+                    if settings_to_update:
+                        for setting_data in settings_to_update:
+                            query_update = (
+                                update(Settings)
+                                .where(Settings.key == setting_data["key"])
+                                .values(
+                                    value=setting_data["value"],
+                                    description=setting_data["description"],
+                                    updated_at=setting_data["updated_at"],
+                                )
+                            )
+                            await database.execute(query=query_update)
+                        logger.info(f"Updated {len(settings_to_update)} settings.")
+            except Exception as e:
+                logger.error(f"Failed to bulk update/insert settings: {str(e)}")
+                raise
+
+        # 重置并重新初始化 KeyManager
+        try:
+            await reset_key_manager_instance()
+            await get_key_manager_instance(settings.API_KEYS, settings.VERTEX_API_KEYS)
+            logger.info("KeyManager instance re-initialized with updated settings.")
+        except Exception as e:
+            logger.error(f"Failed to re-initialize KeyManager: {str(e)}")
+
+        return await ConfigService.get_config()
+
+    @staticmethod
+    async def delete_key(key_to_delete: str) -> Dict[str, Any]:
+        """删除单个API密钥"""
+        # 确保 settings.API_KEYS 是一个列表
+        if not isinstance(settings.API_KEYS, list):
+            settings.API_KEYS = []
+
+        original_keys_count = len(settings.API_KEYS)
+        # 创建一个不包含待删除密钥的新列表
+        updated_api_keys = [k for k in settings.API_KEYS if k != key_to_delete]
+
+        if len(updated_api_keys) < original_keys_count:
+            # 密钥已找到并从列表中移除
+            settings.API_KEYS = updated_api_keys  # 首先更新内存中的 settings
+            # 使用 update_config 持久化更改，它同时处理数据库和 KeyManager
+            await ConfigService.update_config({"API_KEYS": settings.API_KEYS})
+            logger.info(f"密钥 '{key_to_delete}' 已成功删除。")
+            return {"success": True, "message": f"密钥 '{key_to_delete}' 已成功删除。"}
+        else:
+            # 未找到密钥
+            logger.warning(f"尝试删除密钥 '{key_to_delete}'，但未找到该密钥。")
+            return {"success": False, "message": f"未找到密钥 '{key_to_delete}'。"}
+
+    @staticmethod
+    async def delete_selected_keys(keys_to_delete: List[str]) -> Dict[str, Any]:
+        """批量删除选定的API密钥"""
+        if not isinstance(settings.API_KEYS, list):
+            settings.API_KEYS = []
+
+        deleted_count = 0
+        not_found_keys: List[str] = []
+
+        current_api_keys = list(settings.API_KEYS)
+        keys_actually_removed: List[str] = []
+
+        for key_to_del in keys_to_delete:
+            if key_to_del in current_api_keys:
+                current_api_keys.remove(key_to_del)
+                keys_actually_removed.append(key_to_del)
+                deleted_count += 1
+            else:
+                not_found_keys.append(key_to_del)
+
+        if deleted_count > 0:
+            settings.API_KEYS = current_api_keys
+            await ConfigService.update_config({"API_KEYS": settings.API_KEYS})
+            logger.info(
+                f"成功删除 {deleted_count} 个密钥。密钥: {keys_actually_removed}"
+            )
+            message = f"成功删除 {deleted_count} 个密钥。"
+            if not_found_keys:
+                message += f" {len(not_found_keys)} 个密钥未找到: {not_found_keys}。"
+            return {
+                "success": True,
+                "message": message,
+                "deleted_count": deleted_count,
+                "not_found_keys": not_found_keys,
+            }
+        else:
+            message = "没有密钥被删除。"
+            if not_found_keys:
+                message = f"所有 {len(not_found_keys)} 个指定的密钥均未找到: {not_found_keys}。"
+            elif not keys_to_delete:
+                message = "未指定要删除的密钥。"
+            logger.warning(message)
+            return {
+                "success": False,
+                "message": message,
+                "deleted_count": 0,
+                "not_found_keys": not_found_keys,
+            }
+
+    @staticmethod
+    async def reset_config() -> Dict[str, Any]:
+        """
+        重置配置：优先从系统环境变量加载，然后从 .env 文件加载，
+        更新内存中的 settings 对象，并刷新 KeyManager。
+
+        Returns:
+            Dict[str, Any]: 重置后的配置字典
+        """
+        # 1. 重新加载配置对象，它应该处理环境变量和 .env 的优先级
+        _reload_settings()
+        logger.info(
+            "Settings object reloaded, prioritizing system environment variables then .env file."
+        )
+
+        # 2. 重置并重新初始化 KeyManager
+        try:
+            await reset_key_manager_instance()
+            # 确保使用更新后的 settings 中的 API_KEYS
+            await get_key_manager_instance(settings.API_KEYS)
+            logger.info("KeyManager instance re-initialized with reloaded settings.")
+        except Exception as e:
+            logger.error(f"Failed to re-initialize KeyManager during reset: {str(e)}")
+            # 根据需要决定是否抛出异常或继续
+            # 这里选择记录错误并继续
+
+        # 3. 返回更新后的配置
+        return await ConfigService.get_config()
+
+    @staticmethod
+    async def fetch_ui_models() -> List[Dict[str, Any]]:
+        """获取用于UI显示的模型列表"""
+        try:
+            key_manager = await get_key_manager_instance()
+            model_service = ModelService()
+
+            api_key = await key_manager.get_random_valid_key()
+            if not api_key:
+                logger.error("No valid API keys available to fetch model list for UI.")
+                raise HTTPException(
+                    status_code=500,
+                    detail="No valid API keys available to fetch model list.",
+                )
+
+            models = await model_service.get_gemini_openai_models(api_key)
+            return models
+        except HTTPException as e:
+            raise e
+        except Exception as e:
+            logger.error(
+                f"Failed to fetch models for UI in ConfigService: {e}", exc_info=True
+            )
+            raise HTTPException(
+                status_code=500, detail=f"Failed to fetch models for UI: {str(e)}"
+            )
+
+
+# 重新加载配置的函数
+def _reload_settings():
+    """重新加载环境变量并更新配置"""
+    # 显式加载 .env 文件，覆盖现有环境变量
+    load_dotenv(find_dotenv(), override=True)
+    # 更新现有 settings 对象的属性，而不是新建实例
+    for key, value in ConfigSettings().model_dump().items():
+        setattr(settings, key, value)

app/service/embedding/embedding_service.py

@@ -0,0 +1,87 @@
+import datetime
+import re
+import time
+from typing import List, Union
+
+import openai
+from openai import APIStatusError
+from openai.types import CreateEmbeddingResponse
+
+from app.config.config import settings
+from app.database.services import add_error_log, add_request_log
+from app.log.logger import get_embeddings_logger
+
+logger = get_embeddings_logger()
+
+
+class EmbeddingService:
+
+    async def create_embedding(
+        self, input_text: Union[str, List[str]], model: str, api_key: str
+    ) -> CreateEmbeddingResponse:
+        """Create embeddings using OpenAI API with database logging"""
+        start_time = time.perf_counter()
+        request_datetime = datetime.datetime.now()
+        is_success = False
+        status_code = None
+        response = None
+        error_log_msg = ""
+        if isinstance(input_text, list):
+            request_msg_log = {
+                "input_truncated": [
+                    str(item)[:100] + "..." if len(str(item)) > 100 else str(item)
+                    for item in input_text[:5]
+                ]
+            }
+            if len(input_text) > 5:
+                request_msg_log["input_truncated"].append("...")
+        else:
+            request_msg_log = {
+                "input_truncated": (
+                    input_text[:1000] + "..." if len(input_text) > 1000 else input_text
+                )
+            }
+
+        try:
+            client = openai.OpenAI(api_key=api_key, base_url=settings.BASE_URL)
+            response = client.embeddings.create(input=input_text, model=model)
+            is_success = True
+            status_code = 200
+            return response
+        except APIStatusError as e:
+            is_success = False
+            status_code = e.status_code
+            error_log_msg = f"OpenAI API error: {e}"
+            logger.error(f"Error creating embedding (APIStatusError): {error_log_msg}")
+            raise e
+        except Exception as e:
+            is_success = False
+            error_log_msg = f"Generic error: {e}"
+            logger.error(f"Error creating embedding (Exception): {error_log_msg}")
+            match = re.search(r"status code (\d+)", str(e))
+            if match:
+                status_code = int(match.group(1))
+            else:
+                status_code = 500
+            raise e
+        finally:
+            end_time = time.perf_counter()
+            latency_ms = int((end_time - start_time) * 1000)
+            if not is_success:
+                await add_error_log(
+                    gemini_key=api_key,
+                    model_name=model,
+                    error_type="openai-embedding",
+                    error_log=error_log_msg,
+                    error_code=status_code,
+                    request_msg=request_msg_log,
+                    request_datetime=request_datetime,
+                )
+            await add_request_log(
+                model_name=model,
+                api_key=api_key,
+                is_success=is_success,
+                status_code=status_code,
+                latency_ms=latency_ms,
+                request_time=request_datetime,
+            )

app/service/embedding/gemini_embedding_service.py

@@ -0,0 +1,150 @@
+# app/service/embedding/gemini_embedding_service.py
+
+import datetime
+import re
+import time
+from typing import Any, Dict
+
+from app.config.config import settings
+from app.database.services import add_error_log, add_request_log
+from app.domain.gemini_models import GeminiBatchEmbedRequest, GeminiEmbedRequest
+from app.log.logger import get_gemini_embedding_logger
+from app.service.client.api_client import GeminiApiClient
+from app.service.key.key_manager import KeyManager
+
+logger = get_gemini_embedding_logger()
+
+
+def _build_embed_payload(request: GeminiEmbedRequest) -> Dict[str, Any]:
+    """构建嵌入请求payload"""
+    payload = {"content": request.content.model_dump()}
+
+    if request.taskType:
+        payload["taskType"] = request.taskType
+    if request.title:
+        payload["title"] = request.title
+    if request.outputDimensionality:
+        payload["outputDimensionality"] = request.outputDimensionality
+
+    return payload
+
+
+def _build_batch_embed_payload(
+    request: GeminiBatchEmbedRequest, model: str
+) -> Dict[str, Any]:
+    """构建批量嵌入请求payload"""
+    requests = []
+    for embed_request in request.requests:
+        embed_payload = _build_embed_payload(embed_request)
+        embed_payload["model"] = (
+            f"models/{model}"  # Gemini API要求每个请求包含model字段
+        )
+        requests.append(embed_payload)
+
+    return {"requests": requests}
+
+
+class GeminiEmbeddingService:
+    """Gemini嵌入服务"""
+
+    def __init__(self, base_url: str, key_manager: KeyManager):
+        self.api_client = GeminiApiClient(base_url, settings.TIME_OUT)
+        self.key_manager = key_manager
+
+    async def embed_content(
+        self, model: str, request: GeminiEmbedRequest, api_key: str
+    ) -> Dict[str, Any]:
+        """生成单一嵌入内容"""
+        payload = _build_embed_payload(request)
+        start_time = time.perf_counter()
+        request_datetime = datetime.datetime.now()
+        is_success = False
+        status_code = None
+        response = None
+
+        try:
+            response = await self.api_client.embed_content(payload, model, api_key)
+            is_success = True
+            status_code = 200
+            return response
+        except Exception as e:
+            is_success = False
+            error_log_msg = str(e)
+            logger.error(f"Single embedding API call failed: {error_log_msg}")
+            match = re.search(r"status code (\d+)", error_log_msg)
+            if match:
+                status_code = int(match.group(1))
+            else:
+                status_code = 500
+
+            await add_error_log(
+                gemini_key=api_key,
+                model_name=model,
+                error_type="gemini-embed-single",
+                error_log=error_log_msg,
+                error_code=status_code,
+                request_msg=payload,
+                request_datetime=request_datetime,
+            )
+            raise e
+        finally:
+            end_time = time.perf_counter()
+            latency_ms = int((end_time - start_time) * 1000)
+            await add_request_log(
+                model_name=model,
+                api_key=api_key,
+                is_success=is_success,
+                status_code=status_code,
+                latency_ms=latency_ms,
+                request_time=request_datetime,
+            )
+
+    async def batch_embed_contents(
+        self, model: str, request: GeminiBatchEmbedRequest, api_key: str
+    ) -> Dict[str, Any]:
+        """生成批量嵌入内容"""
+        payload = _build_batch_embed_payload(request, model)
+        start_time = time.perf_counter()
+        request_datetime = datetime.datetime.now()
+        is_success = False
+        status_code = None
+        response = None
+
+        try:
+            response = await self.api_client.batch_embed_contents(
+                payload, model, api_key
+            )
+            is_success = True
+            status_code = 200
+            return response
+        except Exception as e:
+            is_success = False
+            error_log_msg = str(e)
+            logger.error(f"Batch embedding API call failed: {error_log_msg}")
+            match = re.search(r"status code (\d+)", error_log_msg)
+            if match:
+                status_code = int(match.group(1))
+            else:
+                status_code = 500
+
+            await add_error_log(
+                gemini_key=api_key,
+                model_name=model,
+                error_type="gemini-embed-batch",
+                error_log=error_log_msg,
+                error_code=status_code,
+                request_msg=payload,
+                request_datetime=request_datetime,
+            )
+            raise e
+        finally:
+            end_time = time.perf_counter()
+            latency_ms = int((end_time - start_time) * 1000)
+            await add_request_log(
+                model_name=model,
+                api_key=api_key,
+                is_success=is_success,
+                status_code=status_code,
+                latency_ms=latency_ms,
+                request_time=request_datetime,
+            )