chore: 更新版本号至 2.1.9

- 修改了 response_handler.py 中的 _handle_openai_stream_response 和 _handle_openai_normal_response 方法，增加了对推理内容 (reasoning_content) 的支持。
- 更新了 _extract_result 方法的返回值，确保能够提取推理内容。
- 在 gemini_chat_service.py 和 openai_chat_service.py 中，调整了生成配置以包含思考过程的选项。
- 在 vertex_express_chat_service.py 中，增强了对客户端思考配置的处理逻辑，确保优先使用客户端提供的配置。

.env.example

@@ -10,6 +10,10 @@ MYSQL_DATABASE=default_db
 API_KEYS=["AIzaSyxxxxxxxxxxxxxxxxxxx","AIzaSyxxxxxxxxxxxxxxxxxxx"]
 ALLOWED_TOKENS=["sk-123456"]
 AUTH_TOKEN=sk-123456
+# For Vertex AI Platform API Keys
+VERTEX_API_KEYS=["AQ.Abxxxxxxxxxxxxxxxxxxx"]
+# For Vertex AI Platform Express API Base URL
+VERTEX_EXPRESS_BASE_URL=https://aiplatform.googleapis.com/v1beta1/publishers/google
 TEST_MODEL=gemini-1.5-flash
 THINKING_MODELS=["gemini-2.5-flash-preview-04-17"]
 THINKING_BUDGET_MAP={"gemini-2.5-flash-preview-04-17": 4000}
@@ -29,6 +33,8 @@ TIME_OUT=300
 # 代理服务器配置 (支持 http 和 socks5)
 # 示例: PROXIES=["http://user:pass@host:port", "socks5://host:port"]
 PROXIES=[]
+# 对同一个API_KEY使用代理列表中固定的IP策略
+PROXIES_USE_CONSISTENCY_HASH_BY_API_KEY=true
 #########################image_generate 相关配置###########################
 PAID_KEY=AIzaSyxxxxxxxxxxxxxxxxxxx
 CREATE_IMAGE_MODEL=imagen-3.0-generate-002
@@ -37,6 +43,7 @@ SMMS_SECRET_TOKEN=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 PICGO_API_KEY=xxxx
 CLOUDFLARE_IMGBED_URL=https://xxxxxxx.pages.dev/upload
 CLOUDFLARE_IMGBED_AUTH_CODE=xxxxxxxxx
+CLOUDFLARE_IMGBED_UPLOAD_FOLDER=
 ##########################################################################
 #########################stream_optimizer 相关配置########################
 STREAM_OPTIMIZER_ENABLED=false
@@ -60,9 +67,16 @@ AUTO_DELETE_REQUEST_LOGS_DAYS=30
 ##########################################################################
 
 # 假流式配置 (Fake Streaming Configuration)
-FAKE_STREAM_ENABLED=True  # 是否启用假流式输出
-FAKE_STREAM_EMPTY_DATA_INTERVAL_SECONDS=5  # 假流式发送空数据的间隔时间（秒）
+# 是否启用假流式输出
+FAKE_STREAM_ENABLED=True
+# 假流式发送空数据的间隔时间（秒）
+FAKE_STREAM_EMPTY_DATA_INTERVAL_SECONDS=5
 
 # 安全设置 (JSON 字符串格式)
 # 注意：这里的示例值可能需要根据实际模型支持情况调整
-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"}]'
+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"}]
+URL_NORMALIZATION_ENABLED=false
+# tts配置
+TTS_MODEL=gemini-2.5-flash-preview-tts
+TTS_VOICE_NAME=Zephyr
+TTS_SPEED=normal

.github/workflows/release.yml

@@ -3,7 +3,7 @@ name: Publish Release
 on:
   push:
     tags:
-      - 'v*' # 当推送以 "v" 开头的标签时触发（如 v1.0.0, v2.1.0）
+      - "v*" # 当推送以 "v" 开头的标签时触发（如 v1.0.0, v2.1.0）
 
 jobs:
   update-release-draft:
@@ -15,8 +15,17 @@ jobs:
       # Step 1: 检出代码库
       - name: Checkout code
         uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
 
-      # Step 2: 自动生成 Release
+      # Step 2: 自动生成 Release Notes
+      - name: Generate release notes
+        id: changelog
+        uses: mikepenz/release-changelog-builder-action@v4
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      # Step 3: 自动生成 Release
       - name: Create Release
         id: create_release
         uses: actions/create-release@v1
@@ -25,15 +34,16 @@ jobs:
         with:
           tag_name: ${{ github.ref_name }}
           release_name: ${{ github.ref_name }}
+          body: ${{ steps.changelog.outputs.changelog }}
           draft: false
           prerelease: false
-      
-      # Step 3: 可选，构建zip文件
+
+      # Step 4: 可选，构建zip文件
       - name: Create ZIP file
         run: |
           zip -r gemini-balance.zip . -x "*.git*" "*.github*" "*.env*" "logs/*" "tests/*"
 
-      # Step 4: 可选，上传构建文件
+      # Step 5: 可选，上传构建文件
       - name: Upload Release Asset
         uses: actions/upload-release-asset@v1
         env:
@@ -41,5 +51,5 @@ jobs:
         with:
           upload_url: ${{ steps.create_release.outputs.upload_url }}
           asset_path: ./gemini-balance.zip # 替换为你的构建文件路径
-          asset_name: gemini-balance.zip  # 替换为你的文件名
+          asset_name: gemini-balance.zip # 替换为你的文件名
           asset_content_type: application/zip

Dockerfile

@@ -14,6 +14,8 @@ ENV BASE_URL=https://generativelanguage.googleapis.com/v1beta
 ENV TOOLS_CODE_EXECUTION_ENABLED=false
 ENV IMAGE_MODELS='["gemini-2.0-flash-exp"]'
 ENV SEARCH_MODELS='["gemini-2.0-flash-exp","gemini-2.0-pro-exp"]'
+ENV URL_NORMALIZATION_ENABLED=false
+ENV CLOUDFLARE_IMGBED_UPLOAD_FOLDER=""
 
 # Expose port
 EXPOSE 8000

README.md

@@ -1,266 +1,293 @@
-# Gemini Balance - Gemini API 代理和负载均衡器
+[Read this document in Chinese](README_ZH.md)
 
-> ⚠️ 本项目采用 CC BY-NC 4.0（署名-非商业性使用）协议，禁止任何形式的商业倒卖服务，详见 LICENSE 文件。
+# 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>
+
+> ⚠️ This project is licensed under the CC BY-NC 4.0 (Attribution-NonCommercial) license. Any form of commercial resale service is prohibited. See the LICENSE file for details.
+
+> I have never sold this service on any platform. If you encounter someone selling this service, they are definitely a reseller. Please be careful not to be deceived.
 
 [![Python](https://img.shields.io/badge/Python-3.9%2B-blue.svg)](https://www.python.org/)
 [![FastAPI](https://img.shields.io/badge/FastAPI-0.100%2B-green.svg)](https://fastapi.tiangolo.com/)
 [![Uvicorn](https://img.shields.io/badge/Uvicorn-running-purple.svg)](https://www.uvicorn.org/)
 [![Telegram Group](https://img.shields.io/badge/Telegram-Group-blue.svg?logo=telegram)](https://t.me/+soaHax5lyI0wZDVl)
-> 交流群：https://t.me/+soaHax5lyI0wZDVl
 
-## 项目简介
+> Telegram Group: <https://t.me/+soaHax5lyI0wZDVl>
 
-Gemini Balance 是一个基于 Python FastAPI 构建的应用程序，旨在提供 Google Gemini API 的代理和负载均衡功能。它允许您管理多个 Gemini API Key，并通过简单的配置实现 Key 的轮询、认证、模型过滤和状态监控。此外，项目还集成了图像生成和多种图床上传功能，并支持 OpenAI API 格式的代理。
+## 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.
+
+**Project Structure:**
 
 ```plaintext
 app/
-├── config/       # 配置管理
-├── core/         # 核心应用逻辑 (FastAPI 实例创建, 中间件等)
-├── database/     # 数据库模型和连接
-├── domain/       # 业务领域对象 (可选)
-├── exception/    # 自定义异常
-├── handler/      # 请求处理器 (可选, 或在 router 中处理)
-├── log/          # 日志配置
-├── main.py       # 应用入口
-├── middleware/   # FastAPI 中间件
-├── router/       # API 路由 (Gemini, OpenAI, 状态页等)
-├── scheduler/    # 定时任务 (如 Key 状态检查)
-├── service/      # 业务逻辑服务 (聊天, Key 管理, 统计等)
-├── static/       # 静态文件 (CSS, JS)
-├── templates/    # HTML 模板 (如 Key 状态页)
-├── utils/        # 工具函数
+├── config/       # Configuration management
+├── core/         # Core application logic (FastAPI instance creation, middleware, etc.)
+├── database/     # Database models and connections
+├── domain/       # Business domain objects (optional)
+├── exception/    # Custom exceptions
+├── handler/      # Request handlers (optional, or handled in router)
+├── 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
 ```
 
-## ✨ 功能亮点
+## ✨ Feature Highlights
 
-* **多 Key 负载均衡**: 支持配置多个 Gemini API Key (`API_KEYS`)，自动按顺序轮询使用，提高可用性和并发能力。
-* **可视化配置即时生效**: 通过管理后台修改配置后，无需重启服务即可生效，切记要点击保存才会生效。
-![配置面板](files/image4.png)
-* **双协议API 兼容**: 同时支持 Gemini 和 OpenAI 格式的 CHAT API 请求转发。
+* **Multi-Key Load Balancing**: Supports configuring multiple Gemini API Keys (`API_KEYS`) for automatic sequential polling, improving availability and concurrency.
+* **Visual Configuration Takes Effect Immediately**: Configurations modified through the admin backend take effect without restarting the service. Remember to click save for changes to apply.
+    ![Configuration Panel](files/image4.png)
+* **Dual Protocol API Compatibility**: Supports forwarding CHAT API requests in both Gemini and OpenAI formats.
 
-    ```palintext
+    ```plaintext
     openai baseurl `http://localhost:8000(/hf)/v1`
     gemini baseurl `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代理**: 支持自定义gemini代理，比如自行在deno或者cloudflare上搭建gemini代理
-* **openai画图接口兼容**: 将`imagen-3.0-generate-002`模型接口改造成openai画图接口，支持客户端调用。
-* **灵活的添加密钥方式**: 灵活的添加密钥方式，采用正则匹配`gemini_key`,密钥去重
-![添加密钥](files/image5.png)
-* **兼容openai格式embeddings接口**：完美适配openai格式的`embeddings`接口，可用于本地文档向量化。
-* **流式响应优化**: 可选的流式输出优化器 (`STREAM_OPTIMIZER_ENABLED`)，改善长文本流式响应的体验。
-* **失败重试与 Key 管理**: 自动处理 API 请求失败，进行重试 (`MAX_RETRIES`)，并在 Key 失效次数过多时自动禁用 (`MAX_FAILURES`)，定时检查恢复 (`CHECK_INTERVAL_HOURS`)。
-* **Docker 支持**: 支持AMD，ARM架构的docker部署，也可自行构建docker镜像。
-    >镜像地址: docker pull ghcr.io/snailyp/gemini-balance:latest
-* **模型列表自动维护**: 支持openai和gemini模型列表获取，与newapi自动获取模型列表完美兼容，无需手动填写。
-* **支持移除不使用的模型**: 默认提供的模型太多，很多用不上，可以通过`FILTERED_MODELS`过滤掉。
-* **代理支持**: 支持配置 HTTP/SOCKS5 代理服务器 (`PROXIES`)，用于访问 Gemini API，方便在特殊网络环境下使用。支持批量添加代理。
+* **Supports Image-Text Chat and Image Modification**: `IMAGE_MODELS` configures which models can perform image-text chat and image editing. When actually calling, use the `configured_model-image` model name to use this feature.
+    ![Chat with Image Generation](files/image6.png)
+    ![Modify Image](files/image7.png)
+* **Supports Web Search**: Supports web search. `SEARCH_MODELS` configures which models can perform web searches. When actually calling, use the `configured_model-search` model name to use this feature.
+    ![Web Search](files/image8.png)
+* **Key Status Monitoring**: Provides a `/keys_status` page (requires authentication) to view the status and usage of each Key in real-time.
+    ![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)
+* **Support for Custom Gemini Proxy**: Supports custom Gemini proxies, such as those built on Deno or Cloudflare.
+* **OpenAI Image Generation API Compatibility**: Adapts the `imagen-3.0-generate-002` model interface to be compatible with the OpenAI image generation API, supporting client calls.
+* **Flexible Key Addition**: Flexible way to add keys using regex matching for `gemini_key`, with key deduplication.
+    ![Add Key](files/image5.png)
+* **OpenAI Format Embeddings API Compatibility**: Perfectly adapts to the OpenAI format `embeddings` interface, usable for local document vectorization.
+* **Streamlined Response Optimization**: Optional stream output optimizer (`STREAM_OPTIMIZER_ENABLED`) to improve the experience of long-text stream responses.
+* **Failure Retry and Key Management**: Automatically handles API request failures, retries (`MAX_RETRIES`), automatically disables Keys after too many failures (`MAX_FAILURES`), and periodically checks for recovery (`CHECK_INTERVAL_HOURS`).
+* **Docker Support**: Supports AMD and ARM architecture Docker deployments. You can also build your own Docker image.
+    > Image address: docker pull ghcr.io/snailyp/gemini-balance:latest
+* **Automatic Model List Maintenance**: Supports fetching OpenAI and Gemini model lists, perfectly compatible with NewAPI's automatic model list fetching, no manual entry required.
+* **Support for Removing Unused Models**: Too many default models are provided, many of which are not used. You can filter them out using `FILTERED_MODELS`.
+* **Proxy Support**: Supports configuring HTTP/SOCKS5 proxy servers (`PROXIES`) for accessing the Gemini API, convenient for use in special network environments. Supports batch adding proxies.
 
-## 🚀 快速开始
+## 🚀 Quick Start
 
-### 自行构建 Docker (推荐)
+### Build Docker Yourself (Recommended)
 
-#### a) dockerfile构建
+#### a) Build with Dockerfile
 
-1. **构建镜像**:
+1. **Build Image**:
 
     ```bash
     docker build -t gemini-balance .
     ```
 
-2. **运行容器**:
+2. **Run Container**:
 
     ```bash
     docker run -d -p 8000:8000 --env-file .env gemini-balance
     ```
 
-    * `-d`: 后台运行。
-    * `-p 8000:8000`: 将容器的 8000 端口映射到主机的 8000 端口。
-    * `--env-file .env`: 使用 `.env` 文件设置环境变量。
+    * `-d`: Run in detached mode.
+    * `-p 8000:8000`: Map port 8000 of the container to port 8000 of the host.
+    * `--env-file .env`: Use the `.env` file to set environment variables.
 
-    > 注意：如果使用 SQLite 数据库，需要挂载数据卷以持久化数据：
+    > Note: If using an SQLite database, you need to mount a data volume to persist
+>
     > ```bash
     > docker run -d -p 8000:8000 --env-file .env -v /path/to/data:/app/data gemini-balance
     > ```
-    > 其中 `/path/to/data` 是主机上的数据存储路径，`/app/data` 是容器内的数据目录。
+>
+    > Where `/path/to/data` is the data storage path on the host, and `/app/data` is the data directory inside the container.
 
-#### b) 用现有的docker镜像部署
+#### b) Deploy with an Existing Docker Image
 
-1. **拉取镜像**:
+1. **Pull Image**:
 
-   ```bash
-   docker pull ghcr.io/snailyp/gemini-balance:latest
-   ```
+    ```bash
+    docker pull ghcr.io/snailyp/gemini-balance:latest
+    ```
 
-2. **运行容器**:
+2. **Run Container**:
 
-   ```bash
-   docker run -d -p 8000:8000 --env-file .env ghcr.io/snailyp/gemini-balance:latest
-   ```
+    ```bash
+    docker run -d -p 8000:8000 --env-file .env ghcr.io/snailyp/gemini-balance:latest
+    ```
 
-   * `-d`: 后台运行。
-   * `-p 8000:8000`: 将容器的 8000 端口映射到主机的 8000 端口 (根据需要调整)。
-   * `--env-file .env`: 使用 `.env` 文件设置环境变量 (确保 `.env` 文件存在于执行命令的目录)。
+    * `-d`: Run in detached mode.
+    * `-p 8000:8000`: Map port 8000 of the container to port 8000 of the host (adjust as needed).
+    * `--env-file .env`: Use the `.env` file to set environment variables (ensure the `.env` file exists in the directory where the command is executed).
 
-    > 注意：如果使用 SQLite 数据库，需要挂载数据卷以持久化数据：
+    > Note: If using an SQLite database, you need to mount a data volume to persist
+>
     > ```bash
     > docker run -d -p 8000:8000 --env-file .env -v /path/to/data:/app/data ghcr.io/snailyp/gemini-balance:latest
     > ```
-    > 其中 `/path/to/data` 是主机上的数据存储路径，`/app/data` 是容器内的数据目录。
+>
+    > Where `/path/to/data` is the data storage path on the host, and `/app/data` is the data directory inside the container.
 
-### 本地运行 (适用于开发和测试)
+### Run Locally (Suitable for Development and Testing)
 
-如果您想在本地直接运行源代码进行开发或测试，请按照以下步骤操作：
+If you want to run the source code directly locally for development or testing, follow these steps:
 
-1. **确保已完成准备工作**:
-    * 克隆仓库到本地。
-    * 安装 Python 3.9 或更高版本。
-    * 在项目根目录下创建并配置好 `.env` 文件 (参考前面的"配置环境变量"部分)。
-    * 安装项目依赖：
+1. **Ensure Prerequisites are Met**:
+    * Clone the repository locally.
+    * Install Python 3.9 or higher.
+    * Create and configure the `.env` file in the project root directory (refer to the "Configure Environment Variables" section above).
+    * Install project dependencies:
 
         ```bash
         pip install -r requirements.txt
         ```
 
-2. **启动应用**:
-    在项目根目录下运行以下命令：
+2. **Start Application**:
+    Run the following command in the project root directory:
 
     ```bash
     uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload
     ```
 
-    * `app.main:app`: 指定 FastAPI 应用实例的位置 (`app` 模块中的 `main.py` 文件里的 `app` 对象)。
-    * `--host 0.0.0.0`: 使应用可以从本地网络中的任何 IP 地址访问。
-    * `--port 8000`: 指定应用监听的端口号 (您可以根据需要修改)。
-    * `--reload`: 启用自动重载功能。当您修改代码时，服务会自动重启，非常适合开发环境 (生产环境请移除此选项)。
+    * `app.main:app`: Specifies the location of the FastAPI application instance (the `app` object in the `main.py` file within the `app` module).
+    * `--host 0.0.0.0`: Makes the application accessible from any IP address on the local network.
+    * `--port 8000`: Specifies the port number the application listens on (you can change this as needed).
+    * `--reload`: Enables automatic reloading. When you modify the code, the service will automatically restart, which is very suitable for development environments (remove this option in production environments).
 
-3. **访问应用**:
-    应用启动后，您可以通过浏览器或 API 工具访问 `http://localhost:8000` (或您指定的主机和端口)。
+3. **Access Application**:
+    After the application starts, you can access `http://localhost:8000` (or the host and port you specified) through a browser or API tool.
 
-### 完整配置项列表
+### Complete Configuration List
 
-| 配置项                       | 说明                                                     | 默认值                             |
-| :--------------------------- | :------------------------------------------------------- | :---------------------------------------------------- |
-| **数据库配置**               |                                                          |                                                       |
-| `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 密钥列表，用于负载均衡                        | `["your-gemini-api-key-1", "your-gemini-api-key-2"]`  |
-| `ALLOWED_TOKENS`             | 必填，允许访问的 Token 列表                                    | `["your-access-token-1", "your-access-token-2"]`      |
-| `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`            | 可选，被禁用的模型列表                                         | `["gemini-1.0-pro-vision-latest", ...]`               |
-| `TOOLS_CODE_EXECUTION_ENABLED` | 可选，是否启用代码执行工具                                     | `false`                                               |
-| `SHOW_SEARCH_LINK`           | 可选，是否在响应中显示搜索结果链接                             | `true`                                                |
-| `SHOW_THINKING_PROCESS`      | 可选，是否显示模型思考过程                                     | `true`                                                |
-| `THINKING_MODELS`            | 可选，支持思考功能的模型列表                                   | `[]`                                                  |
-| `THINKING_BUDGET_MAP`        | 可选，思考功能预算映射 (模型名:预算值)                         | `{}`                                                  |
-| `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`, `socks5://host:port`) | `[]`                                                  |
-| `LOG_LEVEL`                  | 可选，日志级别，例如 DEBUG, INFO, WARNING, ERROR, CRITICAL     | `INFO`                                                |
-| `AUTO_DELETE_ERROR_LOGS_ENABLED` | 可选，是否开启自动删除错误日志                                 | `true`                                                |
-| `AUTO_DELETE_ERROR_LOGS_DAYS`  | 可选，自动删除多少天前的错误日志 (例如 1, 7, 30)             | `7`                                                   |
-| `AUTO_DELETE_REQUEST_LOGS_ENABLED`| 可选，是否开启自动删除请求日志                               | `false`                                               |
-| `AUTO_DELETE_REQUEST_LOGS_DAYS` | 可选，自动删除多少天前的请求日志 (例如 1, 7, 30)           | `30`                                                  |
-| `SAFETY_SETTINGS`            | 可选，安全设置 (JSON 字符串格式)，用于配置内容安全阈值。示例值可能需要根据实际模型支持情况调整。 | `[{"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"}]` |
-| **图像生成相关**             |                                                          |                                                       |
-| `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`                                  |
-| `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`                    |
-| **流式优化器相关**           |                                                          |                                                       |
-| `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`                                                   |
+| Configuration Item             | Description                                                                 | Default Value                                                                                                                                                                                                                            |
+| :----------------------------- | :-------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Database Configuration**     |                                                                             |                                                                                                                                                                                                                                          |
+| `DATABASE_TYPE`                | Optional, database type, supports `mysql` or `sqlite`                       | `mysql`                                                                                                                                                                                                                                  |
+| `SQLITE_DATABASE`              | Optional, required when using `sqlite`, SQLite database file path           | `default_db`                                                                                                                                                                                                                             |
+| `MYSQL_HOST`                   | Required when using `mysql`, MySQL database host address                    | `localhost`                                                                                                                                                                                                                              |
+| `MYSQL_SOCKET`                 | Optional, MySQL database socket address                                     | `/var/run/mysqld/mysqld.sock`                                                                                                                                                                                                            |
+| `MYSQL_PORT`                   | Required when using `mysql`, MySQL database port                            | `3306`                                                                                                                                                                                                                                   |
+| `MYSQL_USER`                   | Required when using `mysql`, MySQL database username                        | `your_db_user`                                                                                                                                                                                                                           |
+| `MYSQL_PASSWORD`               | Required when using `mysql`, MySQL database password                        | `your_db_password`                                                                                                                                                                                                                       |
+| `MYSQL_DATABASE`               | Required when using `mysql`, MySQL database name                            | `defaultdb`                                                                                                                                                                                                                              |
+| **API Related Configuration**  |                                                                             |                                                                                                                                                                                                                                          |
+| `API_KEYS`                     | Required, list of Gemini API keys for load balancing                        | `["your-gemini-api-key-1", "your-gemini-api-key-2"]`                                                                                                                                                                                     |
+| `ALLOWED_TOKENS`               | Required, list of tokens allowed to access                                  | `["your-access-token-1", "your-access-token-2"]`                                                                                                                                                                                         |
+| `AUTH_TOKEN`                   | Optional, super admin token with all permissions, defaults to the first of `ALLOWED_TOKENS` if not set | `sk-123456`                                                                                                                                                                                                              |
+| `TEST_MODEL`                   | Optional, model name used to test if a key is usable                        | `gemini-1.5-flash`                                                                                                                                                                                                                       |
+| `IMAGE_MODELS`                 | Optional, list of models that support drawing functions                     | `["gemini-2.0-flash-exp"]`                                                                                                                                                                                                               |
+| `SEARCH_MODELS`                | Optional, list of models that support search functions                      | `["gemini-2.0-flash-exp"]`                                                                                                                                                                                                               |
+| `FILTERED_MODELS`              | Optional, list of disabled models                                           | `["gemini-1.0-pro-vision-latest", ...]`                                                                                                                                                                                                  |
+| `TOOLS_CODE_EXECUTION_ENABLED` | Optional, whether to enable the code execution tool                         | `false`                                                                                                                                                                                                                                  |
+| `SHOW_SEARCH_LINK`             | Optional, whether to display search result links in the response            | `true`                                                                                                                                                                                                                                   |
+| `SHOW_THINKING_PROCESS`        | Optional, whether to display the model's thinking process                   | `true`                                                                                                                                                                                                                                   |
+| `THINKING_MODELS`              | Optional, list of models that support thinking functions                    | `[]`                                                                                                                                                                                                                                     |
+| `THINKING_BUDGET_MAP`          | Optional, thinking function budget mapping (model_name:budget_value)        | `{}`                                                                                                                                                                                                                                     |
+| `URL_NORMALIZATION_ENABLED`    | Optional, whether to enable intelligent URL routing mapping                 | `false`                                                                                                                                                                                                                                  |
+| `BASE_URL`                     | Optional, Gemini API base URL, no modification needed by default            | `https://generativelanguage.googleapis.com/v1beta`                                                                                                                                                                                       |
+| `MAX_FAILURES`                 | Optional, number of times a single key is allowed to fail                   | `3`                                                                                                                                                                                                                                      |
+| `MAX_RETRIES`                  | Optional, maximum number of retries for failed API requests                 | `3`                                                                                                                                                                                                                                      |
+| `CHECK_INTERVAL_HOURS`         | Optional, time interval (hours) to check if a disabled Key has recovered    | `1`                                                                                                                                                                                                                                      |
+| `TIMEZONE`                     | Optional, timezone used by the application                                  | `Asia/Shanghai`                                                                                                                                                                                                                          |
+| `TIME_OUT`                     | Optional, request timeout (seconds)                                         | `300`                                                                                                                                                                                                                                    |
+| `PROXIES`                      | Optional, list of proxy servers (e.g., `http://user:pass@host:port`, `socks5://host:port`) | `[]`                                                                                                                                                                                                                                     |
+| `LOG_LEVEL`                    | Optional, log level, e.g., DEBUG, INFO, WARNING, ERROR, CRITICAL          | `INFO`                                                                                                                                                                                                                                   |
+| `AUTO_DELETE_ERROR_LOGS_ENABLED` | Optional, whether to enable automatic deletion of error logs              | `true`                                                                                                                                                                                                                                   |
+| `AUTO_DELETE_ERROR_LOGS_DAYS`  | Optional, automatically delete error logs older than this many days (e.g., 1, 7, 30) | `7`                                                                                                                                                                                                                                      |
+| `AUTO_DELETE_REQUEST_LOGS_ENABLED`| Optional, whether to enable automatic deletion of request logs             | `false`                                                                                                                                                                                                                                  |
+| `AUTO_DELETE_REQUEST_LOGS_DAYS` | Optional, automatically delete request logs older than this many days (e.g., 1, 7, 30) | `30`                                                                                                                                                                                                                                     |
+| `SAFETY_SETTINGS`              | Optional, safety settings (JSON string format), used to configure content safety thresholds. Example values may need adjustment based on actual model support. | `[{"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 Related**                |                                                                             |                                                                                                                                                                                                                                          |
+| `TTS_MODEL`                    | Optional, TTS model name                                                    | `gemini-2.5-flash-preview-tts`                                                                                                                                                                                                           |
+| `TTS_VOICE_NAME`               | Optional, TTS voice name                                                    | `Zephyr`                                                                                                                                                                                                                                 |
+| `TTS_SPEED`                    | Optional, TTS speed                                                         | `normal`                                                                                                                                                                                                                                 |
+| **Image Generation Related**   |                                                                             |                                                                                                                                                                                                                                          |
+| `PAID_KEY`                     | Optional, paid API Key for advanced features like image generation          | `your-paid-api-key`                                                                                                                                                                                                                        |
+| `CREATE_IMAGE_MODEL`           | Optional, image generation model                                            | `imagen-3.0-generate-002`                                                                                                                                                                                                                  |
+| `UPLOAD_PROVIDER`              | Optional, image upload provider: `smms`, `picgo`, `cloudflare_imgbed`       | `smms`                                                                                                                                                                                                                                   |
+| `SMMS_SECRET_TOKEN`            | Optional, API Token for SM.MS image hosting                                 | `your-smms-token`                                                                                                                                                                                                                          |
+| `PICGO_API_KEY`                | Optional, API Key for [PicoGo](https://www.picgo.net/) image hosting        | `your-picogo-apikey`                                                                                                                                                                                                                         |
+| `CLOUDFLARE_IMGBED_URL`        | Optional, [CloudFlare](https://github.com/MarSeventh/CloudFlare-ImgBed) image hosting upload address | `https://xxxxxxx.pages.dev/upload`                                                                                                                                                                                           |
+| `CLOUDFLARE_IMGBED_AUTH_CODE`  | Optional, authentication key for CloudFlare image hosting                   | `your-cloudflare-imgber-auth-code`                                                                                                                                                                                                           |
+| `CLOUDFLARE_IMGBED_UPLOAD_FOLDER` | Optional, upload folder path for CloudFlare image hosting               | `""`                                                                                                                                                                                                                                          |
+| **Stream Optimizer Related**   |                                                                             |                                                                                                                                                                                                                                          |
+| `STREAM_OPTIMIZER_ENABLED`     | Optional, whether to enable stream output optimization                      | `false`                                                                                                                                                                                                                                  |
+| `STREAM_MIN_DELAY`             | Optional, minimum delay for stream output                                   | `0.016`                                                                                                                                                                                                                                  |
+| `STREAM_MAX_DELAY`             | Optional, maximum delay for stream output                                   | `0.024`                                                                                                                                                                                                                                  |
+| `STREAM_SHORT_TEXT_THRESHOLD`  | Optional, short text threshold                                              | `10`                                                                                                                                                                                                                                     |
+| `STREAM_LONG_TEXT_THRESHOLD`   | Optional, long text threshold                                               | `50`                                                                                                                                                                                                                                     |
+| `STREAM_CHUNK_SIZE`            | Optional, stream output chunk size                                          | `5`                                                                                                                                                                                                                                      |
+| **Fake Stream Related**        |                                                                             |                                                                                                                                                                                                                                          |
+| `FAKE_STREAM_ENABLED`          | Optional, whether to enable fake streaming for models or scenarios that don't support streaming | `false`                                                                                                                                                                                                                                  |
+| `FAKE_STREAM_EMPTY_DATA_INTERVAL_SECONDS` | Optional, interval in seconds for sending heartbeat empty data during fake streaming | `5`                                                                                                                                                                                                                                      |
 
-## ⚙️ API 端点
+## ⚙️ API Endpoints
 
-以下是服务提供的主要 API 端点：
+The following are the main API endpoints provided by the service:
 
-### Gemini API 相关 (`(/gemini)/v1beta`)
+### Gemini API Related (`(/gemini)/v1beta`)
 
-* `GET /models`: 列出可用的 Gemini 模型。
-* `POST /models/{model_name}:generateContent`: 使用指定的 Gemini 模型生成内容。
-* `POST /models/{model_name}:streamGenerateContent`: 使用指定的 Gemini 模型流式生成内容。
+* `GET /models`: List available Gemini models.
+* `POST /models/{model_name}:generateContent`: Generate content using the specified Gemini model.
+* `POST /models/{model_name}:streamGenerateContent`: Stream content generation using the specified Gemini model.
 
-### OpenAI API 相关
+### OpenAI API Related
 
-* `GET (/hf)/v1/models`: 列出可用的模型 (底层用的gemini格式)。
-* `POST (/hf)/v1/chat/completions`: 进行聊天补全 (底层用的gemini格式, 支持流式传输)。
-* `POST (/hf)/v1/embeddings`: 创建文本嵌入 (底层用的gemini格式)。
-* `POST (/hf)/v1/images/generations`: 生成图像 (底层用的gemini格式)。
-* `GET /openai/v1/models`: 列出可用的模型 (底层用的openai格式)。
-* `POST /openai/v1/chat/completions`: 进行聊天补全 (底层用的openai格式, 支持流式传输, 可防止截断，速度也快)。
-* `POST /openai/v1/embeddings`: 创建文本嵌入 (底层用的openai格式)。
-* `POST /openai/v1/images/generations`: 生成图像 (底层用的openai格式)。
+* `GET (/hf)/v1/models`: List available models (uses Gemini format underneath).
+* `POST (/hf)/v1/chat/completions`: Perform chat completion (uses Gemini format underneath, supports streaming).
+* `POST (/hf)/v1/embeddings`: Create text embeddings (uses Gemini format underneath).
+* `POST (/hf)/v1/images/generations`: Generate images (uses Gemini format underneath).
+* `GET /openai/v1/models`: List available models (uses OpenAI format underneath).
+* `POST /openai/v1/chat/completions`: Perform chat completion (uses OpenAI format underneath, supports streaming, can prevent truncation, and is faster).
+* `POST /openai/v1/embeddings`: Create text embeddings (uses OpenAI format underneath).
+* `POST /openai/v1/images/generations`: Generate images (uses OpenAI format underneath).
 
-## 🤝 贡献
+## 🤝 Contributing
 
-欢迎提交 Pull Request 或 Issue。
+Pull Requests or Issues are welcome.
 
-## 🎉 特别鸣谢
+## 🎉 Special Thanks
 
-特别鸣谢以下项目和平台为本项目提供图床服务:
+Special thanks to the following projects and platforms for providing image hosting services for this project:
 
 * [PicGo](https://www.picgo.net/)
 * [SM.MS](https://smms.app/)
-* [CloudFlare-ImgBed](https://github.com/MarSeventh/CloudFlare-ImgBed) 开源项目
+* [CloudFlare-ImgBed](https://github.com/MarSeventh/CloudFlare-ImgBed) open source project
 
-## 🙏 感谢贡献者
+## 🙏 Thanks to Contributors
 
-感谢所有为本项目做出贡献的开发者！
+Thanks to all developers who contributed to this project!
 
 [![Contributors](https://contrib.rocks/image?repo=snailyp/gemini-balance)](https://github.com/snailyp/gemini-balance/graphs/contributors)
 
+## Thanks to Our Supporters
+
+A special shout-out to DigitalOcean for providing the rock-solid and dependable cloud infrastructure that keeps this project humming!
+[![DigitalOcean Logo](files/dataocean.svg)](https://m.do.co/c/b249dd7f3b4c)
+
+CDN acceleration and security protection for this project are sponsored by Tencent EdgeOne.
+[![EdgeOne Logo](https://edgeone.ai/media/34fe3a45-492d-4ea4-ae5d-ea1087ca7b4b.png)](https://edgeone.ai/?from=github)
+
 ## ⭐ 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)
 
-## 💖 友情项目
+## 💖 Friendly Projects
 
-* **[OneLine](https://github.com/chengtx809/OneLine)** by [chengtx809](https://github.com/chengtx809) - OneLine一线：AI驱动的热点事件时间轴生成工具
+* **[OneLine](https://github.com/chengtx809/OneLine)** by [chengtx809](https://github.com/chengtx809) - OneLine: AI-driven hot event timeline generation tool
 
-## 🎁 项目支持
+## 🎁 Project Support
 
-如果你觉得这个项目对你有帮助，可以考虑通过 [爱发电](https://afdian.com/a/snaily) 支持我。
+If you find this project helpful, consider supporting me via [Afdian](https://afdian.com/a/snaily).
 
-## 许可证
+## License
 
-本项目采用 CC BY-NC 4.0（署名-非商业性使用）协议，禁止任何形式的商业倒卖服务，详见 LICENSE 文件。
+This project is licensed under the CC BY-NC 4.0 (Attribution-NonCommercial) license. Any form of commercial resale service is prohibited. See the LICENSE file for details.

README_ZH.md

@@ -0,0 +1,278 @@
+# 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>
+
+> ⚠️ 本项目采用 CC BY-NC 4.0（署名-非商业性使用）协议，禁止任何形式的商业倒卖服务，详见 LICENSE 文件。
+
+> 本人从未在各个平台售卖服务，如有遇到售卖此服务者，那一定是倒卖狗，大家切记不要上当受骗。
+
+[![Python](https://img.shields.io/badge/Python-3.9%2B-blue.svg)](https://www.python.org/)
+[![FastAPI](https://img.shields.io/badge/FastAPI-0.100%2B-green.svg)](https://fastapi.tiangolo.com/)
+[![Uvicorn](https://img.shields.io/badge/Uvicorn-running-purple.svg)](https://www.uvicorn.org/)
+[![Telegram Group](https://img.shields.io/badge/Telegram-Group-blue.svg?logo=telegram)](https://t.me/+soaHax5lyI0wZDVl)
+> 交流群：https://t.me/+soaHax5lyI0wZDVl
+
+## 项目简介
+
+Gemini Balance 是一个基于 Python FastAPI 构建的应用程序，旨在提供 Google Gemini API 的代理和负载均衡功能。它允许您管理多个 Gemini API Key，并通过简单的配置实现 Key 的轮询、认证、模型过滤和状态监控。此外，项目还集成了图像生成和多种图床上传功能，并支持 OpenAI API 格式的代理。
+
+**项目结构:**
+
+```plaintext
+app/
+├── config/       # 配置管理
+├── core/         # 核心应用逻辑 (FastAPI 实例创建, 中间件等)
+├── database/     # 数据库模型和连接
+├── domain/       # 业务领域对象 (可选)
+├── exception/    # 自定义异常
+├── handler/      # 请求处理器 (可选, 或在 router 中处理)
+├── log/          # 日志配置
+├── main.py       # 应用入口
+├── middleware/   # FastAPI 中间件
+├── router/       # API 路由 (Gemini, OpenAI, 状态页等)
+├── scheduler/    # 定时任务 (如 Key 状态检查)
+├── service/      # 业务逻辑服务 (聊天, Key 管理, 统计等)
+├── static/       # 静态文件 (CSS, JS)
+├── templates/    # HTML 模板 (如 Key 状态页)
+├── utils/        # 工具函数
+```
+
+## ✨ 功能亮点
+
+* **多 Key 负载均衡**: 支持配置多个 Gemini API Key (`API_KEYS`)，自动按顺序轮询使用，提高可用性和并发能力。
+* **可视化配置即时生效**: 通过管理后台修改配置后，无需重启服务即可生效，切记要点击保存才会生效。
+![配置面板](files/image4.png)
+* **双协议API 兼容**: 同时支持 Gemini 和 OpenAI 格式的 CHAT API 请求转发。
+
+    ```palintext
+    openai baseurl `http://localhost:8000(/hf)/v1`
+    gemini baseurl `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代理**: 支持自定义gemini代理，比如自行在deno或者cloudflare上搭建gemini代理
+* **openai画图接口兼容**: 将`imagen-3.0-generate-002`模型接口改造成openai画图接口，支持客户端调用。
+* **灵活的添加密钥方式**: 灵活的添加密钥方式，采用正则匹配`gemini_key`,密钥去重
+![添加密钥](files/image5.png)
+* **兼容openai格式embeddings接口**：完美适配openai格式的`embeddings`接口，可用于本地文档向量化。
+* **流式响应优化**: 可选的流式输出优化器 (`STREAM_OPTIMIZER_ENABLED`)，改善长文本流式响应的体验。
+* **失败重试与 Key 管理**: 自动处理 API 请求失败，进行重试 (`MAX_RETRIES`)，并在 Key 失效次数过多时自动禁用 (`MAX_FAILURES`)，定时检查恢复 (`CHECK_INTERVAL_HOURS`)。
+* **Docker 支持**: 支持AMD，ARM架构的docker部署，也可自行构建docker镜像。
+    >镜像地址: docker pull ghcr.io/snailyp/gemini-balance:latest
+* **模型列表自动维护**: 支持openai和gemini模型列表获取，与newapi自动获取模型列表完美兼容，无需手动填写。
+* **支持移除不使用的模型**: 默认提供的模型太多，很多用不上，可以通过`FILTERED_MODELS`过滤掉。
+* **代理支持**: 支持配置 HTTP/SOCKS5 代理服务器 (`PROXIES`)，用于访问 Gemini API，方便在特殊网络环境下使用。支持批量添加代理。
+
+## 🚀 快速开始
+
+### 自行构建 Docker (推荐)
+
+#### a) dockerfile构建
+
+1. **构建镜像**:
+
+    ```bash
+    docker build -t gemini-balance .
+    ```
+
+2. **运行容器**:
+
+    ```bash
+    docker run -d -p 8000:8000 --env-file .env gemini-balance
+    ```
+
+    * `-d`: 后台运行。
+    * `-p 8000:8000`: 将容器的 8000 端口映射到主机的 8000 端口。
+    * `--env-file .env`: 使用 `.env` 文件设置环境变量。
+
+    > 注意：如果使用 SQLite 数据库，需要挂载数据卷以持久化数据：
+    > ```bash
+    > docker run -d -p 8000:8000 --env-file .env -v /path/to/data:/app/data gemini-balance
+    > ```
+    > 其中 `/path/to/data` 是主机上的数据存储路径，`/app/data` 是容器内的数据目录。
+
+#### b) 用现有的docker镜像部署
+
+1. **拉取镜像**:
+
+   ```bash
+   docker pull ghcr.io/snailyp/gemini-balance:latest
+   ```
+
+2. **运行容器**:
+
+   ```bash
+   docker run -d -p 8000:8000 --env-file .env ghcr.io/snailyp/gemini-balance:latest
+   ```
+
+   * `-d`: 后台运行。
+   * `-p 8000:8000`: 将容器的 8000 端口映射到主机的 8000 端口 (根据需要调整)。
+   * `--env-file .env`: 使用 `.env` 文件设置环境变量 (确保 `.env` 文件存在于执行命令的目录)。
+
+    > 注意：如果使用 SQLite 数据库，需要挂载数据卷以持久化数据：
+    > ```bash
+    > docker run -d -p 8000:8000 --env-file .env -v /path/to/data:/app/data ghcr.io/snailyp/gemini-balance:latest
+    > ```
+    > 其中 `/path/to/data` 是主机上的数据存储路径，`/app/data` 是容器内的数据目录。
+
+### 本地运行 (适用于开发和测试)
+
+如果您想在本地直接运行源代码进行开发或测试，请按照以下步骤操作：
+
+1. **确保已完成准备工作**:
+    * 克隆仓库到本地。
+    * 安装 Python 3.9 或更高版本。
+    * 在项目根目录下创建并配置好 `.env` 文件 (参考前面的"配置环境变量"部分)。
+    * 安装项目依赖：
+
+        ```bash
+        pip install -r requirements.txt
+        ```
+
+2. **启动应用**:
+    在项目根目录下运行以下命令：
+
+    ```bash
+    uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload
+    ```
+
+    * `app.main:app`: 指定 FastAPI 应用实例的位置 (`app` 模块中的 `main.py` 文件里的 `app` 对象)。
+    * `--host 0.0.0.0`: 使应用可以从本地网络中的任何 IP 地址访问。
+    * `--port 8000`: 指定应用监听的端口号 (您可以根据需要修改)。
+    * `--reload`: 启用自动重载功能。当您修改代码时，服务会自动重启，非常适合开发环境 (生产环境请移除此选项)。
+
+3. **访问应用**:
+    应用启动后，您可以通过浏览器或 API 工具访问 `http://localhost:8000` (或您指定的主机和端口)。
+
+### 完整配置项列表
+
+| 配置项                       | 说明                                                     | 默认值                             |
+| :--------------------------- | :------------------------------------------------------- | :---------------------------------------------------- |
+| **数据库配置**               |                                                          |                                                       |
+| `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 密钥列表，用于负载均衡                        | `["your-gemini-api-key-1", "your-gemini-api-key-2"]`  |
+| `ALLOWED_TOKENS`             | 必填，允许访问的 Token 列表                                    | `["your-access-token-1", "your-access-token-2"]`      |
+| `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`            | 可选，被禁用的模型列表                                         | `["gemini-1.0-pro-vision-latest", ...]`               |
+| `TOOLS_CODE_EXECUTION_ENABLED` | 可选，是否启用代码执行工具                                     | `false`                                               |
+| `SHOW_SEARCH_LINK`           | 可选，是否在响应中显示搜索结果链接                             | `true`                                                |
+| `SHOW_THINKING_PROCESS`      | 可选，是否显示模型思考过程                                     | `true`                                                |
+| `THINKING_MODELS`            | 可选，支持思考功能的模型列表                                   | `[]`                                                  |
+| `THINKING_BUDGET_MAP`        | 可选，思考功能预算映射 (模型名:预算值)                         | `{}`                                                  |
+| `URL_NORMALIZATION_ENABLED`  | 可选，是否启用智能路由映射功能                                 | `false`                                               |
+| `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`, `socks5://host:port`) | `[]`                                                  |
+| `LOG_LEVEL`                  | 可选，日志级别，例如 DEBUG, INFO, WARNING, ERROR, CRITICAL     | `INFO`                                                |
+| `AUTO_DELETE_ERROR_LOGS_ENABLED` | 可选，是否开启自动删除错误日志                                 | `true`                                                |
+| `AUTO_DELETE_ERROR_LOGS_DAYS`  | 可选，自动删除多少天前的错误日志 (例如 1, 7, 30)             | `7`                                                   |
+| `AUTO_DELETE_REQUEST_LOGS_ENABLED`| 可选，是否开启自动删除请求日志                               | `false`                                               |
+| `AUTO_DELETE_REQUEST_LOGS_DAYS` | 可选，自动删除多少天前的请求日志 (例如 1, 7, 30)           | `30`                                                  |
+| `SAFETY_SETTINGS`            | 可选，安全设置 (JSON 字符串格式)，用于配置内容安全阈值。示例值可能需要根据实际模型支持情况调整。 | `[{"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 相关**                 |                                                          |                                                       |
+| `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`                                  |
+| `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`                                                   |
+
+## ⚙️ API 端点
+
+以下是服务提供的主要 API 端点：
+
+### Gemini API 相关 (`(/gemini)/v1beta`)
+
+* `GET /models`: 列出可用的 Gemini 模型。
+* `POST /models/{model_name}:generateContent`: 使用指定的 Gemini 模型生成内容。
+* `POST /models/{model_name}:streamGenerateContent`: 使用指定的 Gemini 模型流式生成内容。
+
+### OpenAI API 相关
+
+* `GET (/hf)/v1/models`: 列出可用的模型 (底层用的gemini格式)。
+* `POST (/hf)/v1/chat/completions`: 进行聊天补全 (底层用的gemini格式, 支持流式传输)。
+* `POST (/hf)/v1/embeddings`: 创建文本嵌入 (底层用的gemini格式)。
+* `POST (/hf)/v1/images/generations`: 生成图像 (底层用的gemini格式)。
+* `GET /openai/v1/models`: 列出可用的模型 (底层用的openai格式)。
+* `POST /openai/v1/chat/completions`: 进行聊天补全 (底层用的openai格式, 支持流式传输, 可防止截断，速度也快)。
+* `POST /openai/v1/embeddings`: 创建文本嵌入 (底层用的openai格式)。
+* `POST /openai/v1/images/generations`: 生成图像 (底层用的openai格式)。
+
+## 🤝 贡献
+
+欢迎提交 Pull Request 或 Issue。
+
+## 🎉 特别鸣谢
+
+特别鸣谢以下项目和平台为本项目提供图床服务:
+
+* [PicGo](https://www.picgo.net/)
+* [SM.MS](https://smms.app/)
+* [CloudFlare-ImgBed](https://github.com/MarSeventh/CloudFlare-ImgBed) 开源项目
+
+## 🙏 感谢贡献者
+
+感谢所有为本项目做出贡献的开发者！
+
+[![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)
+
+## 💖 友情项目
+
+* **[OneLine](https://github.com/chengtx809/OneLine)** by [chengtx809](https://github.com/chengtx809) - OneLine一线：AI驱动的热点事件时间轴生成工具
+
+## 🎁 项目支持
+
+如果你觉得这个项目对你有帮助，可以考虑通过 [爱发电](https://afdian.com/a/snaily) 支持我。
+
+## 许可证
+
+本项目采用 CC BY-NC 4.0（署名-非商业性使用）协议，禁止任何形式的商业倒卖服务，详见 LICENSE 文件。

VERSION

@@ -1 +1 @@
-2.1.4
+2.1.9

app/config/config.py

@@ -4,7 +4,7 @@
 
 import datetime
 import json
-from typing import Any, Dict, List, Type
+from typing import Any, Dict, List, Type, get_args, get_origin
 
 from pydantic import ValidationError, ValidationInfo, field_validator
 from pydantic_settings import BaseSettings
@@ -59,7 +59,16 @@ class Settings(BaseSettings):
     TEST_MODEL: str = DEFAULT_MODEL
     TIME_OUT: int = DEFAULT_TIMEOUT
     MAX_RETRIES: int = MAX_RETRIES
-    PROXIES: List[str] = []  # 新增：代理服务器列表
+    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"]
@@ -68,8 +77,13 @@ class Settings(BaseSettings):
     TOOLS_CODE_EXECUTION_ENABLED: bool = False
     SHOW_SEARCH_LINK: bool = True
     SHOW_THINKING_PROCESS: bool = True
-    THINKING_MODELS: List[str] = []  # 新增：用于思考过程的模型列表
-    THINKING_BUDGET_MAP: Dict[str, float] = {}  # 新增：模型对应的预算映射
+    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 = ""
@@ -79,6 +93,7 @@ class Settings(BaseSettings):
     PICGO_API_KEY: str = ""
     CLOUDFLARE_IMGBED_URL: str = ""
     CLOUDFLARE_IMGBED_AUTH_CODE: str = ""
+    CLOUDFLARE_IMGBED_UPLOAD_FOLDER: str = ""
 
     # 流式输出优化器配置
     STREAM_OPTIMIZER_ENABLED: bool = False
@@ -101,12 +116,13 @@ class Settings(BaseSettings):
     GITHUB_REPO_NAME: str = "gemini-balance"
 
     # 日志配置
-    LOG_LEVEL: str = "INFO"  # 默认日志级别
-    AUTO_DELETE_ERROR_LOGS_ENABLED: bool = True  # 是否开启自动删除错误日志
-    AUTO_DELETE_ERROR_LOGS_DAYS: int = 7  # 自动删除多少天前的错误日志 (1, 7, 30)
-    AUTO_DELETE_REQUEST_LOGS_ENABLED: bool = False  # 是否开启自动删除请求日志
-    AUTO_DELETE_REQUEST_LOGS_DAYS: int = 30  # 自动删除多少天前的请求日志 (1, 7, 30)
-    SAFETY_SETTINGS: List[Dict[str, str]] = DEFAULT_SAFETY_SETTINGS  # 新增：安全设置
+    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
+
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
@@ -121,93 +137,110 @@ settings = Settings()
 
 def _parse_db_value(key: str, db_value: str, target_type: Type) -> Any:
     """尝试将数据库字符串值解析为目标 Python 类型"""
-    from app.log.logger import get_config_logger  # 函数内导入
+    from app.log.logger import get_config_logger
 
-    logger = get_config_logger()  # 函数内初始化
+    logger = get_config_logger()
     try:
-        # 处理 List[str]
-        if target_type == List[str]:
-            try:
-                parsed = json.loads(db_value)
-                if isinstance(parsed, list):
-                    return [str(item) for item in parsed]
-            except json.JSONDecodeError:
+        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()]
-            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()]
-        # 处理 Dict[str, float]
-        elif target_type == Dict[str, float]:
-            parsed_dict = {}
-            try:
-                # First attempt: standard JSON parsing
-                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:
-                # Second attempt: try replacing single quotes if JSONDecodeError occurred
-                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()}
+            # 处理 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"Parsed DB value (after quote replacement) for key '{key}' is not a dictionary type. Value: {corrected_db_value}"
+                                f"Invalid structure in List[Dict[str, str]] for key '{key}'. Value: {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:
-                    # Log other errors (ValueError, TypeError) or JSON errors without single quotes
-                    logger.error(
-                        f"Could not parse '{db_value}' as Dict[str, float] for key '{key}': {e1}. Returning empty dict."
-                    )
-            return parsed_dict  # Return the parsed dict or an empty one if all attempts fail
-        # 处理 List[Dict[str, str]]
-        elif target_type == List[Dict[str, str]]:
-            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
+                            return []
                     else:
                         logger.warning(
-                            f"Invalid structure in List[Dict[str, str]] for key '{key}'. Value: {db_value}"
+                            f"Parsed DB value for key '{key}' is not a list type. 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 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 []
+                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")
@@ -234,9 +267,9 @@ async def sync_initial_settings():
     2. 将数据库设置合并到内存 settings (数据库优先)。
     3. 将最终的内存 settings 同步回数据库。
     """
-    from app.log.logger import get_config_logger  # 函数内导入
+    from app.log.logger import get_config_logger
 
-    logger = get_config_logger()  # 函数内初始化
+    logger = get_config_logger()
     # 延迟导入以避免循环依赖和确保数据库连接已初始化
     from app.database.connection import database
     from app.database.models import Settings as SettingsModel
@@ -296,18 +329,12 @@ async def sync_initial_settings():
                         if parsed_db_value != memory_value:
                             # 检查类型是否匹配，以防解析函数返回了不兼容的类型
                             type_match = False
-                            if target_type == List[str] and isinstance(
-                                parsed_db_value, list
-                            ):
-                                type_match = True
-                            elif target_type == Dict[str, float] and isinstance(
-                                parsed_db_value, dict
-                            ):
-                                type_match = True
-                            elif target_type not in (
-                                List[str],
-                                Dict[str, float],
-                            ) and isinstance(parsed_db_value, target_type):
+                            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:
@@ -360,21 +387,21 @@ async def sync_initial_settings():
                 continue
 
             # 序列化值为字符串或 JSON 字符串
-            if isinstance(value, (list, dict)):  # 处理列表和字典
+            if isinstance(value, (list, dict)):
                 db_value = json.dumps(
                     value, ensure_ascii=False
-                )  # 使用 ensure_ascii=False 以支持非 ASCII 字符
+                )
             elif isinstance(value, bool):
                 db_value = str(value).lower()
-            elif value is None:  # 处理 None 值
-                db_value = ""  # 或者根据需要设为 NULL 或其他标记
+            elif value is None:
+                db_value = ""
             else:
                 db_value = str(value)
 
             data = {
                 "key": key,
                 "value": db_value,
-                "description": f"{key} configuration setting",  # 默认描述
+                "description": f"{key} configuration setting",
                 "updated_at": now,
             }
 

app/core/application.py

@@ -1,35 +1,32 @@
 from contextlib import asynccontextmanager
-from pathlib import Path # Add pathlib import
+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
 from app.middleware.middleware import setup_middlewares
-from app.exception.exceptions import setup_exception_handlers
 from app.router.routes import setup_routers
-from app.service.key.key_manager import get_key_manager_instance
-from app.database.connection import connect_to_db, disconnect_from_db
-from app.utils.helpers import get_current_version # Import from helpers
-from app.database.initialization import initialize_database
 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()
 
-# Define project paths using pathlib
-# Assuming this file is at app/core/application.py
 PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
-# VERSION_FILE_PATH = PROJECT_ROOT / "VERSION" # Removed: Defined in helpers.py
 STATIC_DIR = PROJECT_ROOT / "app" / "static"
 TEMPLATES_DIR = PROJECT_ROOT / "app" / "templates"
 
-# Removed _get_current_version function definition, moved to helpers.py
-
 # 初始化模板引擎，并添加全局变量
 templates = Jinja2Templates(directory="app/templates")
 
+
 # 定义一个函数来更新模板全局变量
 def update_template_globals(app: FastAPI, update_info: dict):
     # Jinja2Templates 实例没有直接更新全局变量的方法
@@ -40,114 +37,105 @@ def update_template_globals(app: FastAPI, update_info: dict):
 
 
 # --- 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()
-    # Initialize KeyManager using potentially updated settings
-    await get_key_manager_instance(app_settings.API_KEYS)
+    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}")
+        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() # Use imported function
+    current_version = get_current_version()
     update_info = {
         "update_available": update_available,
         "latest_version": latest_version,
         "error_message": error_message,
-        "current_version": current_version
+        "current_version": current_version,
     }
-    # Ensure app.state exists and store update info
     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}")
 
-# --- Application Lifespan ---
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     """
     Manages the application startup and shutdown events.
-    
+
     Args:
         app: FastAPI应用实例
     """
-    # Startup events
     logger.info("Application starting up...")
     try:
-        # Setup database, config, and KeyManager
-        await _setup_database_and_config(settings) # Pass settings object
-
-        # Perform update check after core components are ready
-        # await _perform_update_check(app) # Removed: Version check moved to frontend API call
-
-        # Start the scheduler
+        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)
-        # Depending on the severity, you might want to prevent the app from fully starting
-        # For now, we log critically and let it yield, potentially in a broken state.
-        # Consider adding more robust error handling here if startup failures should halt the app.
+        logger.critical(
+            f"Critical error during application startup: {str(e)}", exc_info=True
+        )
 
-    yield  # Application runs
+    yield
 
-    # Shutdown events
     logger.info("Application shutting down...")
     _stop_scheduler()
     await _shutdown_database()
 
+
 def create_app() -> FastAPI:
     """
     创建并配置FastAPI应用程序实例
-    
+
     Returns:
         FastAPI: 配置好的FastAPI应用程序实例
     """
-    # Removed: initialize_app() call
 
     # 创建FastAPI应用
-    # Read version from file for consistency
-    current_version = get_current_version() # Use imported function
+    current_version = get_current_version()
     app = FastAPI(
         title="Gemini Balance API",
         description="Gemini API代理服务，支持负载均衡和密钥管理",
         version=current_version,
-        lifespan=lifespan
+        lifespan=lifespan,
     )
 
-    # Initialize app.state early to ensure it exists before lifespan potentially uses it
     if not hasattr(app, "state"):
         from starlette.datastructures import State
+
         app.state = State()
-    # Set a default/initial state for update_info
     app.state.update_info = {
         "update_available": False,
         "latest_version": None,
         "error_message": "Initializing...",
-        "current_version": current_version # Use version read earlier
+        "current_version": current_version,
     }
 
     # 配置静态文件
@@ -155,11 +143,11 @@ def create_app() -> FastAPI:
 
     # 配置中间件
     setup_middlewares(app)
-    
+
     # 配置异常处理器
     setup_exception_handlers(app)
-    
+
     # 配置路由
     setup_routers(app)
-    
+
     return app

app/core/constants.py

@@ -76,4 +76,15 @@ DEFAULT_SAFETY_SETTINGS = [
         {"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",
+    "Callirhoe", "Autonoe", "Enceladus", "Iapetus",
+    "Umbriel", "Algieba", "Despina", "Erinome",
+    "Algenib", "Rasalgethi", "Laomedeia", "Achernar",
+    "Alnilam", "Schedar", "Gacrux", "Pulcherrima",
+    "Achird", "Zubenelgenubi", "Vindemiatrix", "Sadachbia",
+    "Sadaltager", "Sulafat"
+]

app/database/connection.py

@@ -2,9 +2,9 @@
 数据库连接池模块
 """
 from pathlib import Path
+from urllib.parse import quote_plus
 from databases import Database
 from sqlalchemy import create_engine, MetaData
-# from sqlalchemy.orm import sessionmaker # 不再需要
 from sqlalchemy.ext.declarative import declarative_base
 
 from app.config.config import settings
@@ -21,9 +21,9 @@ if settings.DATABASE_TYPE == "sqlite":
     DATABASE_URL = f"sqlite:///{db_path}"
 elif settings.DATABASE_TYPE == "mysql":
     if settings.MYSQL_SOCKET:
-        DATABASE_URL = f"mysql+pymysql://{settings.MYSQL_USER}:{settings.MYSQL_PASSWORD}@/{settings.MYSQL_DATABASE}?unix_socket={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}:{settings.MYSQL_PASSWORD}@{settings.MYSQL_HOST}:{settings.MYSQL_PORT}/{settings.MYSQL_DATABASE}"
+        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'.")
 
@@ -46,11 +46,8 @@ Base = declarative_base(metadata=metadata)
 if settings.DATABASE_TYPE == "sqlite":
     database = Database(DATABASE_URL)
 else:
-    database = Database(DATABASE_URL, min_size=5, max_size=20, pool_recycle=1800) # Reduced recycle time to 30 mins
+    database = Database(DATABASE_URL, min_size=5, max_size=20, pool_recycle=1800)
 
-# 移除了 SessionLocal 和 get_db 函数
-
-# --- Async connection functions for lifespan/async routes ---
 async def connect_to_db():
     """
     连接到数据库

app/database/models.py

@@ -2,7 +2,7 @@
 数据库模型模块
 """
 import datetime
-from sqlalchemy import Column, Integer, String, Text, DateTime, JSON, Boolean # 添加 Boolean
+from sqlalchemy import Column, Integer, String, Text, DateTime, JSON, Boolean
 
 from app.database.connection import Base
 
@@ -42,17 +42,18 @@ class ErrorLog(Base):
     def __repr__(self):
         return f"<ErrorLog(id='{self.id}', gemini_key='{self.gemini_key}')>"
 
-# 新增 RequestLog 模型
+
 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密钥") # 考虑安全性，后续可优化
+    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="请求耗时(毫秒)")

app/database/services.py

@@ -71,7 +71,7 @@ async def update_setting(key: str, value: str, description: Optional[str] = None
                 .values(
                     value=value,
                     description=description if description else setting["description"],
-                    updated_at=datetime.now() # Use datetime.now()
+                    updated_at=datetime.now()
                 )
             )
             await database.execute(query)
@@ -85,8 +85,8 @@ async def update_setting(key: str, value: str, description: Optional[str] = None
                     key=key,
                     value=value,
                     description=description,
-                    created_at=datetime.now(), # Use datetime.now()
-                    updated_at=datetime.now() # Use datetime.now()
+                    created_at=datetime.now(),
+                    updated_at=datetime.now()
                 )
             )
             await database.execute(query)
@@ -158,8 +158,8 @@ async def get_error_logs(
     error_code_search: Optional[str] = None,
     start_date: Optional[datetime] = None,
     end_date: Optional[datetime] = None,
-    sort_by: str = 'id',        # 新增排序字段
-    sort_order: str = 'desc'   # 新增排序顺序 ('asc' or 'desc')
+    sort_by: str = 'id',
+    sort_order: str = 'desc'
 ) -> List[Dict[str, Any]]:
     """
     获取错误日志，支持搜索、日期过滤和排序
@@ -189,7 +189,6 @@ async def get_error_logs(
             ErrorLog.request_time
         )
         
-        # Apply filters
         if key_search:
             query = query.where(ErrorLog.gemini_key.ilike(f"%{key_search}%"))
         if error_search:
@@ -200,41 +199,33 @@ async def get_error_logs(
         if start_date:
             query = query.where(ErrorLog.request_time >= start_date)
         if end_date:
-            # Use the datetime object directly for comparison
             query = query.where(ErrorLog.request_time < end_date)
         if error_code_search:
             try:
-                # Attempt to convert search string to integer for exact match
                 error_code_int = int(error_code_search)
                 query = query.where(ErrorLog.error_code == error_code_int)
             except ValueError:
-                # If conversion fails, log a warning and potentially skip this filter
-                # or handle as needed (e.g., return no results for invalid code format)
                 logger.warning(f"Invalid format for error_code_search: '{error_code_search}'. Expected an integer. Skipping error code filter.")
-                # Optionally, force no results if the format is invalid:
-                # query = query.where(False) # This ensures no rows are returned
 
-        # 添加排序逻辑
-        sort_column = getattr(ErrorLog, sort_by, ErrorLog.id) # 获取排序字段，默认为 id
+        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))
 
-        # Apply limit and offset
         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)}") # Use exception for stack trace
+        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, # Added error code search
+    error_code_search: Optional[str] = None,
     start_date: Optional[datetime] = None,
     end_date: Optional[datetime] = None
 ) -> int:
@@ -254,7 +245,6 @@ async def get_error_logs_count(
     try:
         query = select(func.count()).select_from(ErrorLog)
 
-        # Apply the same filters as get_error_logs
         if key_search:
             query = query.where(ErrorLog.gemini_key.ilike(f"%{key_search}%"))
         if error_search:
@@ -265,23 +255,19 @@ async def get_error_logs_count(
         if start_date:
             query = query.where(ErrorLog.request_time >= start_date)
         if end_date:
-            # Use the datetime object directly for comparison
             query = query.where(ErrorLog.request_time < end_date)
         if error_code_search:
             try:
-                # Attempt to convert search string to integer for exact match
                 error_code_int = int(error_code_search)
                 query = query.where(ErrorLog.error_code == error_code_int)
             except ValueError:
-                # If conversion fails, log a warning and potentially skip this filter
                 logger.warning(f"Invalid format for error_code_search in count: '{error_code_search}'. Expected an integer. Skipping error code filter.")
-                # Optionally, force count to 0 if the format is invalid:
-                # return 0 # Or query = query.where(False) before fetching
+
 
         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)}") # Use exception for stack trace
+        logger.exception(f"Failed to count error logs with filters: {str(e)}")
         raise
 
 
@@ -307,7 +293,7 @@ async def get_error_log_details(log_id: int) -> Optional[Dict[str, Any]]:
                 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']) # Fallback to string
+                    log_dict['request_msg'] = str(log_dict['request_msg'])
             return log_dict
         else:
             return None
@@ -315,7 +301,6 @@ async def get_error_log_details(log_id: int) -> Optional[Dict[str, Any]]:
         logger.exception(f"Failed to get error log details for ID {log_id}: {str(e)}")
         raise
 
-# --- 异步删除函数 (使用 databases 库) ---
 
 async def delete_error_logs_by_ids(log_ids: List[int]) -> int:
     """
@@ -345,7 +330,7 @@ async def delete_error_logs_by_ids(log_ids: List[int]) -> int:
     except Exception as e:
         # 数据库连接或执行错误
         logger.error(f"Error during bulk deletion of error logs {log_ids}: {e}", exc_info=True)
-        raise # Re-raise the exception for the router to handle
+        raise
 
 async def delete_error_log_by_id(log_id: int) -> bool:
     """
@@ -364,7 +349,7 @@ async def delete_error_log_by_id(log_id: int) -> bool:
 
         if not exists:
             logger.warning(f"Attempted to delete non-existent error log with ID: {log_id}")
-            return False # 或者可以抛出 404 异常，由路由处理
+            return False
 
         # 执行删除
         delete_query = delete(ErrorLog).where(ErrorLog.id == log_id)
@@ -373,10 +358,36 @@ async def delete_error_log_by_id(log_id: int) -> bool:
         return True
     except Exception as e:
         logger.error(f"Error deleting error log with ID {log_id}: {e}", exc_info=True)
-        raise # Re-raise the exception for the router to handle
-
-# --- RequestLog Services (保持异步) ---
-
+        raise
+ 
+ 
+async def delete_all_error_logs() -> int:
+    """
+    删除所有错误日志条目。
+ 
+    Returns:
+        int: 被删除的错误日志数量。
+    """
+    try:
+        # 1. 获取删除前的总数
+        count_query = select(func.count()).select_from(ErrorLog)
+        total_to_delete = await database.fetch_val(count_query)
+ 
+        if total_to_delete == 0:
+            logger.info("No error logs found to delete.")
+            return 0
+ 
+        # 2. 执行删除操作
+        delete_query = delete(ErrorLog)
+        await database.execute(delete_query)
+        
+        logger.info(f"Successfully deleted all {total_to_delete} error logs.")
+        return total_to_delete
+    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],
@@ -412,7 +423,6 @@ async def add_request_log(
             latency_ms=latency_ms
         )
         await database.execute(query)
-        # logger.debug(f"Added request log: key={api_key[:4]}..., success={is_success}, model={model_name}") # Use debug level
         return True
     except Exception as e:
         logger.error(f"Failed to add request log: {str(e)}")

app/domain/gemini_models.py

@@ -40,15 +40,16 @@ class GenerationConfig(BaseModel):
     frequencyPenalty: Optional[float] = None
     responseLogprobs: Optional[bool] = None
     logprobs: Optional[int] = None
+    thinkingConfig: Optional[Dict[str, Any]] = None
 
 
 class SystemInstruction(BaseModel):
-    role: str = "system"
-    parts: List[Dict[str, Any]] | Dict[str, Any]
+    role: Optional[str] = "system"
+    parts: Union[List[Dict[str, Any]], Dict[str, Any]]
 
 
 class GeminiContent(BaseModel):
-    role: str
+    role: Optional[str] = None
     parts: List[Dict[str, Any]]
 
 

app/domain/image_models.py

@@ -1,23 +1,20 @@
+from typing import Union
+
+
 class ImageMetadata:
-    def __init__(self, width: int, height: int, filename: str, size: int, url: str, delete_url: str | None = None):
+    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

@@ -33,3 +33,10 @@ class ImageGenerationRequest(BaseModel):
     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/handler/message_converter.py

@@ -128,12 +128,7 @@ class OpenAIMessageConverter(MessageConverter):
             raise ValueError(f"Unsupported media format: {format}")
 
         try:
-            # Decode Base64 to check size
-            # Be careful with memory usage for very large files
-            # Consider streaming decoding or checking length heuristic first if memory is a concern
-            decoded_data = base64.b64decode(
-                data, validate=True
-            )  # Use validate=True for stricter check
+            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)."
@@ -141,7 +136,6 @@ class OpenAIMessageConverter(MessageConverter):
                 raise ValueError(
                     f"Media data size exceeds limit of {max_size // 1024 // 1024}MB"
                 )
-            # No need to return decoded_data, just the original base64 if valid
             return data
         except base64.binascii.Error as e:
             logger.error(f"Invalid Base64 data provided: {e}")
@@ -163,7 +157,6 @@ class OpenAIMessageConverter(MessageConverter):
             if "content" in msg and isinstance(msg["content"], list):
                 for content_item in msg["content"]:
                     if not isinstance(content_item, dict):
-                        # Skip non-dict items if any unexpected format appears
                         logger.warning(
                             f"Skipping unexpected content item format: {type(content_item)}"
                         )
@@ -184,13 +177,11 @@ class OpenAIMessageConverter(MessageConverter):
                             logger.error(
                                 f"Failed to convert image URL {content_item['image_url']['url']}: {e}"
                             )
-                            # Decide how to handle: skip part, add error text, etc.
                             parts.append(
                                 {
                                     "text": f"[Error processing image: {content_item['image_url']['url']}]"
                                 }
                             )
-                    # --- Add handling for input_audio ---
                     elif content_type == "input_audio" and content_item.get(
                         "input_audio"
                     ):
@@ -205,7 +196,6 @@ class OpenAIMessageConverter(MessageConverter):
                             continue
 
                         try:
-                            # Validate size and format
                             validated_data = self._validate_media_data(
                                 audio_format,
                                 audio_data,

app/handler/response_handler.py

@@ -39,13 +39,13 @@ class GeminiResponseHandler(ResponseHandler):
 def _handle_openai_stream_response(
     response: Dict[str, Any], model: str, finish_reason: str, usage_metadata: Optional[Dict[str, Any]]
 ) -> Dict[str, Any]:
-    text, tool_calls = _extract_result(
+    text, reasoning_content, tool_calls, _ = _extract_result(
         response, model, stream=True, gemini_format=False
     )
-    if not text and not tool_calls:
+    if not text and not tool_calls and not reasoning_content:
         delta = {}
     else:
-        delta = {"content": text, "role": "assistant"}
+        delta = {"content": text, "reasoning_content": reasoning_content, "role": "assistant"}
         if tool_calls:
             delta["tool_calls"] = tool_calls
     template_chunk = {
@@ -63,7 +63,7 @@ def _handle_openai_stream_response(
 def _handle_openai_normal_response(
     response: Dict[str, Any], model: str, finish_reason: str, usage_metadata: Optional[Dict[str, Any]]
 ) -> Dict[str, Any]:
-    text, tool_calls = _extract_result(
+    text, reasoning_content, tool_calls, _ = _extract_result(
         response, model, stream=False, gemini_format=False
     )
     return {
@@ -77,6 +77,7 @@ def _handle_openai_normal_response(
                 "message": {
                     "role": "assistant",
                     "content": text,
+                    "reasoning_content": reasoning_content,
                     "tool_calls": tool_calls,
                 },
                 "finish_reason": finish_reason,
@@ -156,17 +157,22 @@ def _extract_result(
     model: str,
     stream: bool = False,
     gemini_format: bool = False,
-) -> tuple[str, List[Dict[str, Any]]]:
-    text, tool_calls = "", []
+) -> 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:
-                return "", []
+                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]:
@@ -184,30 +190,18 @@ def _extract_result(
     else:
         if response.get("candidates"):
             candidate = response["candidates"][0]
-            if "thinking" in model:
-                if settings.SHOW_THINKING_PROCESS:
-                    if len(candidate["content"]["parts"]) == 2:
-                        text = (
-                            "> thinking\n\n"
-                            + candidate["content"]["parts"][0]["text"]
-                            + "\n\n---\n> output\n\n"
-                            + candidate["content"]["parts"][1]["text"]
-                        )
-                    else:
-                        text = candidate["content"]["parts"][0]["text"]
-                else:
-                    if len(candidate["content"]["parts"]) == 2:
-                        text = candidate["content"]["parts"][1]["text"]
-                    else:
-                        text = candidate["content"]["parts"][0]["text"]
-            else:
-                text = ""
-                if "parts" in candidate["content"]:
-                    for part in candidate["content"]["parts"]:
-                        if "text" in part:
+            text, reasoning_content = "", ""
+            if "parts" in candidate["content"]:
+                for part in candidate["content"]["parts"]:
+                    if "text" in part:
+                        if "thought" in part and settings.SHOW_THINKING_PROCESS:
+                            reasoning_content += part["text"]
+                        else:
                             text += part["text"]
-                        elif "inlineData" in part:
-                            text += _extract_image_data(part)
+                        if "thought" in part and thought is None:
+                            thought = part.get("thought")
+                    elif "inlineData" in part:
+                        text += _extract_image_data(part)
 
             text = _add_search_link_text(model, candidate, text)
             tool_calls = _extract_tool_calls(
@@ -215,7 +209,7 @@ def _extract_result(
             )
         else:
             text = "暂无返回"
-    return text, tool_calls
+    return text, reasoning_content, tool_calls, thought
 
 
 def _extract_image_data(part: dict) -> str:
@@ -233,6 +227,7 @@ def _extract_image_data(part: dict) -> str:
             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"
@@ -288,13 +283,16 @@ def _extract_tool_calls(
 def _handle_gemini_stream_response(
     response: Dict[str, Any], model: str, stream: bool
 ) -> Dict[str, Any]:
-    text, tool_calls = _extract_result(
+    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:
-        content = {"parts": [{"text": text}], "role": "model"}
+        part = {"text": text}
+        if thought is not None:
+            part["thought"] = thought
+        content = {"parts": [part], "role": "model"}
     response["candidates"][0]["content"] = content
     return response
 
@@ -302,13 +300,18 @@ def _handle_gemini_stream_response(
 def _handle_gemini_normal_response(
     response: Dict[str, Any], model: str, stream: bool
 ) -> Dict[str, Any]:
-    text, tool_calls = _extract_result(
+    text, reasoning_content, tool_calls, thought = _extract_result(
         response, model, stream=stream, gemini_format=True
     )
+    parts = []
     if tool_calls:
-        content = {"parts": tool_calls, "role": "model"}
+        parts = tool_calls
     else:
-        content = {"parts": [{"text": text}], "role": "model"}
+        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
 

app/log/logger.py

@@ -223,3 +223,11 @@ def get_openai_compatible_logger():
 def get_error_log_logger():
     return Logger.setup_logger("error_log")
 
+
+def get_request_log_logger():
+    return Logger.setup_logger("request_log")
+
+
+def get_vertex_express_logger():
+    return Logger.setup_logger("vertex_express")
+

app/main.py

@@ -1,4 +1,8 @@
 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/middleware/middleware.py

@@ -8,6 +8,7 @@ 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
@@ -32,6 +33,7 @@ class AuthMiddleware(BaseHTTPMiddleware):
             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")
         ):
 
             auth_token = request.cookies.get("auth_token")
@@ -51,6 +53,9 @@ def setup_middlewares(app: FastAPI) -> None:
     Args:
         app: FastAPI应用程序实例
     """
+    # 添加智能路由中间件（必须在认证中间件之前）
+    app.add_middleware(SmartRoutingMiddleware)
+
     # 添加认证中间件
     app.add_middleware(AuthMiddleware)
 
@@ -60,7 +65,7 @@ def setup_middlewares(app: FastAPI) -> None:
     # 配置CORS中间件
     app.add_middleware(
         CORSMiddleware,
-        allow_origins=["*"],  # 生产环境建议配置具体的域名
+        allow_origins=["*"],
         allow_credentials=True,
         allow_methods=[
             "GET",
@@ -68,8 +73,8 @@ def setup_middlewares(app: FastAPI) -> None:
             "PUT",
             "DELETE",
             "OPTIONS",
-        ],  # 明确指定允许的HTTP方法
-        allow_headers=["*"],  # 生产环境建议配置具体的请求头
-        expose_headers=["*"],  # 允许前端访问的响应头
-        max_age=600,  # 预检请求缓存时间(秒)
+        ],
+        allow_headers=["*"],
+        expose_headers=["*"],
+        max_age=600,
     )

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

@@ -55,7 +55,6 @@ async def reset_config(request: Request):
         raise HTTPException(status_code=400, detail=str(e))
 
 
-# Pydantic model for bulk delete request
 class DeleteKeysRequest(BaseModel):
     keys: List[str] = Field(..., description="List of API keys to delete")
 
@@ -70,9 +69,6 @@ async def delete_single_key(key_to_delete: str, request: Request):
         logger.info(f"Attempting to delete key: {key_to_delete}")
         result = await ConfigService.delete_key(key_to_delete)
         if not result.get("success"):
-            # Optionally, translate specific errors to HTTP status codes
-            # For now, let's assume 400 for any failure from service if not found,
-            # or 500 if it was an unexpected error (though service should handle that)
             raise HTTPException(
                 status_code=(
                     404 if "not found" in result.get("message", "").lower() else 400
@@ -81,7 +77,6 @@ async def delete_single_key(key_to_delete: str, request: Request):
             )
         return result
     except HTTPException as e:
-        # Re-raise HTTPExceptions directly
         raise e
     except Exception as e:
         logger.error(f"Error deleting key '{key_to_delete}': {e}", exc_info=True)
@@ -104,14 +99,10 @@ async def delete_selected_keys_route(
     try:
         logger.info(f"Attempting to bulk delete {len(delete_request.keys)} keys.")
         result = await ConfigService.delete_selected_keys(delete_request.keys)
-        # Similar to single delete, we can check result["success"]
         if not result.get("success") and result.get("deleted_count", 0) == 0:
-            # If no keys were actually deleted, it might be a client error (e.g., all keys not found)
-            # or an empty list was somehow passed despite the check above.
             raise HTTPException(
                 status_code=400, detail=result.get("message", "Failed to delete keys.")
             )
-        # If some keys were deleted but others not found, it's still a partial success, return 200 with details.
         return result
     except HTTPException as e:
         raise e

app/router/error_log_routes.py

@@ -183,6 +183,28 @@ async def delete_error_logs_bulk_api(
         )
 
 
+@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:
+        deleted_count = await error_log_service.process_delete_all_error_logs()
+        logger.info(f"Successfully deleted all {deleted_count} 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)):
     """
@@ -192,7 +214,7 @@ async def delete_error_log_api(request: Request, log_id: int = Path(..., ge=1)):
     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:

app/router/gemini_routes.py

@@ -151,6 +151,35 @@ async def stream_generate_content(
         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: {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("/reset-all-fail-counts")
 async def reset_all_key_fail_counts(key_type: str = None, key_manager: KeyManager = Depends(get_key_manager)):
     """批量重置Gemini API密钥的失败计数，可选择性地仅重置有效或无效密钥"""

app/router/openai_routes.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends, HTTPException, Response
 from fastapi.responses import StreamingResponse
 
 from app.config.config import settings
@@ -7,6 +7,7 @@ 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
@@ -14,6 +15,7 @@ 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
 
@@ -24,6 +26,7 @@ security_service = SecurityService()
 model_service = ModelService()
 embedding_service = EmbeddingService()
 image_create_service = ImageCreateService()
+tts_service = TTSService()
 
 
 async def get_key_manager():
@@ -41,6 +44,11 @@ async def get_openai_chat_service(key_manager: KeyManager = Depends(get_key_mana
     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(
@@ -147,3 +155,21 @@ async def get_keys_list(
             },
             "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: {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

@@ -8,7 +8,7 @@ from fastapi.templating import Jinja2Templates
 
 from app.core.security import verify_auth_token
 from app.log.logger import get_routes_logger
-from app.router import error_log_routes, gemini_routes, openai_routes, config_routes, scheduler_routes, stats_routes, version_routes, openai_compatiable_routes
+from app.router import error_log_routes, gemini_routes, openai_routes, config_routes, scheduler_routes, stats_routes, version_routes, openai_compatiable_routes, vertex_express_routes
 from app.service.key.key_manager import get_key_manager_instance
 from app.service.stats.stats_service import StatsService
 
@@ -33,6 +33,7 @@ def setup_routers(app: FastAPI) -> None:
     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)
 
     setup_page_routes(app)
 

app/router/vertex_express_routes.py

@@ -0,0 +1,146 @@
+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
+
+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_first_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: {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: {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: {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

@@ -58,21 +58,18 @@ async def check_failed_keys():
                     contents=[
                         GeminiContent(
                             role="user",
-                            parts=[{"text": "hi"}],  # 使用简单的文本进行验证
+                            parts=[{"text": "hi"}],
                         )
                     ]
                 )
-                # 调用 generate_content 进行验证
                 await chat_service.generate_content(
-                    settings.TEST_MODEL, gemini_request, key  # 使用配置中定义的测试模型
+                    settings.TEST_MODEL, gemini_request, key
                 )
-                # 如果没有抛出异常，说明 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."
                 )

app/service/chat/gemini_chat_service.py

@@ -28,6 +28,33 @@ def _has_image_parts(contents: List[Dict[str, Any]]) -> bool:
     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]]:
     """构建工具"""
     
@@ -40,7 +67,15 @@ def _build_tools(model: str, payload: Dict[str, Any]) -> List[Dict[str, Any]]:
             for k, v in item.items():
                 if k == "functionDeclarations" and v and isinstance(v, list):
                     functions = record.get("functionDeclarations", [])
-                    functions.extend(v)
+                    # 清理每个函数声明中的不支持字段
+                    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
@@ -78,6 +113,26 @@ def _get_safety_settings(model: str) -> List[Dict[str, str]]:
     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()
@@ -87,21 +142,41 @@ def _build_payload(model: str, request: GeminiRequest) -> Dict[str, Any]:
             request_dict["generationConfig"].pop("maxOutputTokens")
     
     payload = {
-        "contents": request_dict.get("contents", []),
+        "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"]
-        
-    if model.endswith("-non-thinking"):
-        payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": 0} 
-    if model in settings.THINKING_BUDGET_MAP:
-        payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": settings.THINKING_BUDGET_MAP.get(model,1000)}
+    
+    # 处理思考配置：优先使用客户端提供的配置，否则使用默认配置
+    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"):
+            payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": 0} 
+        elif 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
 
@@ -131,7 +206,7 @@ class GeminiChatService:
         self, original_response: Dict[str, Any], text: str
     ) -> Dict[str, Any]:
         """创建包含指定文本的响应"""
-        response_copy = json.loads(json.dumps(original_response))  # 深拷贝
+        response_copy = json.loads(json.dumps(original_response))
         if response_copy.get("candidates") and response_copy["candidates"][0].get(
             "content", {}
         ).get("parts"):
@@ -144,7 +219,7 @@ class GeminiChatService:
         """生成内容"""
         payload = _build_payload(model, request)
         start_time = time.perf_counter()
-        request_datetime = datetime.datetime.now() # Record request time
+        request_datetime = datetime.datetime.now()
         is_success = False
         status_code = None
         response = None
@@ -152,20 +227,18 @@ class GeminiChatService:
         try:
             response = await self.api_client.generate_content(payload, model, api_key)
             is_success = True
-            status_code = 200 # Assume 200 on success
+            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}")
-            # Try to parse status code from exception
             match = re.search(r"status code (\d+)", error_log_msg)
             if match:
                 status_code = int(match.group(1))
             else:
-                status_code = 500 # Default to 500 if parsing fails
+                status_code = 500
 
-            # Log error to error log table
             await add_error_log(
                 gemini_key=api_key,
                 model_name=model,
@@ -174,11 +247,58 @@ class GeminiChatService:
                 error_code=status_code,
                 request_msg=payload
             )
-            raise e # Re-throw exception for upstream handling
+            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)
-            # Log request to request log table
             await add_request_log(
                 model_name=model,
                 api_key=api_key,
@@ -203,7 +323,7 @@ class GeminiChatService:
             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
+            final_api_key = current_attempt_key
             try:
                 async for line in self.api_client.stream_generate_content(
                     payload, model, current_attempt_key
@@ -240,16 +360,14 @@ class GeminiChatService:
                 logger.warning(
                     f"Streaming API call failed with error: {error_log_msg}. Attempt {retries} of {max_retries}"
                 )
-                # Parse error code for logging
                 match = re.search(r"status code (\d+)", error_log_msg)
                 if match:
                     status_code = int(match.group(1))
                 else:
                     status_code = 500
 
-                # Log error to error log table
                 await add_error_log(
-                    gemini_key=current_attempt_key, # Log key used for this failed attempt
+                    gemini_key=current_attempt_key,
                     model_name=model,
                     error_type="gemini-chat-stream",
                     error_log=error_log_msg,
@@ -257,28 +375,26 @@ class GeminiChatService:
                     request_msg=payload
                 )
 
-                # Attempt to switch API Key
                 api_key = await self.key_manager.handle_api_failure(current_attempt_key, retries)
                 if api_key:
                     logger.info(f"Switched to new API key: {api_key}")
-                else: # No more keys or retries exceeded by handle_api_failure logic
-                        logger.error(f"No valid API key available after {retries} retries.")
-                        break # Exit loop if no key available
+                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 # Exit loop after max retries
+                    break
             finally:
-                # Log the final outcome of the streaming request
                 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, # Log the last key used
-                    is_success=is_success, # Log the final success status
-                    status_code=status_code, # Log the last known status code
-                    latency_ms=latency_ms, # Log total time including retries
+                    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

@@ -26,16 +26,43 @@ from app.service.key.key_manager import KeyManager
 logger = get_openai_logger()
 
 
-def _has_media_parts(contents: List[Dict[str, Any]]) -> bool:
-    """判断消息是否包含图片、音频或视频部分 (inline_data)"""
-    for content in contents:
-        if content and "parts" in content and isinstance(content["parts"], list):
-            for part in content["parts"]:
-                if isinstance(part, dict) and "inline_data" in part:
+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]]:
@@ -51,7 +78,7 @@ def _build_tools(
             or model.endswith("-image")
             or model.endswith("-image-generation")
         )
-        and not _has_media_parts(messages)  # Use the updated check
+        and not _has_media_parts(messages)
     ):
         tool["codeExecution"] = {}
         logger.debug("Code execution tool enabled.")
@@ -76,6 +103,8 @@ def _build_tools(
                 ):
                     function.pop("parameters", None)
 
+                # 清理函数中的不支持字段
+                function = _clean_json_schema_properties(function)
                 function_declarations.append(function)
 
         if function_declarations:
@@ -83,8 +112,13 @@ def _build_tools(
             names, functions = set(), []
             for fc in function_declarations:
                 if fc.get("name") not in names:
-                    names.add(fc.get("name"))
-                    functions.append(fc)
+                    if fc.get("name")=="googleSearch":
+                        # cherry开启内置搜索时，添加googleSearch工具
+                        tool["googleSearch"] = {}
+                    else:
+                        # 其他函数，添加到functionDeclarations中
+                        names.add(fc.get("name"))
+                        functions.append(fc)
 
             tool["functionDeclarations"] = functions
 
@@ -132,9 +166,13 @@ def _build_payload(
     if request.model.endswith("-non-thinking"):
         payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": 0}
     if request.model in settings.THINKING_BUDGET_MAP:
-        payload["generationConfig"]["thinkingConfig"] = {
-            "thinkingBudget": settings.THINKING_BUDGET_MAP.get(request.model, 1000)
-        }
+        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
@@ -173,7 +211,7 @@ class OpenAIChatService:
         self, original_chunk: Dict[str, Any], text: str
     ) -> Dict[str, Any]:
         """创建包含指定文本的OpenAI响应块"""
-        chunk_copy = json.loads(json.dumps(original_chunk))  # 深拷贝
+        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
@@ -184,10 +222,8 @@ class OpenAIChatService:
         api_key: str,
     ) -> Union[Dict[str, Any], AsyncGenerator[str, None]]:
         """创建聊天完成"""
-        # 转换消息格式
         messages, instruction = self.message_converter.convert(request.messages)
 
-        # 构建请求payload
         payload = _build_payload(request, messages, instruction)
 
         if request.stream:
@@ -219,7 +255,6 @@ class OpenAIChatService:
             is_success = False
             error_log_msg = str(e)
             logger.error(f"Normal API call failed with error: {error_log_msg}")
-            # Try to parse status code from exception
             match = re.search(r"status code (\d+)", error_log_msg)
             if match:
                 status_code = int(match.group(1))
@@ -587,7 +622,6 @@ class OpenAIChatService:
                 error_code=status_code,
                 request_msg={"image_data_truncated": image_data[:1000]},
             )
-            # Re-raise the exception so the caller knows about the failure
             raise e
         finally:
             end_time = time.perf_counter()

app/service/chat/vertex_express_chat_service.py

@@ -0,0 +1,328 @@
+# app/services/chat_service.py
+
+import json
+import re
+import datetime
+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.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.database.services import add_error_log, add_request_log
+
+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 _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
+
+    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))
+
+    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"] = {}
+
+    # 解决 "Tool use with function calling is unsupported" 问题
+    if tool.get("functionDeclarations"):
+        tool.pop("googleSearch", None)
+        tool.pop("codeExecution", None)
+
+    return [tool] if tool else []
+
+
+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()
+    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"):
+            payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": 0} 
+        elif 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
+            )
+            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
+                )
+
+                api_key = await self.key_manager.handle_api_failure(current_attempt_key, retries)
+                if api_key:
+                    logger.info(f"Switched to new API key: {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

@@ -40,29 +40,38 @@ class GeminiApiClient(ApiClient):
             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:
-            proxy_to_use = random.choice(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}"
+            url = f"{self.base_url}/models?key={api_key}&pageSize=1000"
             try:
-                response = await client.get(url)
-                response.raise_for_status()  # 如果状态码不是 2xx，则引发 HTTPStatusError
+                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)
-                # 返回 None 而不是抛出异常，以便上层处理
                 return None
             except httpx.RequestError as e:
                 logger.error(f"请求模型列表失败: {e}")
-                # 返回 None 而不是抛出异常
                 return None
             
     async def generate_content(self, payload: Dict[str, Any], model: str, api_key: str) -> Dict[str, Any]:
@@ -71,12 +80,16 @@ class GeminiApiClient(ApiClient):
 
         proxy_to_use = None
         if settings.PROXIES:
-            proxy_to_use = random.choice(settings.PROXIES)
-            logger.info(f"Using proxy: {proxy_to_use}")
+            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}"
-            response = await client.post(url, json=payload)
+            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}")
@@ -88,12 +101,16 @@ class GeminiApiClient(ApiClient):
         
         proxy_to_use = None
         if settings.PROXIES:
-            proxy_to_use = random.choice(settings.PROXIES)
-            logger.info(f"Using proxy: {proxy_to_use}")
+            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) as response:
+            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")
@@ -101,6 +118,27 @@ class GeminiApiClient(ApiClient):
                 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()
+
 
 class OpenaiApiClient(ApiClient):
     """OpenAI API客户端"""
@@ -109,11 +147,27 @@ class OpenaiApiClient(ApiClient):
         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)
-        async with httpx.AsyncClient(timeout=timeout) as client:
+
+        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"
-            headers = {"Authorization": f"Bearer {api_key}"}
             response = await client.get(url, headers=headers)
             if response.status_code != 200:
                 error_content = response.text
@@ -122,15 +176,18 @@ class OpenaiApiClient(ApiClient):
 
     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:
-            proxy_to_use = random.choice(settings.PROXIES)
-            logger.info(f"Using proxy: {proxy_to_use}")
+            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"
-            headers = {"Authorization": f"Bearer {api_key}"}
             response = await client.post(url, json=payload, headers=headers)
             if response.status_code != 200:
                 error_content = response.text
@@ -139,15 +196,17 @@ class OpenaiApiClient(ApiClient):
 
     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:
-            proxy_to_use = random.choice(settings.PROXIES)
-            logger.info(f"Using proxy: {proxy_to_use}")
+            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"
-            headers = {"Authorization": f"Bearer {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()
@@ -161,12 +220,15 @@ class OpenaiApiClient(ApiClient):
         
         proxy_to_use = None
         if settings.PROXIES:
-            proxy_to_use = random.choice(settings.PROXIES)
-            logger.info(f"Using proxy: {proxy_to_use}")
+            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"
-            headers = {"Authorization": f"Bearer {api_key}"}
             payload = {
                 "input": input,
                 "model": model,
@@ -179,15 +241,18 @@ class OpenaiApiClient(ApiClient):
                     
     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:
-            proxy_to_use = random.choice(settings.PROXIES)
-            logger.info(f"Using proxy: {proxy_to_use}")
+            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"
-            headers = {"Authorization": f"Bearer {api_key}"}
             response = await client.post(url, json=payload, headers=headers)
             if response.status_code != 200:
                 error_content = response.text

app/service/config/config_service.py

@@ -55,7 +55,7 @@ class ConfigService:
             # 处理不同类型的值
             if isinstance(value, list):
                 db_value = json.dumps(value)
-            elif isinstance(value, dict):  # 新增对 dict 类型的处理
+            elif isinstance(value, dict):
                 db_value = json.dumps(value)
             elif isinstance(value, bool):
                 db_value = str(value).lower()
@@ -76,7 +76,6 @@ class ConfigService:
             }
 
             if key in existing_keys:
-                # Preserve original description if not explicitly provided
                 data["description"] = existing_settings_map[key].get(
                     "description", description
                 )
@@ -111,17 +110,15 @@ class ConfigService:
                         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  # Re-raise the exception after logging
+                raise
 
         # 重置并重新初始化 KeyManager
         try:
             await reset_key_manager_instance()
-            await get_key_manager_instance(settings.API_KEYS)
+            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)}")
-            # Decide if this error should prevent returning the updated config
-            # For now, we log the error and continue
 
         return await ConfigService.get_config()
 
@@ -157,7 +154,7 @@ class ConfigService:
         deleted_count = 0
         not_found_keys: List[str] = []
 
-        current_api_keys = list(settings.API_KEYS)  # 创建副本以进行修改
+        current_api_keys = list(settings.API_KEYS)
         keys_actually_removed: List[str] = []
 
         for key_to_del in keys_to_delete:
@@ -169,7 +166,7 @@ class ConfigService:
                 not_found_keys.append(key_to_del)
 
         if deleted_count > 0:
-            settings.API_KEYS = current_api_keys  # 更新内存中的 settings
+            settings.API_KEYS = current_api_keys
             await ConfigService.update_config({"API_KEYS": settings.API_KEYS})
             logger.info(
                 f"成功删除 {deleted_count} 个密钥。密钥: {keys_actually_removed}"
@@ -185,9 +182,9 @@ class ConfigService:
             }
         else:
             message = "没有密钥被删除。"
-            if not_found_keys:  # 如果提供了密钥但都未找到
+            if not_found_keys:
                 message = f"所有 {len(not_found_keys)} 个指定的密钥均未找到: {not_found_keys}。"
-            elif not keys_to_delete:  # 如果 keys_to_delete 列表为空
+            elif not keys_to_delete:
                 message = "未指定要删除的密钥。"
             logger.warning(message)
             return {
@@ -244,13 +241,11 @@ class ConfigService:
             models = await model_service.get_gemini_openai_models(api_key)
             return models
         except HTTPException as e:
-            # Re-raise HTTPExceptions directly if they are already specific
             raise e
         except Exception as e:
             logger.error(
                 f"Failed to fetch models for UI in ConfigService: {e}", exc_info=True
             )
-            # Raise a generic HTTPException for other errors
             raise HTTPException(
                 status_code=500, detail=f"Failed to fetch models for UI: {str(e)}"
             )

app/service/embedding/embedding_service.py

@@ -1,15 +1,15 @@
 import datetime
 import time
-import re # For potential status code parsing from generic errors
+import re
 from typing import List, Union
 
 import openai
-from openai import APIStatusError # Import specific error type
+from openai import APIStatusError
 from openai.types import CreateEmbeddingResponse
 
 from app.config.config import settings
 from app.log.logger import get_embeddings_logger
-from app.database.services import add_error_log, add_request_log # Import DB logging functions
+from app.database.services import add_error_log, add_request_log
 
 logger = get_embeddings_logger()
 
@@ -26,7 +26,6 @@ class EmbeddingService:
         status_code = None
         response = None
         error_log_msg = ""
-        # Prepare request message for logging (truncate if list or long string)
         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:
@@ -46,32 +45,29 @@ class EmbeddingService:
             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 # Re-raise the specific error
+            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}")
-            # Try to parse status code from generic error (less reliable)
             match = re.search(r"status code (\d+)", str(e))
             if match:
                 status_code = int(match.group(1))
             else:
-                status_code = 500 # Default if parsing fails
-            raise e # Re-raise the generic error
+                status_code = 500
+            raise e
         finally:
             end_time = time.perf_counter()
             latency_ms = int((end_time - start_time) * 1000)
             if not is_success:
-                 # Log error to database if it failed
-                 await add_error_log(
-                     gemini_key=api_key, # Using gemini_key parameter name for consistency
-                     model_name=model,
-                     error_type="openai-embedding",
-                     error_log=error_log_msg,
-                     error_code=status_code,
-                     request_msg=request_msg_log
+                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
                  )
-            # Log request outcome to database regardless of success/failure
             await add_request_log(
                 model_name=model,
                 api_key=api_key,

app/service/error_log/error_log_service.py

@@ -153,3 +153,26 @@ async def process_delete_error_log_by_id(log_id: int) -> bool:
             exc_info=True,
         )
         raise
+
+
+async def process_delete_all_error_logs() -> int:
+    """
+    处理删除所有错误日志的请求。
+    返回删除的日志数量。
+    """
+    try:
+        if not database.is_connected:
+            await database.connect()
+            logger.info("Database connection established for deleting all error logs.")
+
+        deleted_count = await db_services.delete_all_error_logs()
+        logger.info(
+            f"Successfully processed request to delete all error logs. Count: {deleted_count}"
+        )
+        return deleted_count
+    except Exception as e:
+        logger.error(
+            f"Service error in process_delete_all_error_logs: {e}",
+            exc_info=True,
+        )
+        raise

app/service/image/image_create_service.py

@@ -121,6 +121,7 @@ class ImageCreateService:
                             provider=settings.UPLOAD_PROVIDER,
                             base_url=settings.CLOUDFLARE_IMGBED_URL,
                             auth_code=settings.CLOUDFLARE_IMGBED_AUTH_CODE,
+                            upload_folder=settings.CLOUDFLARE_IMGBED_UPLOAD_FOLDER,
                         )
                     else:
                         raise ValueError(
@@ -137,7 +138,7 @@ class ImageCreateService:
                     )
 
             response_data = {
-                "created": int(time.time()),  # Current timestamp
+                "created": int(time.time()),
                 "data": images_data,
             }
             return response_data

app/service/key/key_manager.py

@@ -1,6 +1,6 @@
 import asyncio
 from itertools import cycle
-from typing import Dict
+from typing import Dict, Union
 
 from app.config.config import settings
 from app.log.logger import get_key_manager_logger
@@ -9,12 +9,19 @@ logger = get_key_manager_logger()
 
 
 class KeyManager:
-    def __init__(self, api_keys: list):
+    def __init__(self, api_keys: list, vertex_api_keys: list):
         self.api_keys = api_keys
+        self.vertex_api_keys = vertex_api_keys
         self.key_cycle = cycle(api_keys)
+        self.vertex_key_cycle = cycle(vertex_api_keys)
         self.key_cycle_lock = asyncio.Lock()
+        self.vertex_key_cycle_lock = asyncio.Lock()
         self.failure_count_lock = asyncio.Lock()
+        self.vertex_failure_count_lock = asyncio.Lock()
         self.key_failure_counts: Dict[str, int] = {key: 0 for key in api_keys}
+        self.vertex_key_failure_counts: Dict[str, int] = {
+            key: 0 for key in vertex_api_keys
+        }
         self.MAX_FAILURES = settings.MAX_FAILURES
         self.paid_key = settings.PAID_KEY
 
@@ -26,17 +33,33 @@ class KeyManager:
         async with self.key_cycle_lock:
             return next(self.key_cycle)
 
+    async def get_next_vertex_key(self) -> str:
+        """获取下一个 Vertex Express API key"""
+        async with self.vertex_key_cycle_lock:
+            return next(self.vertex_key_cycle)
+
     async def is_key_valid(self, key: str) -> bool:
         """检查key是否有效"""
         async with self.failure_count_lock:
             return self.key_failure_counts[key] < self.MAX_FAILURES
 
+    async def is_vertex_key_valid(self, key: str) -> bool:
+        """检查 Vertex key 是否有效"""
+        async with self.vertex_failure_count_lock:
+            return self.vertex_key_failure_counts[key] < self.MAX_FAILURES
+
     async def reset_failure_counts(self):
         """重置所有key的失败计数"""
         async with self.failure_count_lock:
             for key in self.key_failure_counts:
                 self.key_failure_counts[key] = 0
 
+    async def reset_vertex_failure_counts(self):
+        """重置所有 Vertex key 的失败计数"""
+        async with self.vertex_failure_count_lock:
+            for key in self.vertex_key_failure_counts:
+                self.vertex_key_failure_counts[key] = 0
+
     async def reset_key_failure_count(self, key: str) -> bool:
         """重置指定key的失败计数"""
         async with self.failure_count_lock:
@@ -49,6 +72,18 @@ class KeyManager:
             )
             return False
 
+    async def reset_vertex_key_failure_count(self, key: str) -> bool:
+        """重置指定 Vertex key 的失败计数"""
+        async with self.vertex_failure_count_lock:
+            if key in self.vertex_key_failure_counts:
+                self.vertex_key_failure_counts[key] = 0
+                logger.info(f"Reset failure count for Vertex key: {key}")
+                return True
+            logger.warning(
+                f"Attempt to reset failure count for non-existent Vertex key: {key}"
+            )
+            return False
+
     async def get_next_working_key(self) -> str:
         """获取下一可用的API key"""
         initial_key = await self.get_next_key()
@@ -60,7 +95,19 @@ class KeyManager:
 
             current_key = await self.get_next_key()
             if current_key == initial_key:
-                # await self.reset_failure_counts() 取消重置
+                return current_key
+
+    async def get_next_working_vertex_key(self) -> str:
+        """获取下一可用的 Vertex Express API key"""
+        initial_key = await self.get_next_vertex_key()
+        current_key = initial_key
+
+        while True:
+            if await self.is_vertex_key_valid(current_key):
+                return current_key
+
+            current_key = await self.get_next_vertex_key()
+            if current_key == initial_key:
                 return current_key
 
     async def handle_api_failure(self, api_key: str, retries: int) -> str:
@@ -76,10 +123,23 @@ class KeyManager:
         else:
             return ""
 
+    async def handle_vertex_api_failure(self, api_key: str, retries: int) -> str:
+        """处理 Vertex Express API 调用失败"""
+        async with self.vertex_failure_count_lock:
+            self.vertex_key_failure_counts[api_key] += 1
+            if self.vertex_key_failure_counts[api_key] >= self.MAX_FAILURES:
+                logger.warning(
+                    f"Vertex Express API key {api_key} has failed {self.MAX_FAILURES} times"
+                )
+
     def get_fail_count(self, key: str) -> int:
         """获取指定密钥的失败次数"""
         return self.key_failure_counts.get(key, 0)
 
+    def get_vertex_fail_count(self, key: str) -> int:
+        """获取指定 Vertex 密钥的失败次数"""
+        return self.vertex_key_failure_counts.get(key, 0)
+
     async def get_keys_by_status(self) -> dict:
         """获取分类后的API key列表，包括失败次数"""
         valid_keys = {}
@@ -95,102 +155,118 @@ class KeyManager:
 
         return {"valid_keys": valid_keys, "invalid_keys": invalid_keys}
 
+    async def get_vertex_keys_by_status(self) -> dict:
+        """获取分类后的 Vertex Express API key 列表，包括失败次数"""
+        valid_keys = {}
+        invalid_keys = {}
+
+        async with self.vertex_failure_count_lock:
+            for key in self.vertex_api_keys:
+                fail_count = self.vertex_key_failure_counts[key]
+                if fail_count < self.MAX_FAILURES:
+                    valid_keys[key] = fail_count
+                else:
+                    invalid_keys[key] = fail_count
+        return {"valid_keys": valid_keys, "invalid_keys": invalid_keys}
+
     async def get_first_valid_key(self) -> str:
         """获取第一个有效的API key"""
         async with self.failure_count_lock:
             for key in self.key_failure_counts:
                 if self.key_failure_counts[key] < self.MAX_FAILURES:
                     return key
-        # 如果所有 key 都无效，或者列表为空，则尝试返回第一个（如果列表不为空）
-        # 或者根据具体逻辑处理，这里保持原样，可能在空列表或全无效时需要调整
         if self.api_keys:
             return self.api_keys[0]
-        # 如果 api_keys 为空，这里会出问题。实际应用中应有非空保证或更好处理。
-        # 为了保持接口一致性，如果列表为空，可能应该抛出异常或返回特定值。
-        # 暂且假设 api_keys 不会为空，或者调用者处理后续的空 key 问题。
-        # 根据现有代码，如果api_keys为空，self.api_keys[0]会报错。
-        # 如果没有有效key且列表不空，返回第一个。若列表为空，这里会出IndexError。
-        # 更安全的做法是：
         if not self.api_keys:
             logger.warning("API key list is empty, cannot get first valid key.")
-            # Depending on desired behavior, either raise error or return an indicator like "" or None
-            # For now, let's allow it to potentially fail if a key is expected by caller
-            # but it's better to be explicit. Let's return empty string for consistency with handle_api_failure
             return ""
-        return self.api_keys[
-            0
-        ]  # Fallback to the first key if no key is "valid" but list is not empty
+        return self.api_keys[0]
 
 
 _singleton_instance = None
 _singleton_lock = asyncio.Lock()
-_preserved_failure_counts: Dict[str, int] | None = None
-_preserved_old_api_keys_for_reset: list | None = None
-_preserved_next_key_in_cycle: str | None = None
+_preserved_failure_counts: Union[Dict[str, int], None] = None
+_preserved_vertex_failure_counts: Union[Dict[str, int], None] = None
+_preserved_old_api_keys_for_reset: Union[list, None] = None
+_preserved_vertex_old_api_keys_for_reset: Union[list, None] = None
+_preserved_next_key_in_cycle: Union[str, None] = None
+_preserved_vertex_next_key_in_cycle: Union[str, None] = None
 
 
-async def get_key_manager_instance(api_keys: list = None) -> KeyManager:
+async def get_key_manager_instance(
+    api_keys: list = None, vertex_api_keys: list = None
+) -> KeyManager:
     """
     获取 KeyManager 单例实例。
 
-    如果尚未创建实例，将使用提供的 api_keys 初始化 KeyManager。
+    如果尚未创建实例，将使用提供的 api_keys,vertex_api_keys 初始化 KeyManager。
     如果已创建实例，则忽略 api_keys 参数，返回现有单例。
     如果在重置后调用，会尝试恢复之前的状态（失败计数、循环位置）。
     """
-    global _singleton_instance, _preserved_failure_counts, _preserved_old_api_keys_for_reset, _preserved_next_key_in_cycle
+    global _singleton_instance, _preserved_failure_counts, _preserved_vertex_failure_counts, _preserved_old_api_keys_for_reset, _preserved_vertex_old_api_keys_for_reset, _preserved_next_key_in_cycle, _preserved_vertex_next_key_in_cycle
 
     async with _singleton_lock:
         if _singleton_instance is None:
             if api_keys is None:
-                # This case needs careful handling. If it's the very first call, api_keys are required.
-                # If it's after a reset and no api_keys are provided, what should happen?
-                # The original ValueError was "API keys are required to initialize the KeyManager".
-                # Let's assume if api_keys is None here, it's an error unless we are restoring from non-None _preserved_old_api_keys_for_reset.
-                # However, the user's request implies new api_keys will be part of the reset flow.
-                # For now, stick to a strict requirement for api_keys if _singleton_instance is None.
                 raise ValueError(
                     "API keys are required to initialize or re-initialize the KeyManager instance."
                 )
-            if not api_keys:  # Handle case where api_keys is an empty list
+            if vertex_api_keys is None:
+                raise ValueError(
+                    "Vertex Express API keys are required to initialize or re-initialize the KeyManager instance."
+                )
+
+            if not api_keys:
                 logger.warning(
                     "Initializing KeyManager with an empty list of API keys."
                 )
-                # Consider if this should be an error or allowed. Current KeyManager supports it.
+            if not vertex_api_keys:
+                logger.warning(
+                    "Initializing KeyManager with an empty list of Vertex Express API keys."
+                )
 
-            _singleton_instance = KeyManager(api_keys)
+            _singleton_instance = KeyManager(api_keys, vertex_api_keys)
             logger.info(
-                f"KeyManager instance created/re-created with {len(api_keys)} API keys."
+                f"KeyManager instance created/re-created with {len(api_keys)} API keys and {len(vertex_api_keys)} Vertex Express API keys."
             )
 
             # 1. 恢复失败计数
             if _preserved_failure_counts:
-                # Initialize new instance's failure_counts for all new keys to 0
                 current_failure_counts = {
                     key: 0 for key in _singleton_instance.api_keys
                 }
-                # Inherit counts for keys that exist in both old and new lists
                 for key, count in _preserved_failure_counts.items():
                     if key in current_failure_counts:
                         current_failure_counts[key] = count
                 _singleton_instance.key_failure_counts = current_failure_counts
                 logger.info("Inherited failure counts for applicable keys.")
-            _preserved_failure_counts = None  # Clear after use
+            _preserved_failure_counts = None
+
+            if _preserved_vertex_failure_counts:
+                current_vertex_failure_counts = {
+                    key: 0 for key in _singleton_instance.vertex_api_keys
+                }
+                for key, count in _preserved_vertex_failure_counts.items():
+                    if key in current_vertex_failure_counts:
+                        current_vertex_failure_counts[key] = count
+                _singleton_instance.vertex_key_failure_counts = (
+                    current_vertex_failure_counts
+                )
+                logger.info("Inherited failure counts for applicable Vertex keys.")
+            _preserved_vertex_failure_counts = None
 
             # 2. 调整 key_cycle 的起始点
             start_key_for_new_cycle = None
             if (
                 _preserved_old_api_keys_for_reset
                 and _preserved_next_key_in_cycle
-                and _singleton_instance.api_keys  # Ensure new api_keys list is not empty
+                and _singleton_instance.api_keys
             ):
                 try:
-                    # Find the index of the preserved next key in the *old* list
                     start_idx_in_old = _preserved_old_api_keys_for_reset.index(
                         _preserved_next_key_in_cycle
                     )
 
-                    # Iterate through the old key list (circularly) starting from _preserved_next_key_in_cycle
-                    # Find the first key that also exists in the new api_keys list
                     for i in range(len(_preserved_old_api_keys_for_reset)):
                         current_old_key_idx = (start_idx_in_old + i) % len(
                             _preserved_old_api_keys_for_reset
@@ -214,26 +290,20 @@ async def get_key_manager_instance(api_keys: list = None) -> KeyManager:
 
             if start_key_for_new_cycle and _singleton_instance.api_keys:
                 try:
-                    # Find the index of the determined start_key in the new api_keys list
                     target_idx = _singleton_instance.api_keys.index(
                         start_key_for_new_cycle
                     )
-                    # Advance the new cycle by calling next() target_idx times
-                    # This positions the cycle so that the *next* call to next() will yield start_key_for_new_cycle
                     for _ in range(target_idx):
                         next(_singleton_instance.key_cycle)
                     logger.info(
                         f"Key cycle in new instance advanced. Next call to get_next_key() will yield: {start_key_for_new_cycle}"
                     )
                 except ValueError:
-                    # This should not happen if start_key_for_new_cycle was correctly found in api_keys
                     logger.warning(
                         f"Determined start key '{start_key_for_new_cycle}' not found in new API keys during cycle advancement. "
                         "New cycle will start from the beginning."
                     )
-                except (
-                    StopIteration
-                ):  # Should not happen with cycle unless api_keys is empty, handled by _singleton_instance.api_keys check
+                except StopIteration:
                     logger.error(
                         "StopIteration while advancing key cycle, implies empty new API key list previously missed."
                     )
@@ -254,7 +324,76 @@ async def get_key_manager_instance(api_keys: list = None) -> KeyManager:
             # 清理所有保存的状态
             _preserved_old_api_keys_for_reset = None
             _preserved_next_key_in_cycle = None
-            # _preserved_failure_counts already cleared
+
+            # 3. 调整 vertex_key_cycle 的起始点
+            start_key_for_new_vertex_cycle = None
+            if (
+                _preserved_vertex_old_api_keys_for_reset
+                and _preserved_vertex_next_key_in_cycle
+                and _singleton_instance.vertex_api_keys
+            ):
+                try:
+                    start_idx_in_old = _preserved_vertex_old_api_keys_for_reset.index(
+                        _preserved_vertex_next_key_in_cycle
+                    )
+
+                    for i in range(len(_preserved_vertex_old_api_keys_for_reset)):
+                        current_old_key_idx = (start_idx_in_old + i) % len(
+                            _preserved_vertex_old_api_keys_for_reset
+                        )
+                        key_candidate = _preserved_vertex_old_api_keys_for_reset[
+                            current_old_key_idx
+                        ]
+                        if key_candidate in _singleton_instance.vertex_api_keys:
+                            start_key_for_new_vertex_cycle = key_candidate
+                            break
+                except ValueError:
+                    logger.warning(
+                        f"Preserved next key '{_preserved_vertex_next_key_in_cycle}' not found in preserved old Vertex Express API keys. "
+                        "New cycle will start from the beginning of the new list."
+                    )
+                except Exception as e:
+                    logger.error(
+                        f"Error determining start key for new Vertex key cycle from preserved state: {e}. "
+                        "New cycle will start from the beginning."
+                    )
+
+            if start_key_for_new_vertex_cycle and _singleton_instance.vertex_api_keys:
+                try:
+                    target_idx = _singleton_instance.vertex_api_keys.index(
+                        start_key_for_new_vertex_cycle
+                    )
+                    for _ in range(target_idx):
+                        next(_singleton_instance.vertex_key_cycle)
+                    logger.info(
+                        f"Vertex key cycle in new instance advanced. Next call to get_next_vertex_key() will yield: {start_key_for_new_vertex_cycle}"
+                    )
+                except ValueError:
+                    logger.warning(
+                        f"Determined start key '{start_key_for_new_vertex_cycle}' not found in new Vertex Express API keys during cycle advancement. "
+                        "New cycle will start from the beginning."
+                    )
+                except StopIteration:
+                    logger.error(
+                        "StopIteration while advancing Vertex key cycle, implies empty new Vertex Express API key list previously missed."
+                    )
+                except Exception as e:
+                    logger.error(
+                        f"Error advancing new Vertex key cycle: {e}. Cycle will start from beginning."
+                    )
+            else:
+                if _singleton_instance.vertex_api_keys:
+                    logger.info(
+                        "New Vertex key cycle will start from the beginning of the new Vertex Express API key list (no specific start key determined or needed)."
+                    )
+                else:
+                    logger.info(
+                        "New Vertex key cycle not applicable as the new Vertex Express API key list is empty."
+                    )
+
+            # 清理所有保存的状态
+            _preserved_vertex_old_api_keys_for_reset = None
+            _preserved_vertex_next_key_in_cycle = None
 
         return _singleton_instance
 
@@ -265,31 +404,30 @@ async def reset_key_manager_instance():
     将保存当前实例的状态（失败计数、旧 API keys、下一个 key 提示）
     以供下一次 get_key_manager_instance 调用时恢复。
     """
-    global _singleton_instance, _preserved_failure_counts, _preserved_old_api_keys_for_reset, _preserved_next_key_in_cycle
+    global _singleton_instance, _preserved_failure_counts, _preserved_vertex_failure_counts, _preserved_old_api_keys_for_reset, _preserved_vertex_old_api_keys_for_reset, _preserved_next_key_in_cycle, _preserved_vertex_next_key_in_cycle
     async with _singleton_lock:
         if _singleton_instance:
             # 1. 保存失败计数
             _preserved_failure_counts = _singleton_instance.key_failure_counts.copy()
+            _preserved_vertex_failure_counts = (
+                _singleton_instance.vertex_key_failure_counts.copy()
+            )
 
             # 2. 保存旧的 API keys 列表
             _preserved_old_api_keys_for_reset = _singleton_instance.api_keys.copy()
+            _preserved_vertex_old_api_keys_for_reset = (
+                _singleton_instance.vertex_api_keys.copy()
+            )
 
             # 3. 保存 key_cycle 的下一个 key 提示
-            # This should be the key that get_next_key() would return next.
             try:
-                if (
-                    _singleton_instance.api_keys
-                ):  # Only if there are keys to cycle through
-                    # Calling get_next_key() consumes one key and returns it. This is the key
-                    # we want the new cycle to effectively start with.
+                if _singleton_instance.api_keys:
                     _preserved_next_key_in_cycle = (
                         await _singleton_instance.get_next_key()
                     )
                 else:
-                    _preserved_next_key_in_cycle = None  # No keys, so no next key
-            except (
-                StopIteration
-            ):  # Should be caught by "if _singleton_instance.api_keys"
+                    _preserved_next_key_in_cycle = None
+            except StopIteration:
                 logger.warning(
                     "Could not preserve next key hint: key cycle was empty or exhausted in old instance."
                 )
@@ -298,6 +436,23 @@ async def reset_key_manager_instance():
                 logger.error(f"Error preserving next key hint during reset: {e}")
                 _preserved_next_key_in_cycle = None
 
+            # 4. 保存 vertex_key_cycle 的下一个 key 提示
+            try:
+                if _singleton_instance.vertex_api_keys:
+                    _preserved_vertex_next_key_in_cycle = (
+                        await _singleton_instance.get_next_vertex_key()
+                    )
+                else:
+                    _preserved_vertex_next_key_in_cycle = None
+            except StopIteration:
+                logger.warning(
+                    "Could not preserve next key hint: Vertex key cycle was empty or exhausted in old instance."
+                )
+                _preserved_vertex_next_key_in_cycle = None
+            except Exception as e:
+                logger.error(f"Error preserving next key hint during reset: {e}")
+                _preserved_vertex_next_key_in_cycle = None
+
             _singleton_instance = None
             logger.info(
                 "KeyManager instance has been reset. State (failure counts, old keys, next key hint) preserved for next instantiation."

app/service/model/model_service.py

@@ -10,8 +10,7 @@ logger = get_model_logger()
 
 class ModelService:
     async def get_gemini_models(self, api_key: str) -> Optional[Dict[str, Any]]:
-        """使用 GeminiApiClient 获取并过滤模型列表"""
-        api_client = GeminiApiClient(base_url=settings.BASE_URL) # 实例化客户端
+        api_client = GeminiApiClient(base_url=settings.BASE_URL)
         gemini_models = await api_client.get_models(api_key)
 
         if gemini_models is None:

app/service/openai_compatiable/openai_compatiable_service.py

@@ -79,7 +79,6 @@ class OpenAICompatiableService:
             is_success = False
             error_log_msg = str(e)
             logger.error(f"Normal API call failed with error: {error_log_msg}")
-            # Try to parse status code from exception
             match = re.search(r"status code (\d+)", error_log_msg)
             if match:
                 status_code = int(match.group(1))
@@ -132,7 +131,7 @@ class OpenAICompatiableService:
                 logger.info("Streaming completed successfully")
                 is_success = True
                 status_code = 200
-                break  # 成功后退出循环
+                break
             except Exception as e:
                 retries += 1
                 is_success = False
@@ -140,14 +139,12 @@ class OpenAICompatiableService:
                 logger.warning(
                     f"Streaming API call failed with error: {error_log_msg}. Attempt {retries} of {max_retries}"
                 )
-                # Parse error code for logging
                 match = re.search(r"status code (\d+)", error_log_msg)
                 if match:
                     status_code = int(match.group(1))
                 else:
                     status_code = 500
 
-                # Log error to error log table
                 await add_error_log(
                     gemini_key=current_attempt_key,
                     model_name=model,
@@ -157,8 +154,6 @@ class OpenAICompatiableService:
                     request_msg=payload,
                 )
 
-                # Attempt to switch API Key
-                # Ensure key_manager is available (might need adjustment if not always passed)
                 if self.key_manager:
                     api_key = await self.key_manager.handle_api_failure(
                         current_attempt_key, retries
@@ -178,7 +173,6 @@ class OpenAICompatiableService:
                     logger.error(f"Max retries ({max_retries}) reached for streaming.")
                     break
             finally:
-                # Log the final outcome of the streaming request
                 end_time = time.perf_counter()
                 latency_ms = int((end_time - start_time) * 1000)
                 await add_request_log(
@@ -189,7 +183,6 @@ class OpenAICompatiableService:
                     latency_ms=latency_ms,
                     request_time=request_datetime,
                 )
-                # If the loop finished due to failure, yield error and DONE
                 if not is_success and retries >= max_retries:
                     yield f"data: {json.dumps({'error': 'Streaming failed after retries'})}\n\n"
                     yield "data: [DONE]\n\n"

app/service/request_log/request_log_service.py

@@ -6,12 +6,12 @@ from datetime import datetime, timedelta, timezone
 
 from sqlalchemy import delete
 
-from app import database
+from app.database.connection import database
 from app.config.config import settings
 from app.database.models import RequestLog
-from app.log.logger import Logger
+from app.log.logger import get_request_log_logger
 
-logger = Logger.setup_logger("request_log_service")
+logger = get_request_log_logger()
 
 
 async def delete_old_request_logs_task():

app/service/stats/stats_service.py

@@ -1,6 +1,7 @@
 # app/service/stats_service.py
 
 import datetime
+from typing import Union
 
 from sqlalchemy import and_, case, func, or_, select
 
@@ -41,7 +42,7 @@ class StatsService:
                             ),
                             1,
                         ),
-                        (RequestLog.status_code is None, 1),  # type: ignore
+                        (RequestLog.status_code is None, 1),
                         else_=0,
                     )
                 ).label("failure"),
@@ -96,7 +97,7 @@ class StatsService:
                             ),
                             1,
                         ),
-                        (RequestLog.status_code is None, 1),  # type: ignore
+                        (RequestLog.status_code is None, 1),
                         else_=0,
                     )
                 ).label("failure"),
@@ -166,25 +167,24 @@ class StatsService:
                     RequestLog.request_time.label("timestamp"),
                     RequestLog.api_key.label("key"),
                     RequestLog.model_name.label("model"),
-                    RequestLog.status_code,  # We might need to map this to 'success'/'failure' later
+                    RequestLog.status_code,
                 )
                 .where(RequestLog.request_time >= start_time)
                 .order_by(RequestLog.request_time.desc())
-            )  # Order by most recent first
+            )
 
             results = await database.fetch_all(query)
 
-            # Convert results to list of dicts and map status_code
             details = []
             for row in results:
-                status = "failure"  # 默认状态为 failure，如果 status_code 有效且在 200-299 范围内则更新为 success
-                if row["status_code"] is not None:  # 检查 status_code 是否为空
+                status = "failure"
+                if row["status_code"] is not None:
                     status = "success" if 200 <= row["status_code"] < 300 else "failure"
                 details.append(
                     {
                         "timestamp": row[
                             "timestamp"
-                        ].isoformat(),  # Use ISO format for JS compatibility
+                        ].isoformat(),
                         "key": row["key"],
                         "model": row["model"],
                         "status": status,
@@ -196,11 +196,11 @@ class StatsService:
             return details
 
         except Exception as e:
-            logger.error(f"Failed to get API call details for period '{period}': {e}")
-            # Re-raise the exception to be handled by the route
+            logger.error(
+                f"Failed to get API call details for period '{period}': {e}")
             raise
 
-    async def get_key_usage_details_last_24h(self, key: str) -> dict | None:
+    async def get_key_usage_details_last_24h(self, key: str) -> Union[dict, None]:
         """
         获取指定 API 密钥在过去 24 小时内按模型统计的调用次数。
 
@@ -220,15 +220,16 @@ class StatsService:
         try:
             query = (
                 select(
-                    RequestLog.model_name, func.count(RequestLog.id).label("call_count")
+                    RequestLog.model_name, func.count(
+                        RequestLog.id).label("call_count")
                 )
                 .where(
                     RequestLog.api_key == key,
                     RequestLog.request_time >= cutoff_time,
-                    RequestLog.model_name.isnot(None),  # Ensure model_name is not null
+                    RequestLog.model_name.isnot(None),
                 )
                 .group_by(RequestLog.model_name)
-                .order_by(func.count(RequestLog.id).desc())  # Order by count descending
+                .order_by(func.count(RequestLog.id).desc())
             )
 
             results = await database.fetch_all(query)
@@ -237,9 +238,10 @@ class StatsService:
                 logger.info(
                     f"No usage details found for key ending in ...{key[-4:]} in the last 24h."
                 )
-                return {}  # Return empty dict if no records found
+                return {}
 
-            usage_details = {row["model_name"]: row["call_count"] for row in results}
+            usage_details = {row["model_name"]: row["call_count"]
+                             for row in results}
             logger.info(
                 f"Successfully fetched usage details for key ending in ...{key[-4:]}: {usage_details}"
             )
@@ -250,6 +252,4 @@ class StatsService:
                 f"Failed to get key usage details for key ending in ...{key[-4:]}: {e}",
                 exc_info=True,
             )
-            # Depending on requirements, you might return None or raise the exception
-            # Raising allows the route handler to return a 500 error.
-            raise  # Re-raise the exception
+            raise

app/service/tts/tts_service.py

@@ -0,0 +1,95 @@
+import datetime
+import io
+import re
+import time
+import wave
+from typing import Optional
+
+from google import genai
+
+from app.config.config import settings
+from app.core.constants import TTS_VOICE_NAMES
+from app.database.services import add_error_log, add_request_log
+from app.domain.openai_models import TTSRequest
+from app.log.logger import get_openai_logger
+
+logger = get_openai_logger()
+
+
+def _create_wav_file(audio_data: bytes) -> bytes:
+    """Creates a WAV file in memory from raw audio data."""
+    with io.BytesIO() as wav_file:
+        with wave.open(wav_file, "wb") as wf:
+            wf.setnchannels(1)  # Mono
+            wf.setsampwidth(2)  # 16-bit
+            wf.setframerate(24000)  # 24kHz sample rate
+            wf.writeframes(audio_data)
+        return wav_file.getvalue()
+
+
+class TTSService:
+    async def create_tts(self, request: TTSRequest, api_key: str) -> Optional[bytes]:
+        """
+        使用 Google Gemini SDK 创建音频。
+        """
+        start_time = time.perf_counter()
+        request_datetime = datetime.datetime.now()
+        is_success = False
+        status_code = None
+        response = None
+        error_log_msg = ""
+        try:
+            client = genai.Client(api_key=api_key)
+            response =await client.aio.models.generate_content(
+                model=settings.TTS_MODEL,
+                contents=f"Speak in a {settings.TTS_SPEED} speed voice: {request.input}",
+                config={
+                    "response_modalities": ["Audio"],
+                    "speech_config": {
+                        "voice_config": {
+                            "prebuilt_voice_config": {
+                                "voice_name": request.voice if request.voice in TTS_VOICE_NAMES else settings.TTS_VOICE_NAME
+                            }
+                        }
+                    },
+                },
+            )
+            if (
+                response.candidates
+                and response.candidates[0].content.parts
+                and response.candidates[0].content.parts[0].inline_data
+            ):
+                raw_audio_data = response.candidates[0].content.parts[0].inline_data.data
+                is_success = True
+                status_code = 200
+                return _create_wav_file(raw_audio_data)
+        except Exception as e:
+            is_success = False
+            error_log_msg = f"Generic error: {e}"
+            logger.error(f"An error occurred in TTSService: {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
+        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=settings.TTS_MODEL,
+                    error_type="google-tts",
+                    error_log=error_log_msg,
+                    error_code=status_code,
+                    request_msg=request.input
+                 )
+            await add_request_log(
+                model_name=settings.TTS_MODEL,
+                api_key=api_key,
+                is_success=is_success,
+                status_code=status_code,
+                latency_ms=latency_ms,
+                request_time=request_datetime
+            )

app/service/update/update_service.py

@@ -7,11 +7,7 @@ from app.log.logger import get_update_logger
 
 logger = get_update_logger()
 
-# GitHub repository details are read from settings (defined in app/config/config.py or environment variables)
-
-# GITHUB_API_URL will be constructed inside the function to ensure settings are loaded
-
-VERSION_FILE_PATH = "VERSION" # Path relative to project root
+VERSION_FILE_PATH = "VERSION"
 
 async def check_for_updates() -> Tuple[bool, Optional[str], Optional[str]]:
     """
@@ -24,9 +20,6 @@ async def check_for_updates() -> Tuple[bool, Optional[str], Optional[str]]:
             - Optional[str]: 如果检查失败，则为错误消息，否则为 None。
     """
     try:
-        # Read current version from VERSION file
-        # Ensure the path is correct relative to the execution context or use absolute path if needed
-        # Assuming execution from project root d:/develop/pythonProjects/gemini-balance
         with open(VERSION_FILE_PATH, 'r', encoding='utf-8') as f:
             current_v = f.read().strip()
         if not current_v:
@@ -41,25 +34,22 @@ async def check_for_updates() -> Tuple[bool, Optional[str], Optional[str]]:
 
     logger.info(f"当前应用程序版本 (from {VERSION_FILE_PATH}): {current_v}")
 
-    # Check if repository details are configured in settings
     if not settings.GITHUB_REPO_OWNER or not settings.GITHUB_REPO_NAME or \
        settings.GITHUB_REPO_OWNER == "your_owner" or settings.GITHUB_REPO_NAME == "your_repo":
         logger.warning("GitHub repository owner/name not configured in settings. Skipping update check.")
         return False, None, "Update check skipped: Repository not configured in settings."
 
-    # Construct the API URL inside the function to ensure settings are loaded
     github_api_url = f"https://api.github.com/repos/{settings.GITHUB_REPO_OWNER}/{settings.GITHUB_REPO_NAME}/releases/latest"
-    logger.debug(f"Checking for updates at URL: {github_api_url}") # Log the URL for debugging
+    logger.debug(f"Checking for updates at URL: {github_api_url}")
 
     try:
         async with httpx.AsyncClient(timeout=10.0) as client:
-            # 添加 User-Agent 头，GitHub API 可能需要
             headers = {
                 "Accept": "application/vnd.github.v3+json",
-                "User-Agent": f"{settings.GITHUB_REPO_NAME}-UpdateChecker/1.0" # Use repo name from settings for User-Agent
+                "User-Agent": f"{settings.GITHUB_REPO_NAME}-UpdateChecker/1.0"
             }
-            response = await client.get(github_api_url, headers=headers) # Use the locally constructed URL
-            response.raise_for_status() # 对错误的 HTTP 状态码（4xx 或 5xx）抛出异常
+            response = await client.get(github_api_url, headers=headers)
+            response.raise_for_status()
 
             latest_release = response.json()
             latest_v_str = latest_release.get("tag_name")
@@ -68,7 +58,6 @@ async def check_for_updates() -> Tuple[bool, Optional[str], Optional[str]]:
                 logger.warning("在最新的 GitHub release 响应中找不到 'tag_name'。")
                 return False, None, "无法从 GitHub 解析最新版本。"
 
-            # 移除 tag 名称中可能存在的 'v' 前缀
             if latest_v_str.startswith('v'):
                 latest_v_str = latest_v_str[1:]
 
@@ -98,8 +87,6 @@ async def check_for_updates() -> Tuple[bool, Optional[str], Optional[str]]:
         logger.error(f"检查更新时发生网络错误: {e}")
         return False, None, "更新检查期间发生网络错误。"
     except version.InvalidVersion:
-        # Note: latest_v_str might not be defined if the error occurs before fetching it.
-        # Consider adding a check or default value for logging.
         latest_v_str_for_log = latest_v_str if 'latest_v_str' in locals() else 'N/A'
         logger.error(f"发现无效的版本格式。当前 (from {VERSION_FILE_PATH}): '{current_v}', 最新: '{latest_v_str_for_log}'")
         return False, None, "遇到无效的版本格式。"

app/static/js/config_editor.js

@@ -5,11 +5,15 @@ const ARRAY_INPUT_CLASS = "array-input";
 const MAP_ITEM_CLASS = "map-item";
 const MAP_KEY_INPUT_CLASS = "map-key-input";
 const MAP_VALUE_INPUT_CLASS = "map-value-input";
+const CUSTOM_HEADER_ITEM_CLASS = "custom-header-item";
+const CUSTOM_HEADER_KEY_INPUT_CLASS = "custom-header-key-input";
+const CUSTOM_HEADER_VALUE_INPUT_CLASS = "custom-header-value-input";
 const SAFETY_SETTING_ITEM_CLASS = "safety-setting-item";
 const SHOW_CLASS = "show"; // For modals
 const API_KEY_REGEX = /AIzaSy\S{33}/g;
 const PROXY_REGEX =
   /(?:https?|socks5):\/\/(?:[^:@\/]+(?::[^@\/]+)?@)?(?:[^:\/\s]+)(?::\d+)?/g;
+const VERTEX_API_KEY_REGEX = /AQ\.[a-zA-Z0-9_]{50}/g; // 新增 Vertex Express API Key 正则
 const MASKED_VALUE = "••••••••";
 
 // DOM Elements - Global Scope for frequently accessed elements
@@ -31,6 +35,16 @@ const bulkDeleteProxyInput = document.getElementById("bulkDeleteProxyInput");
 const resetConfirmModal = document.getElementById("resetConfirmModal");
 const configForm = document.getElementById("configForm"); // Added for frequent use
 
+// Vertex Express API Key Modal Elements
+const vertexApiKeyModal = document.getElementById("vertexApiKeyModal");
+const vertexApiKeyBulkInput = document.getElementById("vertexApiKeyBulkInput");
+const bulkDeleteVertexApiKeyModal = document.getElementById(
+  "bulkDeleteVertexApiKeyModal"
+);
+const bulkDeleteVertexApiKeyInput = document.getElementById(
+  "bulkDeleteVertexApiKeyInput"
+);
+
 // Model Helper Modal Elements
 const modelHelperModal = document.getElementById("modelHelperModal");
 const modelHelperTitleElement = document.getElementById("modelHelperTitle");
@@ -244,6 +258,8 @@ document.addEventListener("DOMContentLoaded", function () {
       bulkDeleteApiKeyModal,
       proxyModal,
       bulkDeleteProxyModal,
+      vertexApiKeyModal, // 新增
+      bulkDeleteVertexApiKeyModal, // 新增
       modelHelperModal,
     ];
     modals.forEach((modal) => {
@@ -370,8 +386,78 @@ document.addEventListener("DOMContentLoaded", function () {
     addSafetySettingBtn.addEventListener("click", () => addSafetySettingItem());
   }
 
+  // Add Custom Header button
+  const addCustomHeaderBtn = document.getElementById("addCustomHeaderBtn");
+  if (addCustomHeaderBtn) {
+    addCustomHeaderBtn.addEventListener("click", () => addCustomHeaderItem());
+  }
+
   initializeSensitiveFields(); // Initialize sensitive field handling
 
+  // Vertex Express API Key Modal Elements and Events
+  const addVertexApiKeyBtn = document.getElementById("addVertexApiKeyBtn");
+  const closeVertexApiKeyModalBtn = document.getElementById(
+    "closeVertexApiKeyModalBtn"
+  );
+  const cancelAddVertexApiKeyBtn = document.getElementById(
+    "cancelAddVertexApiKeyBtn"
+  );
+  const confirmAddVertexApiKeyBtn = document.getElementById(
+    "confirmAddVertexApiKeyBtn"
+  );
+  const bulkDeleteVertexApiKeyBtn = document.getElementById(
+    "bulkDeleteVertexApiKeyBtn"
+  );
+  const closeBulkDeleteVertexModalBtn = document.getElementById(
+    "closeBulkDeleteVertexModalBtn"
+  );
+  const cancelBulkDeleteVertexApiKeyBtn = document.getElementById(
+    "cancelBulkDeleteVertexApiKeyBtn"
+  );
+  const confirmBulkDeleteVertexApiKeyBtn = document.getElementById(
+    "confirmBulkDeleteVertexApiKeyBtn"
+  );
+
+  if (addVertexApiKeyBtn) {
+    addVertexApiKeyBtn.addEventListener("click", () => {
+      openModal(vertexApiKeyModal);
+      if (vertexApiKeyBulkInput) vertexApiKeyBulkInput.value = "";
+    });
+  }
+  if (closeVertexApiKeyModalBtn)
+    closeVertexApiKeyModalBtn.addEventListener("click", () =>
+      closeModal(vertexApiKeyModal)
+    );
+  if (cancelAddVertexApiKeyBtn)
+    cancelAddVertexApiKeyBtn.addEventListener("click", () =>
+      closeModal(vertexApiKeyModal)
+    );
+  if (confirmAddVertexApiKeyBtn)
+    confirmAddVertexApiKeyBtn.addEventListener(
+      "click",
+      handleBulkAddVertexApiKeys
+    );
+
+  if (bulkDeleteVertexApiKeyBtn) {
+    bulkDeleteVertexApiKeyBtn.addEventListener("click", () => {
+      openModal(bulkDeleteVertexApiKeyModal);
+      if (bulkDeleteVertexApiKeyInput) bulkDeleteVertexApiKeyInput.value = "";
+    });
+  }
+  if (closeBulkDeleteVertexModalBtn)
+    closeBulkDeleteVertexModalBtn.addEventListener("click", () =>
+      closeModal(bulkDeleteVertexApiKeyModal)
+    );
+  if (cancelBulkDeleteVertexApiKeyBtn)
+    cancelBulkDeleteVertexApiKeyBtn.addEventListener("click", () =>
+      closeModal(bulkDeleteVertexApiKeyModal)
+    );
+  if (confirmBulkDeleteVertexApiKeyBtn)
+    confirmBulkDeleteVertexApiKeyBtn.addEventListener(
+      "click",
+      handleBulkDeleteVertexApiKeys
+    );
+
   // Model Helper Modal Event Listeners
   if (closeModelHelperModalBtn) {
     closeModelHelperModalBtn.addEventListener("click", () =>
@@ -591,6 +677,14 @@ async function initConfig() {
     ) {
       config.FILTERED_MODELS = ["gemini-1.0-pro-latest"];
     }
+    // --- 新增：处理 VERTEX_API_KEYS 默认值 ---
+    if (!config.VERTEX_API_KEYS || !Array.isArray(config.VERTEX_API_KEYS)) {
+      config.VERTEX_API_KEYS = [];
+    }
+    // --- 新增：处理 VERTEX_EXPRESS_BASE_URL 默认值 ---
+    if (typeof config.VERTEX_EXPRESS_BASE_URL === "undefined") {
+      config.VERTEX_EXPRESS_BASE_URL = "";
+    }
     // --- 新增：处理 PROXIES 默认值 ---
     if (!config.PROXIES || !Array.isArray(config.PROXIES)) {
       config.PROXIES = []; // 默认为空数组
@@ -606,6 +700,14 @@ async function initConfig() {
     ) {
       config.THINKING_BUDGET_MAP = {}; // 默认为空对象
     }
+    // --- 新增：处理 CUSTOM_HEADERS 默认值 ---
+    if (
+      !config.CUSTOM_HEADERS ||
+      typeof config.CUSTOM_HEADERS !== "object" ||
+      config.CUSTOM_HEADERS === null
+    ) {
+      config.CUSTOM_HEADERS = {}; // 默认为空对象
+    }
     // --- 新增：处理 SAFETY_SETTINGS 默认值 ---
     if (!config.SAFETY_SETTINGS || !Array.isArray(config.SAFETY_SETTINGS)) {
       config.SAFETY_SETTINGS = []; // 默认为空数组
@@ -666,10 +768,13 @@ async function initConfig() {
       SEARCH_MODELS: ["gemini-1.5-flash-latest"],
       FILTERED_MODELS: ["gemini-1.0-pro-latest"],
       UPLOAD_PROVIDER: "smms",
-      PROXIES: [], // 添加默认值
+      PROXIES: [],
+      VERTEX_API_KEYS: [], // 确保默认值存在
+      VERTEX_EXPRESS_BASE_URL: "", // 确保默认值存在
       THINKING_MODELS: [],
       THINKING_BUDGET_MAP: {},
-      AUTO_DELETE_ERROR_LOGS_ENABLED: false, // 新增默认值
+      CUSTOM_HEADERS: {},
+      AUTO_DELETE_ERROR_LOGS_ENABLED: false,
       AUTO_DELETE_ERROR_LOGS_DAYS: 7, // 新增默认值
       AUTO_DELETE_REQUEST_LOGS_ENABLED: false, // 新增默认值
       AUTO_DELETE_REQUEST_LOGS_DAYS: 30, // 新增默认值
@@ -767,6 +872,26 @@ function populateForm(config) {
       '<div class="text-gray-500 text-sm italic">请在上方添加思考模型，预算将自动关联。</div>';
   }
 
+  // Populate CUSTOM_HEADERS
+  const customHeadersContainer = document.getElementById(
+    "CUSTOM_HEADERS_container"
+  );
+  let customHeadersAdded = false;
+  if (
+    customHeadersContainer &&
+    config.CUSTOM_HEADERS &&
+    typeof config.CUSTOM_HEADERS === "object"
+  ) {
+    for (const [key, value] of Object.entries(config.CUSTOM_HEADERS)) {
+      createAndAppendCustomHeaderItem(key, value);
+      customHeadersAdded = true;
+    }
+  }
+  if (!customHeadersAdded && customHeadersContainer) {
+    customHeadersContainer.innerHTML =
+      '<div class="text-gray-500 text-sm italic">添加自定义请求头，例如 X-Api-Key: your-key</div>';
+  }
+
   // 4. Populate other array fields (excluding THINKING_MODELS)
   for (const [key, value] of Object.entries(config)) {
     if (Array.isArray(value) && key !== "THINKING_MODELS") {
@@ -1091,32 +1216,155 @@ function handleBulkDeleteProxies() {
   bulkDeleteProxyInput.value = "";
 }
 
+/**
+ * Handles the bulk addition of Vertex Express API keys from the modal input.
+ */
+function handleBulkAddVertexApiKeys() {
+  const vertexApiKeyContainer = document.getElementById(
+    "VERTEX_API_KEYS_container"
+  );
+  if (!vertexApiKeyBulkInput || !vertexApiKeyContainer || !vertexApiKeyModal) {
+    return;
+  }
+
+  const bulkText = vertexApiKeyBulkInput.value;
+  const extractedKeys = bulkText.match(VERTEX_API_KEY_REGEX) || [];
+
+  const currentKeyInputs = vertexApiKeyContainer.querySelectorAll(
+    `.${ARRAY_INPUT_CLASS}.${SENSITIVE_INPUT_CLASS}`
+  );
+  let currentKeys = Array.from(currentKeyInputs)
+    .map((input) => {
+      return input.hasAttribute("data-real-value")
+        ? input.getAttribute("data-real-value")
+        : input.value;
+    })
+    .filter((key) => key && key.trim() !== "" && key !== MASKED_VALUE);
+
+  const combinedKeys = new Set([...currentKeys, ...extractedKeys]);
+  const uniqueKeys = Array.from(combinedKeys);
+
+  vertexApiKeyContainer.innerHTML = ""; // Clear existing items
+
+  uniqueKeys.forEach((key) => {
+    addArrayItemWithValue("VERTEX_API_KEYS", key); // VERTEX_API_KEYS are sensitive
+  });
+
+  // Ensure new sensitive inputs are masked
+  const newKeyInputs = vertexApiKeyContainer.querySelectorAll(
+    `.${ARRAY_INPUT_CLASS}.${SENSITIVE_INPUT_CLASS}`
+  );
+  newKeyInputs.forEach((input) => {
+    if (configForm && typeof initializeSensitiveFields === "function") {
+      const focusoutEvent = new Event("focusout", {
+        bubbles: true,
+        cancelable: true,
+      });
+      input.dispatchEvent(focusoutEvent);
+    }
+  });
+
+  closeModal(vertexApiKeyModal);
+  showNotification(
+    `添加/更新了 ${uniqueKeys.length} 个唯一 Vertex 密钥`,
+    "success"
+  );
+  vertexApiKeyBulkInput.value = "";
+}
+
+/**
+ * Handles the bulk deletion of Vertex Express API keys based on input from the modal.
+ */
+function handleBulkDeleteVertexApiKeys() {
+  const vertexApiKeyContainer = document.getElementById(
+    "VERTEX_API_KEYS_container"
+  );
+  if (
+    !bulkDeleteVertexApiKeyInput ||
+    !vertexApiKeyContainer ||
+    !bulkDeleteVertexApiKeyModal
+  ) {
+    return;
+  }
+
+  const bulkText = bulkDeleteVertexApiKeyInput.value;
+  if (!bulkText.trim()) {
+    showNotification("请粘贴需要删除的 Vertex Express API 密钥", "warning");
+    return;
+  }
+
+  const keysToDelete = new Set(bulkText.match(VERTEX_API_KEY_REGEX) || []);
+
+  if (keysToDelete.size === 0) {
+    showNotification(
+      "未在输入内容中提取到有效的 Vertex Express API 密钥格式",
+      "warning"
+    );
+    return;
+  }
+
+  const keyItems = vertexApiKeyContainer.querySelectorAll(
+    `.${ARRAY_ITEM_CLASS}`
+  );
+  let deleteCount = 0;
+
+  keyItems.forEach((item) => {
+    const input = item.querySelector(
+      `.${ARRAY_INPUT_CLASS}.${SENSITIVE_INPUT_CLASS}`
+    );
+    const realValue =
+      input &&
+      (input.hasAttribute("data-real-value")
+        ? input.getAttribute("data-real-value")
+        : input.value);
+    if (realValue && keysToDelete.has(realValue)) {
+      item.remove();
+      deleteCount++;
+    }
+  });
+
+  closeModal(bulkDeleteVertexApiKeyModal);
+
+  if (deleteCount > 0) {
+    showNotification(
+      `成功删除了 ${deleteCount} 个匹配的 Vertex 密钥`,
+      "success"
+    );
+  } else {
+    showNotification("列表中未找到您输入的任何 Vertex 密钥进行删除", "info");
+  }
+  bulkDeleteVertexApiKeyInput.value = "";
+}
+
 /**
  * Switches the active configuration tab.
  * @param {string} tabId - The ID of the tab to switch to.
  */
 function switchTab(tabId) {
+  console.log(`Switching to tab: ${tabId}`);
+
+  // 定义选中态和未选中态的样式
+  const activeStyle =
+    "background-color: #3b82f6 !important; color: #ffffff !important; border: 2px solid #2563eb !important; box-shadow: 0 4px 12px -2px rgba(59, 130, 246, 0.4), 0 2px 6px -1px rgba(59, 130, 246, 0.2) !important; transform: translateY(-2px) !important; font-weight: 600 !important;";
+  const inactiveStyle =
+    "background-color: #f8fafc !important; color: #64748b !important; border: 2px solid #e2e8f0 !important; box-shadow: 0 1px 3px 0 rgba(0, 0, 0, 0.1) !important; font-weight: 500 !important; transform: none !important;";
+
   // 更新标签按钮状态
   const tabButtons = document.querySelectorAll(".tab-btn");
+  console.log(`Found ${tabButtons.length} tab buttons`);
+
   tabButtons.forEach((button) => {
-    if (button.getAttribute("data-tab") === tabId) {
-      // 激活状态：主色背景，白色文字，添加阴影
-      button.classList.remove(
-        "bg-white",
-        "bg-opacity-50",
-        "text-gray-700",
-        "hover:bg-opacity-70"
-      );
-      button.classList.add("bg-primary-600", "text-white", "shadow-md");
+    const buttonTabId = button.getAttribute("data-tab");
+    if (buttonTabId === tabId) {
+      // 激活状态：直接设置内联样式
+      button.classList.add("active");
+      button.setAttribute("style", activeStyle);
+      console.log(`Applied active style to button: ${buttonTabId}`);
     } else {
-      // 非激活状态：白色背景，灰色文字，无阴影
-      button.classList.remove("bg-primary-600", "text-white", "shadow-md");
-      button.classList.add(
-        "bg-white",
-        "bg-opacity-50",
-        "text-gray-700",
-        "hover:bg-opacity-70"
-      );
+      // 非激活状态：直接设置内联样式
+      button.classList.remove("active");
+      button.setAttribute("style", inactiveStyle);
+      console.log(`Applied inactive style to button: ${buttonTabId}`);
     }
   });
 
@@ -1231,7 +1479,8 @@ function addArrayItemWithValue(key, value) {
 
   const isThinkingModel = key === "THINKING_MODELS";
   const isAllowedToken = key === "ALLOWED_TOKENS";
-  const isSensitive = key === "API_KEYS" || isAllowedToken;
+  const isVertexApiKey = key === "VERTEX_API_KEYS"; // 新增判断
+  const isSensitive = key === "API_KEYS" || isAllowedToken || isVertexApiKey; // 更新敏感判断
   const modelId = isThinkingModel ? generateUUID() : null;
 
   const arrayItem = document.createElement("div");
@@ -1242,9 +1491,9 @@ function addArrayItemWithValue(key, value) {
 
   const inputWrapper = document.createElement("div");
   inputWrapper.className =
-    "flex items-center flex-grow rounded-md focus-within:border-violet-400 focus-within:ring focus-within:ring-violet-400 focus-within:ring-opacity-50";
-  // Apply themed border directly via style, and ensure it has a border
-  inputWrapper.style.border = "1px solid rgba(120, 100, 200, 0.5)";
+    "flex items-center flex-grow rounded-md focus-within:border-blue-500 focus-within:ring focus-within:ring-blue-500 focus-within:ring-opacity-50";
+  // Apply light theme border directly via style
+  inputWrapper.style.border = "1px solid rgba(0, 0, 0, 0.12)";
   inputWrapper.style.backgroundColor = "transparent"; // Ensure wrapper is transparent
 
   const input = createArrayInput(
@@ -1326,14 +1575,14 @@ function createAndAppendBudgetMapItem(mapKey, mapValue, modelId) {
   valueInput.value = isNaN(intValue) ? 0 : intValue;
   valueInput.placeholder = "预算 (整数)";
   valueInput.className = `${MAP_VALUE_INPUT_CLASS} w-24 px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:border-primary-500 focus:ring focus:ring-primary-200 focus:ring-opacity-50`;
-  valueInput.min = 0;
-  valueInput.max = 24576;
+  valueInput.min = -1;
+  valueInput.max = 32767;
   valueInput.addEventListener("input", function () {
-    let val = this.value.replace(/[^0-9]/g, "");
+    let val = this.value.replace(/[^0-9-]/g, "");
     if (val !== "") {
       val = parseInt(val, 10);
-      if (val < 0) val = 0;
-      if (val > 24576) val = 24576;
+      if (val < -1) val = -1;
+      if (val > 32767) val = 32767;
     }
     this.value = val; // Corrected variable name
   });
@@ -1353,6 +1602,67 @@ function createAndAppendBudgetMapItem(mapKey, mapValue, modelId) {
   container.appendChild(mapItem);
 }
 
+/**
+ * Adds a new custom header item to the DOM.
+ */
+function addCustomHeaderItem() {
+  createAndAppendCustomHeaderItem("", "");
+}
+
+/**
+ * Creates and appends a DOM element for a custom header.
+ * @param {string} key - The header key.
+ * @param {string} value - The header value.
+ */
+function createAndAppendCustomHeaderItem(key, value) {
+  const container = document.getElementById("CUSTOM_HEADERS_container");
+  if (!container) {
+    console.error(
+      "Cannot add custom header: CUSTOM_HEADERS_container not found!"
+    );
+    return;
+  }
+
+  const placeholder = container.querySelector(".text-gray-500.italic");
+  if (
+    placeholder &&
+    container.children.length === 1 &&
+    container.firstChild === placeholder
+  ) {
+    container.innerHTML = "";
+  }
+
+  const headerItem = document.createElement("div");
+  headerItem.className = `${CUSTOM_HEADER_ITEM_CLASS} flex items-center mb-2 gap-2`;
+
+  const keyInput = document.createElement("input");
+  keyInput.type = "text";
+  keyInput.value = key;
+  keyInput.placeholder = "Header Name";
+  keyInput.className = `${CUSTOM_HEADER_KEY_INPUT_CLASS} flex-grow px-3 py-2 border border-gray-300 rounded-md focus:outline-none bg-gray-100 text-gray-500`;
+
+  const valueInput = document.createElement("input");
+  valueInput.type = "text";
+  valueInput.value = value;
+  valueInput.placeholder = "Header Value";
+  valueInput.className = `${CUSTOM_HEADER_VALUE_INPUT_CLASS} flex-grow px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:border-primary-500 focus:ring focus:ring-primary-200 focus:ring-opacity-50`;
+
+  const removeBtn = createRemoveButton();
+  removeBtn.addEventListener("click", () => {
+    headerItem.remove();
+    if (container.children.length === 0) {
+      container.innerHTML =
+        '<div class="text-gray-500 text-sm italic">添加自定义请求头，例如 X-Api-Key: your-key</div>';
+    }
+  });
+
+  headerItem.appendChild(keyInput);
+  headerItem.appendChild(valueInput);
+  headerItem.appendChild(removeBtn);
+
+  container.appendChild(headerItem);
+}
+
 /**
  * Collects all data from the configuration form.
  * @returns {object} An object containing all configuration data.
@@ -1429,6 +1739,26 @@ function collectFormData() {
     });
   }
 
+  const customHeadersContainer = document.getElementById(
+    "CUSTOM_HEADERS_container"
+  );
+  if (customHeadersContainer) {
+    formData["CUSTOM_HEADERS"] = {};
+    const customHeaderItems = customHeadersContainer.querySelectorAll(
+      `.${CUSTOM_HEADER_ITEM_CLASS}`
+    );
+    customHeaderItems.forEach((item) => {
+      const keyInput = item.querySelector(`.${CUSTOM_HEADER_KEY_INPUT_CLASS}`);
+      const valueInput = item.querySelector(
+        `.${CUSTOM_HEADER_VALUE_INPUT_CLASS}`
+      );
+      if (keyInput && valueInput && keyInput.value.trim() !== "") {
+        formData["CUSTOM_HEADERS"][keyInput.value.trim()] =
+          valueInput.value.trim();
+      }
+    });
+  }
+
   if (safetySettingsContainer) {
     formData["SAFETY_SETTINGS"] = [];
     const settingItems = safetySettingsContainer.querySelectorAll(
@@ -1887,7 +2217,7 @@ function renderModelsInModal() {
     modelItemElement.type = "button";
     modelItemElement.textContent = model.id;
     modelItemElement.className =
-      "block w-full text-left px-4 py-2 rounded-md hover:bg-violet-700 focus:bg-violet-700 focus:outline-none transition-colors text-gray-200";
+      "block w-full text-left px-4 py-2 rounded-md hover:bg-blue-100 focus:bg-blue-100 focus:outline-none transition-colors text-gray-700 hover:text-gray-800";
     // Add any other classes for styling, e.g., from existing modals or array items
 
     modelItemElement.addEventListener("click", () =>

app/static/js/keys_status.js

@@ -817,58 +817,11 @@ function toggleSection(header, sectionId) {
   }
 }
 
-// 筛选有效密钥（根据失败次数阈值）并更新批量操作状态
+// filterValidKeys 函数已被 filterAndSearchValidKeys 替代，此函数保留为空或可移除
 function filterValidKeys() {
-  const thresholdInput = document.getElementById("failCountThreshold");
-  const validKeysList = document.getElementById("validKeys"); // Get the UL element
-  if (!validKeysList) return; // Exit if the list doesn't exist
-
-  const validKeyItems = validKeysList.querySelectorAll("li[data-key]"); // Select li elements within the list
-  // 读取阈值，如果输入无效或为空，则默认为0（不过滤）
-  const threshold = parseInt(thresholdInput.value, 10);
-  const filterThreshold = isNaN(threshold) || threshold < 0 ? 0 : threshold;
-  let hasVisibleItems = false;
-
-  validKeyItems.forEach((item) => {
-    // 确保只处理包含 data-fail-count 的 li 元素
-    if (item.dataset.failCount !== undefined) {
-      const failCount = parseInt(item.dataset.failCount, 10);
-      // 如果失败次数大于等于阈值，则显示，否则隐藏
-      if (failCount >= filterThreshold) {
-        item.style.display = "flex"; // 使用 flex 因为 li 现在是 flex 容器
-        hasVisibleItems = true;
-      } else {
-        item.style.display = "none"; // 隐藏
-        // 如果隐藏了一个项，取消其选中状态
-        const checkbox = item.querySelector(".key-checkbox");
-        if (checkbox && checkbox.checked) {
-          checkbox.checked = false;
-        }
-      }
-    }
-  });
-
-  // 更新有效密钥的批量操作状态和全选复选框
-  updateBatchActions("valid");
-
-  // 处理"暂无有效密钥"消息
-  const noMatchMsgId = "no-valid-keys-msg";
-  let noMatchMsg = validKeysList.querySelector(`#${noMatchMsgId}`);
-  const initialKeyCount = validKeysList.querySelectorAll("li[data-key]").length; // 获取初始密钥数量
-
-  if (!hasVisibleItems && initialKeyCount > 0) {
-    // 仅当初始有密钥但现在都不可见时显示
-    if (!noMatchMsg) {
-      noMatchMsg = document.createElement("li");
-      noMatchMsg.id = noMatchMsgId;
-      noMatchMsg.className = "text-center text-gray-500 py-4 col-span-full";
-      noMatchMsg.textContent = "没有符合条件的有效密钥";
-      validKeysList.appendChild(noMatchMsg);
-    }
-    noMatchMsg.style.display = "";
-  } else if (noMatchMsg) {
-    noMatchMsg.style.display = "none";
-  }
+  // This function is now handled by filterAndSearchValidKeys
+  // Kept for now to avoid breaking any potential legacy calls, but should be removed later.
+  filterAndSearchValidKeys();
 }
 
 // --- Initialization Helper Functions ---

app/templates/auth.html

@@ -6,13 +6,14 @@
 <style>
     /* auth.html specific styles */
     .auth-glass-card { /* Renamed to avoid conflict if base.html has .glass-card */
-        background: rgba(255, 255, 255, 0.85); /* Increased opacity */
+        background: rgba(255, 255, 255, 0.95); /* High opacity white for light theme */
         backdrop-filter: blur(20px);
         -webkit-backdrop-filter: blur(20px);
-        border: 1px solid rgba(255, 255, 255, 0.2);
+        border: 1px solid rgba(0, 0, 0, 0.08);
+        box-shadow: 0 10px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
     }
     .auth-bg-gradient { /* Renamed to avoid conflict if base.html has .bg-gradient */
-         background: linear-gradient(135deg, #4F46E5 0%, #7C3AED 50%, #EC4899 100%);
+         background: #f8fafc; /* Light gray background for auth page */
     }
     /* .input-icon class removed, using direct Tailwind classes now */
     /* Keep button ripple effect if needed, or remove if base provides similar */
@@ -49,7 +50,7 @@
             </div>
         </div>
         
-        <h2 class="text-3xl font-extrabold text-center text-transparent bg-clip-text bg-gradient-to-r from-primary-600 to-primary-700 mb-8 animate-slide-down">
+        <h2 class="text-3xl font-extrabold text-center text-gray-800 mb-8 animate-slide-down">
              <img src="/static/icons/logo.png" alt="Gemini Balance Logo" class="h-9 inline-block align-middle mr-2">
              Gemini Balance
         </h2>
@@ -67,9 +68,9 @@
                 >
             </div>
             
-            <button 
-                type="submit" 
-                class="w-full py-4 rounded-xl bg-gradient-to-r from-primary-600 to-primary-700 text-white font-semibold transition duration-300 transform hover:-translate-y-1 hover:shadow-lg"
+            <button
+                type="submit"
+                class="w-full py-4 rounded-xl bg-blue-600 hover:bg-blue-700 text-white font-semibold transition duration-300 transform hover:-translate-y-1 hover:shadow-lg"
             >
                 登录
             </button>

app/templates/base.html

@@ -94,13 +94,14 @@
     </script>
     <style>
       .glass-card {
-          background: rgba(255, 255, 255, 0.85); /* Slightly increased opacity for better readability */
+          background: rgba(255, 255, 255, 0.95); /* High opacity white for light theme */
           backdrop-filter: blur(16px);
           -webkit-backdrop-filter: blur(16px);
-          border: 1px solid rgba(255, 255, 255, 0.18); /* Subtle border */
+          border: 1px solid rgba(0, 0, 0, 0.08); /* Light gray border */
+          box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
       }
       .bg-gradient {
-          background: linear-gradient(135deg, #4F46E5 0%, #7C3AED 50%, #EC4899 100%);
+          background: #ffffff; /* Clean white background */
       }
       /* Scrollbar styling */
       ::-webkit-scrollbar {
@@ -112,11 +113,11 @@
           border-radius: 10px;
       }
       ::-webkit-scrollbar-thumb {
-          background: rgba(79, 70, 229, 0.4); /* primary-600 with opacity */
+          background: rgba(107, 114, 128, 0.6); /* gray-500 for light theme */
           border-radius: 10px;
       }
       ::-webkit-scrollbar-thumb:hover {
-          background: rgba(79, 70, 229, 0.6); /* primary-600 with more opacity */
+          background: rgba(75, 85, 99, 0.8); /* gray-600 for light theme */
       }
       /* Basic modal styles */
       .modal {
@@ -135,6 +136,161 @@
           align-items: center;
           justify-content: center;
       }
+
+      /* Global modal content styling for light theme consistency */
+      .modal .w-full[style*="background-color: rgba(70, 50, 150"],
+      .modal .w-full[style*="background-color: rgba(80, 60, 160"] {
+          background-color: rgba(255, 255, 255, 0.98) !important;
+          color: #374151 !important; /* gray-700 */
+          border: 1px solid rgba(0, 0, 0, 0.08) !important;
+          box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04) !important;
+      }
+
+      /* Global modal text color fixes */
+      .modal .text-gray-100, .modal h2.text-gray-100, .modal h3.text-gray-100 {
+          color: #1f2937 !important; /* gray-800 */
+          font-weight: 600 !important;
+      }
+
+      .modal .text-gray-200, .modal .text-gray-300 {
+          color: #6b7280 !important; /* gray-500 */
+      }
+
+      .modal .text-gray-300:hover {
+          color: #374151 !important; /* gray-700 */
+      }
+
+      /* Global modal button styling */
+      .modal .bg-violet-600, .modal button.bg-violet-600 {
+          background-color: #3b82f6 !important; /* blue-500 - light blue */
+          color: #ffffff !important;
+      }
+
+      .modal .bg-violet-600:hover, .modal button.bg-violet-600:hover {
+          background-color: #2563eb !important; /* blue-600 - darker light blue */
+      }
+
+      /* Global modal blue button styling */
+      .modal .bg-blue-500, .modal button.bg-blue-500,
+      .modal .bg-blue-600, .modal button.bg-blue-600,
+      .modal .bg-blue-700, .modal button.bg-blue-700 {
+          background-color: #3b82f6 !important; /* blue-500 - light blue */
+          color: #ffffff !important;
+      }
+
+      .modal .bg-blue-500:hover, .modal button.bg-blue-500:hover,
+      .modal .bg-blue-600:hover, .modal button.bg-blue-600:hover,
+      .modal .bg-blue-700:hover, .modal button.bg-blue-700:hover {
+          background-color: #2563eb !important; /* blue-600 - darker light blue */
+      }
+
+      /* Global modal red button styling */
+      .modal .bg-red-500, .modal button.bg-red-500,
+      .modal .bg-red-600, .modal button.bg-red-600,
+      .modal .bg-red-700, .modal button.bg-red-700 {
+          background-color: #f87171 !important; /* red-400 - bright light red */
+          color: #ffffff !important;
+      }
+
+      .modal .bg-red-500:hover, .modal button.bg-red-500:hover,
+      .modal .bg-red-600:hover, .modal button.bg-red-600:hover,
+      .modal .bg-red-700:hover, .modal button.bg-red-700:hover {
+          background-color: #ef4444 !important; /* red-500 - darker bright light red */
+      }
+
+      /* Global modal gray button styling */
+      .modal .bg-gray-500, .modal button.bg-gray-500,
+      .modal .bg-gray-600, .modal button.bg-gray-600,
+      .modal .bg-gray-700, .modal button.bg-gray-700 {
+          background-color: #e5e7eb !important; /* gray-200 - light gray */
+          color: #374151 !important; /* gray-700 - dark text for contrast */
+      }
+
+      .modal .bg-gray-500:hover, .modal button.bg-gray-500:hover,
+      .modal .bg-gray-600:hover, .modal button.bg-gray-600:hover,
+      .modal .bg-gray-700:hover, .modal button.bg-gray-700:hover {
+          background-color: #d1d5db !important; /* gray-300 - darker light gray */
+          color: #374151 !important; /* gray-700 - dark text for contrast */
+      }
+
+      /* Comprehensive button contrast fixes */
+      /* Ensure all dark background buttons have white text */
+      .bg-blue-500, .bg-blue-600, .bg-blue-700, .bg-blue-800, .bg-blue-900,
+      .bg-red-500, .bg-red-600, .bg-red-700, .bg-red-800, .bg-red-900,
+      .bg-green-500, .bg-green-600, .bg-green-700, .bg-green-800, .bg-green-900,
+      .bg-purple-500, .bg-purple-600, .bg-purple-700, .bg-purple-800, .bg-purple-900,
+      .bg-indigo-500, .bg-indigo-600, .bg-indigo-700, .bg-indigo-800, .bg-indigo-900,
+      .bg-violet-500, .bg-violet-600, .bg-violet-700, .bg-violet-800, .bg-violet-900,
+      .bg-sky-500, .bg-sky-600, .bg-sky-700, .bg-sky-800, .bg-sky-900,
+      .bg-teal-500, .bg-teal-600, .bg-teal-700, .bg-teal-800, .bg-teal-900,
+      .bg-gray-700, .bg-gray-800, .bg-gray-900,
+      .bg-slate-500, .bg-slate-600, .bg-slate-700, .bg-slate-800, .bg-slate-900 {
+          color: #ffffff !important;
+      }
+
+      /* Ensure all light background buttons have dark text */
+      .bg-gray-50, .bg-gray-100, .bg-gray-200, .bg-gray-300,
+      .bg-white, .bg-transparent {
+          color: #374151 !important; /* gray-700 */
+      }
+
+      /* Fix button children text inheritance */
+      .bg-blue-500 *, .bg-blue-600 *, .bg-blue-700 *, .bg-blue-800 *, .bg-blue-900 *,
+      .bg-red-500 *, .bg-red-600 *, .bg-red-700 *, .bg-red-800 *, .bg-red-900 *,
+      .bg-green-500 *, .bg-green-600 *, .bg-green-700 *, .bg-green-800 *, .bg-green-900 *,
+      .bg-purple-500 *, .bg-purple-600 *, .bg-purple-700 *, .bg-purple-800 *, .bg-purple-900 *,
+      .bg-violet-500 *, .bg-violet-600 *, .bg-violet-700 *, .bg-violet-800 *, .bg-violet-900 *,
+      .bg-sky-500 *, .bg-sky-600 *, .bg-sky-700 *, .bg-sky-800 *, .bg-sky-900 *,
+      .bg-teal-500 *, .bg-teal-600 *, .bg-teal-700 *, .bg-teal-800 *, .bg-teal-900 *,
+      .bg-gray-700 *, .bg-gray-800 *, .bg-gray-900 *,
+      .bg-slate-500 *, .bg-slate-600 *, .bg-slate-700 *, .bg-slate-800 *, .bg-slate-900 * {
+          color: inherit !important;
+      }
+
+      /* Global form element styling for consistency */
+      select, input[type="text"], input[type="number"], input[type="search"],
+      input[type="email"], input[type="password"], input[type="datetime-local"],
+      textarea, .form-input, .form-select {
+          background-color: rgba(255, 255, 255, 0.95) !important;
+          color: #374151 !important; /* gray-700 */
+          border: 1px solid rgba(0, 0, 0, 0.12) !important;
+          border-radius: 0.375rem !important; /* rounded-md */
+      }
+
+      select:focus, input:focus, textarea:focus,
+      .form-input:focus, .form-select:focus {
+          border-color: #3b82f6 !important; /* blue-500 */
+          box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.1) !important;
+          outline: none !important;
+      }
+
+      /* Fix dropdown option styling */
+      select option {
+          background-color: rgba(255, 255, 255, 0.98) !important;
+          color: #374151 !important; /* gray-700 */
+          padding: 8px !important;
+      }
+
+      /* Fix pagination controls globally */
+      .pagination-button, .pagination a, .pagination button {
+          background-color: rgba(255, 255, 255, 0.9) !important;
+          color: #374151 !important; /* gray-700 */
+          border: 1px solid rgba(0, 0, 0, 0.08) !important;
+          transition: all 0.15s ease-in-out !important;
+      }
+
+      .pagination-button:hover, .pagination a:hover, .pagination button:hover {
+          background-color: rgba(229, 231, 235, 1) !important; /* gray-200 */
+          border-color: rgba(0, 0, 0, 0.12) !important;
+          transform: translateY(-1px) !important;
+      }
+
+      .pagination-button.active, .pagination a.active, .pagination button.active {
+          background-color: #3b82f6 !important; /* blue-500 - light blue */
+          color: #ffffff !important;
+          border-color: #2563eb !important; /* blue-600 - darker light blue */
+          font-weight: 600 !important;
+      }
       /* Loading spinner */
       .loading-spin {
           animation: spin 1s linear infinite;
@@ -151,19 +307,20 @@
           transform: translateX(-50%);
           padding: 0.75rem 1.25rem; /* px-5 py-3 */
           border-radius: 0.5rem; /* rounded-lg */
-          background-color: rgba(0, 0, 0, 0.8);
+          background-color: rgba(34, 197, 94, 0.95); /* green-500 for success */
           color: white;
           font-weight: 500; /* font-medium */
           z-index: 1000; /* Increased z-index */
           opacity: 0;
           transition: opacity 0.3s ease-in-out, transform 0.3s ease-in-out;
+          box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05);
       }
       .notification.show {
           opacity: 1;
           transform: translate(-50%, 0);
       }
       .notification.error {
-           background-color: rgba(220, 38, 38, 0.8); /* danger-600 with opacity */
+           background-color: rgba(239, 68, 68, 0.95); /* red-500 for error */
       }
       /* Scroll buttons */
       .scroll-buttons {
@@ -178,7 +335,7 @@
       .scroll-button {
           width: 2.5rem; /* w-10 */
           height: 2.5rem; /* h-10 */
-          background-color: #4f46e5; /* bg-primary-600 */
+          background-color: #3b82f6; /* blue-500 - light blue */
           color: white;
           border-radius: 9999px; /* rounded-full */
           box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06); /* shadow-md */
@@ -188,20 +345,128 @@
           transition: all 0.3s ease-in-out;
       }
       .scroll-button:hover {
-          background-color: #4338ca; /* hover:bg-primary-700 */
+          background-color: #2563eb; /* blue-600 - darker light blue */
           box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05); /* hover:shadow-lg */
       }
+
+      /* Global overrides for light theme consistency */
+      .text-gray-200, .text-gray-300, .text-gray-400 {
+          color: #6b7280 !important; /* gray-500 for better contrast */
+      }
+
+      /* Navigation and header improvements */
+      .bg-primary-600, .bg-primary-700 {
+          background-color: #3b82f6 !important; /* blue-500 - light blue */
+      }
+
+      .text-primary-600, .text-primary-700 {
+          color: #3b82f6 !important; /* blue-500 - light blue */
+      }
+
+      .border-primary-500, .focus\\:border-primary-500 {
+          border-color: #3b82f6 !important; /* blue-500 */
+      }
+
+      .ring-primary-200, .focus\\:ring-primary-200 {
+          --tw-ring-color: rgba(59, 130, 246, 0.2) !important; /* blue-500 with opacity */
+      }
+
+      /* Global purple to blue conversion */
+      .bg-violet-50, .bg-violet-100, .bg-violet-200, .bg-violet-300, .bg-violet-400, .bg-violet-500, .bg-violet-600, .bg-violet-700, .bg-violet-800, .bg-violet-900 {
+          background-color: #3b82f6 !important; /* blue-500 - light blue */
+      }
+
+      .text-violet-50, .text-violet-100, .text-violet-200, .text-violet-300, .text-violet-400, .text-violet-500, .text-violet-600, .text-violet-700, .text-violet-800, .text-violet-900 {
+          color: #3b82f6 !important; /* blue-500 - light blue */
+      }
+
+      .border-violet-50, .border-violet-100, .border-violet-200, .border-violet-300, .border-violet-400, .border-violet-500, .border-violet-600, .border-violet-700, .border-violet-800, .border-violet-900 {
+          border-color: #3b82f6 !important; /* blue-500 - light blue */
+      }
+
+      /* Global button color overrides */
+      /* Blue buttons to light blue */
+      .bg-blue-500, .bg-blue-600, .bg-blue-700, .bg-blue-800, .bg-blue-900,
+      button.bg-blue-500, button.bg-blue-600, button.bg-blue-700, button.bg-blue-800, button.bg-blue-900 {
+          background-color: #3b82f6 !important; /* blue-500 - light blue */
+      }
+
+      .bg-blue-500:hover, .bg-blue-600:hover, .bg-blue-700:hover, .bg-blue-800:hover, .bg-blue-900:hover,
+      button.bg-blue-500:hover, button.bg-blue-600:hover, button.bg-blue-700:hover, button.bg-blue-800:hover, button.bg-blue-900:hover,
+      .hover\\:bg-blue-600:hover, .hover\\:bg-blue-700:hover, .hover\\:bg-blue-800:hover {
+          background-color: #2563eb !important; /* blue-600 - darker light blue */
+      }
+
+      /* Red buttons to bright light red */
+      .bg-red-500, .bg-red-600, .bg-red-700, .bg-red-800, .bg-red-900,
+      button.bg-red-500, button.bg-red-600, button.bg-red-700, button.bg-red-800, button.bg-red-900 {
+          background-color: #f87171 !important; /* red-400 - bright light red */
+      }
+
+      .bg-red-500:hover, .bg-red-600:hover, .bg-red-700:hover, .bg-red-800:hover, .bg-red-900:hover,
+      button.bg-red-500:hover, button.bg-red-600:hover, button.bg-red-700:hover, button.bg-red-800:hover, button.bg-red-900:hover,
+      .hover\\:bg-red-600:hover, .hover\\:bg-red-700:hover, .hover\\:bg-red-800:hover {
+          background-color: #ef4444 !important; /* red-500 - darker bright light red */
+      }
+
+      /* Gray buttons to light gray */
+      .bg-gray-500, .bg-gray-600, .bg-gray-700, .bg-gray-800, .bg-gray-900,
+      button.bg-gray-500, button.bg-gray-600, button.bg-gray-700, button.bg-gray-800, button.bg-gray-900 {
+          background-color: #e5e7eb !important; /* gray-200 - light gray */
+          color: #374151 !important; /* gray-700 - dark text for contrast */
+      }
+
+      .bg-gray-500:hover, .bg-gray-600:hover, .bg-gray-700:hover, .bg-gray-800:hover, .bg-gray-900:hover,
+      button.bg-gray-500:hover, button.bg-gray-600:hover, button.bg-gray-700:hover, button.bg-gray-800:hover, button.bg-gray-900:hover,
+      .hover\\:bg-gray-600:hover, .hover\\:bg-gray-700:hover, .hover\\:bg-gray-800:hover {
+          background-color: #d1d5db !important; /* gray-300 - darker light gray */
+          color: #374151 !important; /* gray-700 - dark text for contrast */
+      }
+
+      /* Ensure all text has proper contrast in light theme */
+      .text-white {
+          color: #374151 !important; /* gray-700 for better contrast on light backgrounds */
+      }
+
+      /* Fix dark button text - ensure white text on dark backgrounds */
+      .bg-blue-500, .bg-blue-600, .bg-blue-700, .bg-blue-800, .bg-blue-900,
+      .bg-red-500, .bg-red-600, .bg-red-700, .bg-red-800, .bg-red-900,
+      .bg-green-500, .bg-green-600, .bg-green-700, .bg-green-800, .bg-green-900,
+      .bg-purple-500, .bg-purple-600, .bg-purple-700, .bg-purple-800, .bg-purple-900,
+      .bg-indigo-500, .bg-indigo-600, .bg-indigo-700, .bg-indigo-800, .bg-indigo-900,
+      .bg-gray-700, .bg-gray-800, .bg-gray-900,
+      .bg-sky-500, .bg-sky-600, .bg-sky-700, .bg-sky-800, .bg-sky-900 {
+          color: #ffffff !important;
+      }
+
+      /* Ensure buttons with dark backgrounds have white text */
+      button.bg-blue-500, button.bg-blue-600, button.bg-blue-700,
+      button.bg-red-500, button.bg-red-600, button.bg-red-700,
+      button.bg-green-500, button.bg-green-600, button.bg-green-700,
+      button.bg-sky-500, button.bg-sky-600, button.bg-sky-700,
+      .btn-primary, .btn-danger, .btn-success, .btn-info {
+          color: #ffffff !important;
+      }
+
+      /* Override any nested text color rules for dark buttons */
+      .bg-blue-500 *, .bg-blue-600 *, .bg-blue-700 *,
+      .bg-red-500 *, .bg-red-600 *, .bg-red-700 *,
+      .bg-green-500 *, .bg-green-600 *, .bg-green-700 *,
+      .bg-sky-500 *, .bg-sky-600 *, .bg-sky-700 * {
+          color: inherit !important;
+      }
+
       {% block head_extra_styles %}
       {% endblock %}
     </style>
     {% block head_extra_scripts %}{% endblock %}
   </head>
-  <body class="bg-gradient min-h-screen text-gray-800 pt-6 pb-16">
+  <body class="bg-white min-h-screen text-gray-900 pt-6 pb-16">
     {% block content %}{% endblock %}
 
     <!-- 底部版权 -->
     <div
-      class="fixed bottom-0 left-0 w-full py-3 bg-white bg-opacity-80 backdrop-blur-md text-sm text-gray-800 border-t border-gray-200 flex flex-col items-center space-y-1"
+      class="fixed bottom-0 left-0 w-full py-3 bg-white bg-opacity-95 backdrop-blur-md text-sm text-gray-800 border-t border-gray-200 flex flex-col items-center space-y-1"
     >
       <!-- 第一行 -->
       <div class="flex items-center justify-center space-x-2">

app/utils/helpers.py

@@ -7,15 +7,12 @@ import base64
 import requests
 from typing import Dict, Any, List, Optional, Tuple
 from pathlib import Path
-import logging # Import logging
+import logging
 
 from app.core.constants import DATA_URL_PATTERN, IMAGE_URL_PATTERN, VALID_IMAGE_RATIOS
 
-# Define logger for helper functions if needed, or use specific loggers
-helper_logger = logging.getLogger("app.utils") # Or use a more specific logger if available
+helper_logger = logging.getLogger("app.utils")
 
-# Define project root and version file path here for get_current_version
-# Assuming this file is at app/utils/helpers.py
 PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
 VERSION_FILE_PATH = PROJECT_ROOT / "VERSION"
 
@@ -159,9 +156,8 @@ def is_valid_api_key(key: str) -> bool:
 
 def get_current_version(default_version: str = "0.0.0") -> str:
     """Reads the current version from the VERSION file."""
-    version_file = VERSION_FILE_PATH # Use Path object defined above
+    version_file = VERSION_FILE_PATH
     try:
-        # Use Path object's open method
         with version_file.open('r', encoding='utf-8') as f:
             version = f.read().strip()
         if not version:

app/utils/uploader.py

@@ -261,18 +261,20 @@ class PicGoUploader(ImageUploader):
 
 class CloudFlareImgBedUploader(ImageUploader):
     """CloudFlare图床上传器"""
-    
-    def __init__(self, auth_code: str, api_url: str):
+
+    def __init__(self, auth_code: str, api_url: str, upload_folder: str = ""):
         """
         初始化CloudFlare图床上传器
         
         Args:
             auth_code: 认证码
             api_url: 上传API地址
+            upload_folder: 上传文件夹路径（可选）
         """
         self.auth_code = auth_code
         self.api_url = api_url
-        
+        self.upload_folder = upload_folder
+
     def upload(self, file: bytes, filename: str) -> UploadResponse:
         """
         上传图片到CloudFlare图床
@@ -288,12 +290,16 @@ class CloudFlareImgBedUploader(ImageUploader):
             UploadError: 上传失败时抛出异常
         """
         try:
-            # 准备请求URL（添加认证码参数，如果存在）
+            # 准备请求URL参数
+            params = []
+            if self.upload_folder:
+                params.append(f"uploadFolder={self.upload_folder}")
             if self.auth_code:
-                request_url = f"{self.api_url}?authCode={self.auth_code}&uploadNameType=origin"
-            else:
-                request_url = f"{self.api_url}?uploadNameType=origin"
-            
+                params.append(f"authCode={self.auth_code}")
+            params.append("uploadNameType=origin")
+
+            request_url = f"{self.api_url}?{'&'.join(params)}"
+
             # 准备文件数据
             files = {
                 "file": (filename, file)
@@ -388,6 +394,7 @@ class ImageUploaderFactory:
         elif provider == "cloudflare_imgbed":
             return CloudFlareImgBedUploader(
                 credentials["auth_code"],
-                credentials["base_url"]
+                credentials["base_url"],
+                credentials.get("upload_folder", ""),
             )
         raise ValueError(f"Unknown provider: {provider}")

files/dataocean.svg

@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 19.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 603 103" style="enable-background:new 0 0 603 103;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#0080FF;}
+	.st1{fill-rule:evenodd;clip-rule:evenodd;fill:#0080FF;}
+</style>
+<g id="XMLID_2369_">
+	<g id="XMLID_2638_">
+		<g id="XMLID_2639_">
+			<g>
+				<g id="XMLID_44_">
+					<g id="XMLID_48_">
+						<path id="XMLID_49_" class="st0" d="M52.1,102.1l0-19.6c20.8,0,36.8-20.6,28.9-42.4C78,32,71.6,25.5,63.5,22.6
+							c-21.8-7.9-42.4,8.1-42.4,28.9c0,0,0,0,0,0l-19.6,0c0-33.1,32-58.9,66.7-48.1c15.2,4.7,27.2,16.8,31.9,31.9
+							C110.9,70.1,85.2,102.1,52.1,102.1z"/>
+					</g>
+					<polygon id="XMLID_47_" class="st1" points="52.1,82.5 32.6,82.5 32.6,63 32.6,63 52.1,63 52.1,63 					"/>
+					<polygon id="XMLID_46_" class="st1" points="32.6,97.5 17.6,97.5 17.6,97.5 17.6,82.5 32.6,82.5 32.6,97.5 					"/>
+					<polygon id="XMLID_45_" class="st1" points="17.6,82.5 5,82.5 5,82.5 5,70 5,70 17.6,70 17.6,70 					"/>
+				</g>
+			</g>
+		</g>
+	</g>
+	<g id="XMLID_2370_">
+		<path id="XMLID_2635_" class="st0" d="M181.5,30.2c-5.8-4-13-6.1-21.4-6.1h-18.3v58.1h18.3c8.4,0,15.6-2.1,21.4-6.4
+			c3.2-2.2,5.7-5.4,7.4-9.3c1.7-3.9,2.6-8.5,2.6-13.7c0-5.1-0.9-9.7-2.6-13.6C187.2,35.4,184.7,32.3,181.5,30.2z M152.5,34h5.8
+			c6.4,0,11.7,1.3,15.7,3.7c4.4,2.7,6.7,7.8,6.7,15.1c0,7.6-2.3,12.9-6.7,15.8h0c-3.8,2.5-9.1,3.8-15.6,3.8h-5.8V34z"/>
+		<path id="XMLID_2634_" class="st0" d="M204.3,23.4c-1.8,0-3.3,0.6-4.5,1.8c-1.2,1.2-1.9,2.7-1.9,4.4c0,1.8,0.6,3.3,1.9,4.5
+			c1.2,1.2,2.7,1.9,4.5,1.9c1.8,0,3.3-0.6,4.5-1.9c1.2-1.2,1.9-2.8,1.9-4.5c0-1.8-0.6-3.3-1.9-4.4C207.6,24,206,23.4,204.3,23.4z"/>
+		<rect id="XMLID_2564_" x="199" y="41.3" class="st0" width="10.3" height="41"/>
+		<path id="XMLID_2561_" class="st0" d="M246.8,44.7c-3.1-2.8-6.6-4.4-10.3-4.4c-5.7,0-10.4,2-14.1,5.8c-3.7,3.8-5.5,8.8-5.5,14.7
+			c0,5.8,1.8,10.7,5.5,14.7c3.7,3.8,8.4,5.8,14.1,5.8c4,0,7.4-1.1,10.2-3.3V79c0,3.4-0.9,6-2.7,7.9c-1.8,1.8-4.3,2.7-7.4,2.7
+			c-4.8,0-7.7-1.9-11.4-6.8l-7,6.7l0.2,0.3c1.5,2.1,3.8,4.2,6.9,6.2c3.1,2,6.9,3,11.5,3c6.1,0,11.1-1.9,14.7-5.6
+			c3.7-3.7,5.5-8.7,5.5-14.9V41.3h-10.1V44.7z M244.1,68.9c-1.8,2-4.1,3-7.1,3c-3,0-5.3-1-7-3c-1.8-2-2.7-4.7-2.7-8
+			c0-3.3,0.9-6.1,2.7-8.1c1.8-2,4.1-3.1,7-3.1c3,0,5.3,1,7.1,3.1c1.8,2,2.7,4.8,2.7,8.1C246.8,64.2,245.8,66.9,244.1,68.9z"/>
+		<rect id="XMLID_2560_" x="265.7" y="41.3" class="st0" width="10.3" height="41"/>
+		<path id="XMLID_2552_" class="st0" d="M271,23.4c-1.8,0-3.3,0.6-4.5,1.8c-1.2,1.2-1.9,2.7-1.9,4.4c0,1.8,0.6,3.3,1.9,4.5
+			c1.2,1.2,2.7,1.9,4.5,1.9c1.8,0,3.3-0.6,4.5-1.9c1.2-1.2,1.9-2.8,1.9-4.5c0-1.8-0.6-3.3-1.9-4.4C274.3,24,272.7,23.4,271,23.4z"/>
+		<path id="XMLID_2509_" class="st0" d="M298.6,30.3h-10.1v11.1h-5.9v9.4h5.9v17c0,5.3,1.1,9.1,3.2,11.3c2.1,2.2,5.8,3.3,11.1,3.3
+			c1.7,0,3.4-0.1,5-0.2l0.5,0v-9.4l-3.5,0.2c-2.5,0-4.1-0.4-4.9-1.3c-0.8-0.9-1.2-2.7-1.2-5.4V50.7h9.6v-9.4h-9.6V30.3z"/>
+		<rect id="XMLID_2508_" x="356.5" y="24.1" class="st0" width="10.3" height="58.1"/>
+		<path id="XMLID_2470_" class="st0" d="M470.9,67.6c-1.8,2.1-3.7,3.9-5.2,4.8v0c-1.4,0.9-3.2,1.4-5.3,1.4c-3,0-5.5-1.1-7.5-3.4
+			c-2-2.3-3-5.2-3-8.7s1-6.4,2.9-8.6c2-2.3,4.4-3.4,7.4-3.4c3.3,0,6.8,2.1,9.8,5.6l6.8-6.5l0,0c-4.4-5.8-10.1-8.5-16.9-8.5
+			c-5.7,0-10.6,2.1-14.6,6.1c-4,4-6,9.2-6,15.3s2,11.2,6,15.3c4,4.1,8.9,6.1,14.6,6.1c7.5,0,13.5-3.2,17.5-9.1L470.9,67.6z"/>
+		<path id="XMLID_2460_" class="st0" d="M513.2,47c-1.5-2-3.5-3.7-5.9-4.9c-2.5-1.2-5.3-1.8-8.5-1.8c-5.8,0-10.5,2.1-14,6.3
+			c-3.4,4.2-5.2,9.3-5.2,15.4c0,6.2,1.9,11.3,5.7,15.3c3.7,3.9,8.8,5.9,14.9,5.9c6.9,0,12.7-2.8,16.9-8.4l0.2-0.3l-6.7-6.5l0,0
+			c-0.6,0.8-1.5,1.6-2.3,2.4c-1,1-2,1.7-3,2.2c-1.5,0.8-3.3,1.1-5.2,1.1c-2.9,0-5.2-0.8-7-2.5c-1.7-1.5-2.7-3.6-2.9-6.2h27.3
+			l0.1-3.8c0-2.7-0.4-5.2-1.1-7.6C515.8,51.3,514.7,49.1,513.2,47z M490.7,56.7c0.5-2,1.4-3.6,2.7-4.9c1.4-1.4,3.2-2.1,5.4-2.1
+			c2.5,0,4.4,0.7,5.7,2.1c1.2,1.3,1.9,2.9,2.1,4.8H490.7z"/>
+		<path id="XMLID_2456_" class="st0" d="M552.8,44.4L552.8,44.4c-3.1-2.7-7.4-4-12.8-4c-3.4,0-6.6,0.8-9.5,2.2
+			c-2.7,1.4-5.3,3.6-7,6.6l0.1,0.1l6.6,6.3c2.7-4.3,5.7-5.8,9.7-5.8c2.2,0,3.9,0.6,5.3,1.7c1.4,1.1,2,2.6,2,4.4v2
+			c-2.6-0.8-5.1-1.2-7.6-1.2c-5.1,0-9.3,1.2-12.4,3.6c-3.1,2.4-4.7,5.9-4.7,10.2c0,3.8,1.3,7,4,9.3c2.7,2.2,6,3.4,9.9,3.4
+			c3.9,0,7.6-1.6,10.9-4.3v3.4h10.1V55.9C557.6,51,556,47.1,552.8,44.4z M534.5,66.6c1.2-0.8,2.8-1.2,4.9-1.2c2.5,0,5.1,0.5,7.8,1.5
+			v4C545,73,542,74,538.3,74c-1.8,0-3.2-0.4-4.1-1.2c-0.9-0.8-1.4-1.7-1.4-3C532.8,68.5,533.4,67.4,534.5,66.6z"/>
+		<path id="XMLID_2454_" class="st0" d="M597.2,45.2c-2.9-3.2-6.9-4.8-12-4.8c-4.1,0-7.4,1.2-9.9,3.5v-2.5h-10.1v41h10.3V59.7
+			c0-3.1,0.7-5.6,2.2-7.3c1.5-1.8,3.4-2.6,6.1-2.6c2.3,0,4.1,0.8,5.4,2.3c1.3,1.6,2,3.7,2,6.4v23.7h10.3V58.5
+			C601.5,52.9,600.1,48.4,597.2,45.2z"/>
+		<path id="XMLID_2450_" class="st0" d="M343.6,44.4L343.6,44.4c-3.1-2.7-7.4-4-12.8-4c-3.4,0-6.6,0.8-9.5,2.2
+			c-2.7,1.4-5.3,3.6-7,6.6l0.1,0.1l6.6,6.3c2.7-4.3,5.7-5.8,9.7-5.8c2.2,0,3.9,0.6,5.3,1.7c1.4,1.1,2,2.6,2,4.4v2
+			c-2.6-0.8-5.1-1.2-7.6-1.2c-5.1,0-9.3,1.2-12.4,3.6c-3.1,2.4-4.7,5.9-4.7,10.2c0,3.8,1.3,7,4,9.3c2.7,2.2,6,3.4,9.9,3.4
+			c3.9,0,7.6-1.6,10.9-4.3v3.4h10.1V55.9C348.3,51,346.7,47.1,343.6,44.4z M325.3,66.6c1.2-0.8,2.8-1.2,4.9-1.2
+			c2.5,0,5.1,0.5,7.8,1.5v4c-2.2,2.1-5.2,3.1-8.9,3.1c-1.8,0-3.2-0.4-4.1-1.2c-0.9-0.8-1.4-1.7-1.4-3
+			C323.6,68.5,324.1,67.4,325.3,66.6z"/>
+		<path id="XMLID_2371_" class="st0" d="M404.2,83.1c-16.5,0-30-13.4-30-30s13.4-30,30-30c16.5,0,30,13.4,30,30
+			S420.7,83.1,404.2,83.1z M404.2,33.8c-10.7,0-19.4,8.7-19.4,19.4s8.7,19.4,19.4,19.4c10.7,0,19.4-8.7,19.4-19.4
+			S414.9,33.8,404.2,33.8z"/>
+	</g>
+</g>
+</svg>

requirements.txt

@@ -9,8 +9,7 @@ uvicorn
 google-genai
 jinja2
 python-multipart
-cryptography # 支持 MySQL 8+ caching_sha2_password 验证
-# 数据库相关依赖
+cryptography
 pymysql
 sqlalchemy
 aiomysql