添加对gemini原生格式TTS的支持

app/domain/gemini_models.py

@@ -41,6 +41,9 @@ class GenerationConfig(BaseModel):
     responseLogprobs: Optional[bool] = None
     logprobs: Optional[int] = None
     thinkingConfig: Optional[Dict[str, Any]] = None
+    # TTS相关字段
+    responseModalities: Optional[List[str]] = None
+    speechConfig: Optional[Dict[str, Any]] = None
 
 
 class SystemInstruction(BaseModel):

app/router/gemini_routes.py

@@ -9,7 +9,7 @@ from app.core.security import SecurityService
 from app.domain.gemini_models import GeminiContent, GeminiRequest, ResetSelectedKeysRequest, VerifySelectedKeysRequest
 from app.service.chat.gemini_chat_service import GeminiChatService
 from app.service.key.key_manager import KeyManager, get_key_manager_instance
-from app.service.tts.multi_speaker.tts_routes import get_tts_chat_service
+from app.service.tts.native.tts_routes import get_tts_chat_service
 from app.service.model.model_service import ModelService
 from app.handler.retry_handler import RetryHandler
 from app.handler.error_handler import handle_route_errors
@@ -113,34 +113,38 @@ async def generate_content(
         logger.info(f"Handling Gemini content generation request for model: {model_name}")
         logger.debug(f"Request: \n{request.model_dump_json(indent=2)}")
 
-        # 检测是否为多人TTS请求
+        # 检测是否为原生Gemini TTS请求
-        is_multi_speaker_tts = False
+        is_native_tts = False
         if "tts" in model_name.lower():
             try:
                 raw_body = await raw_request.body()
                 raw_data = json.loads(raw_body.decode('utf-8'))
 
-                # 检查是否包含多人语音配置
+                # 检查是否包含原生TTS配置（responseModalities和speechConfig）
-                speech_config = raw_data.get("generationConfig", {}).get("speechConfig", {})
+                generation_config = raw_data.get("generationConfig", {})
-                if "multiSpeakerVoiceConfig" in speech_config:
+                response_modalities = generation_config.get("responseModalities", [])
-                    is_multi_speaker_tts = True
+                speech_config = generation_config.get("speechConfig", {})
-                    logger.info("Detected multi-speaker TTS request")
+
-                    logger.info(f"Raw request data for multi-speaker TTS: {json.dumps(raw_data, indent=2, ensure_ascii=False)}")
+                # 如果包含AUDIO模态和语音配置，则认为是原生TTS请求
+                if "AUDIO" in response_modalities and speech_config:
+                    is_native_tts = True
+                    logger.info("Detected native Gemini TTS request")
+                    logger.info(f"Raw request data for native TTS: {json.dumps(raw_data, indent=2, ensure_ascii=False)}")
 
                     # 将TTS字段添加到请求对象中
                     setattr(request, '_raw_tts_data', raw_data)
             except Exception as e:
-                logger.warning(f"Failed to parse request for multi-speaker TTS detection: {e}")
+                logger.warning(f"Failed to parse request for native TTS detection: {e}")
 
         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")
 
-        # 只有多人TTS请求才使用增强服务
+        # 所有原生TTS请求都使用TTS增强服务
-        if is_multi_speaker_tts:
+        if is_native_tts:
             try:
-                logger.info("Using multi-speaker TTS enhanced service")
+                logger.info("Using native TTS enhanced service")
                 tts_service = await get_tts_chat_service(key_manager)
                 response = await tts_service.generate_content(
                     model=model_name,
@@ -149,9 +153,9 @@ async def generate_content(
                 )
                 return response
             except Exception as e:
-                logger.warning(f"Multi-speaker TTS processing failed, falling back to standard service: {e}")
+                logger.warning(f"Native TTS processing failed, falling back to standard service: {e}")
 
-        # 使用标准服务处理所有其他请求（包括单人TTS）
+        # 使用标准服务处理所有其他请求（非TTS）
         response = await chat_service.generate_content(
             model=model_name,
             request=request,

app/service/chat/gemini_chat_service.py

@@ -140,14 +140,29 @@ def _build_payload(model: str, request: GeminiRequest) -> Dict[str, Any]:
         if request.generationConfig.maxOutputTokens is None:
             # 如果未指定最大输出长度，则不传递该字段，解决截断的问题
             request_dict["generationConfig"].pop("maxOutputTokens")
-    
+
-    payload = {
+    # 检查是否为TTS模型
-        "contents": _filter_empty_parts(request_dict.get("contents", [])),
+    is_tts_model = "tts" in model.lower()
-        "tools": _build_tools(model, request_dict),
+
-        "safetySettings": _get_safety_settings(model),
+    if is_tts_model:
-        "generationConfig": request_dict.get("generationConfig"),
+        # TTS模型使用简化的payload，不包含tools和safetySettings
-        "systemInstruction": request_dict.get("systemInstruction"),
+        payload = {
-    }
+            "contents": _filter_empty_parts(request_dict.get("contents", [])),
+            "generationConfig": request_dict.get("generationConfig"),
+        }
+
+        # 只在有systemInstruction时才添加
+        if request_dict.get("systemInstruction"):
+            payload["systemInstruction"] = request_dict.get("systemInstruction")
+    else:
+        # 非TTS模型使用完整的payload
+        payload = {
+            "contents": _filter_empty_parts(request_dict.get("contents", [])),
+            "tools": _build_tools(model, request_dict),
+            "safetySettings": _get_safety_settings(model),
+            "generationConfig": request_dict.get("generationConfig"),
+            "systemInstruction": request_dict.get("systemInstruction"),
+        }
 
     # 确保 generationConfig 不为 None
     if payload["generationConfig"] is None:

app/service/tts/native/README.md

@@ -1,14 +1,14 @@
-# 多人对话TTS功能
+# 原生Gemini TTS功能
 
-这个模块为Gemini Balance项目添加了多人语音TTS（Text-to-Speech）功能，采用智能检测和继承模式设计，保持与原始代码的完全兼容性。
+这个模块为Gemini Balance项目添加了原生Gemini TTS（Text-to-Speech）功能，支持单人和多人语音合成，采用智能检测和继承模式设计，保持与原始代码的完全兼容性。
 
 ## 🎯 设计原则
 
-- **智能检测**：只有包含 `multiSpeakerVoiceConfig` 的请求才启用多人TTS
+- **智能检测**：自动检测所有原生Gemini TTS格式的请求（包含responseModalities和speechConfig）
 - **继承而非修改**：所有扩展都继承自原始类，不修改源码
-- **完全兼容**：原有TTS功能（单人TTS、OpenAI兼容TTS）完全不受影响
+- **完全兼容**：原有TTS功能（OpenAI兼容TTS）完全不受影响
 - **动态模型选择**：支持用户在请求URL中指定不同的TTS模型
-- **自动回退**：多人TTS处理失败时自动回退到标准服务
+- **自动回退**：原生TTS处理失败时自动回退到标准服务
 - **完整日志记录**：包含请求日志、错误日志和性能监控
 - **易于维护**：更新原始代码时不会产生冲突
 
@@ -17,7 +17,7 @@
 ```
 app/service/tts/
 ├── tts_service.py           # 原有的OpenAI兼容TTS服务
-└── multi_speaker/           # 多人对话TTS扩展
+└── native/                  # 原生Gemini TTS扩展
     ├── __init__.py          # 模块初始化
     ├── README.md            # 使用说明（本文件）
     ├── tts_models.py        # TTS数据模型（继承自原始模型）
@@ -26,15 +26,15 @@ app/service/tts/
     └── tts_routes.py        # TTS路由扩展和依赖注入
 ```
 
-## 🚀 多人TTS功能
+## 🚀 原生Gemini TTS功能
 
 ### 智能检测机制（当前实现）
 
-多人TTS功能通过智能检测自动启用，无需任何配置：
+原生Gemini TTS功能通过智能检测自动启用，无需任何配置：
 
 1. **自动启用**：
 ```bash
-# 直接启动服务，多人TTS功能自动可用
+# 直接启动服务，原生TTS功能自动可用
 python -m uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload
 ```
 
@@ -46,17 +46,22 @@ python -m uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload
 ### 工作原理
 
 系统会智能检测请求内容：
-- **多人TTS请求**：包含 `multiSpeakerVoiceConfig` → 使用多人TTS增强服务
+- **原生TTS请求**：包含 `responseModalities: ["AUDIO"]` 和 `speechConfig` → 使用TTS增强服务
-- **单人TTS请求**：不包含 `multiSpeakerVoiceConfig` → 使用原有Gemini TTS服务
+  - **单人TTS**：包含 `voiceConfig.prebuiltVoiceConfig`
+  - **多人TTS**：包含 `multiSpeakerVoiceConfig`
 - **普通请求**：非TTS模型 → 使用原有Gemini聊天服务
 
 ```python
 # app/router/gemini_routes.py 中的智能检测逻辑
 if "tts" in model_name.lower():
-    # 检查是否包含多人语音配置
+    # 检查是否包含原生TTS配置
-    speech_config = raw_data.get("generationConfig", {}).get("speechConfig", {})
+    generation_config = raw_data.get("generationConfig", {})
-    if "multiSpeakerVoiceConfig" in speech_config:
+    response_modalities = generation_config.get("responseModalities", [])
-        # 使用多人TTS增强服务
+    speech_config = generation_config.get("speechConfig", {})
+
+    # 如果包含AUDIO模态和语音配置，则认为是原生TTS请求
+    if "AUDIO" in response_modalities and speech_config:
+        # 使用TTS增强服务
         tts_service = await get_tts_chat_service(key_manager)
         return await tts_service.generate_content(...)
     # 否则使用原有服务
@@ -64,9 +69,36 @@ if "tts" in model_name.lower():
 
 ## 📝 使用示例
 
+### 单人语音TTS请求（自动启用增强服务）
+
+包含 `voiceConfig.prebuiltVoiceConfig` 的请求会自动使用TTS增强服务：
+
+```bash
+curl -X POST "https://your-domain.com/v1beta/models/gemini-2.5-flash-preview-tts:generateContent" \
+  -H "Content-Type: application/json" \
+  -H "x-goog-api-key: your-token" \
+  -d '{
+    "contents": [{
+      "parts": [{
+        "text": "Hello, this is a single speaker test."
+      }]
+    }],
+    "generationConfig": {
+      "responseModalities": ["AUDIO"],
+      "speechConfig": {
+        "voiceConfig": {
+          "prebuiltVoiceConfig": {
+            "voiceName": "Kore"
+          }
+        }
+      }
+    }
+  }'
+```
+
 ### 多人语音TTS请求（自动启用增强服务）
 
-包含 `multiSpeakerVoiceConfig` 的请求会自动使用多人TTS增强服务：
+包含 `multiSpeakerVoiceConfig` 的请求会自动使用TTS增强服务：
 
 ```bash
 curl -X POST "https://your-domain.com/v1beta/models/gemini-2.5-flash-preview-tts:generateContent" \
@@ -183,17 +215,16 @@ TTSGenerationConfig
 1. **请求接收**：系统接收到API请求
 2. **智能检测**：
    - 检查模型名称是否包含 "tts"
-   - 如果是TTS模型，解析请求体检查是否包含 `multiSpeakerVoiceConfig`
+   - 如果是TTS模型，解析请求体检查是否包含 `responseModalities: ["AUDIO"]` 和 `speechConfig`
 3. **服务选择**：
-   - **多人TTS请求**：使用 `TTSGeminiChatService` 增强服务
+   - **原生TTS请求**：使用 `TTSGeminiChatService` 增强服务
-   - **单人TTS请求**：使用原有 `GeminiChatService`
    - **普通请求**：使用原有 `GeminiChatService`
 4. **请求处理**：
-   - **多人TTS**：使用 `_handle_tts_request()` 特殊处理
+   - **原生TTS**：使用 `_handle_tts_request()` 特殊处理
    - **其他请求**：使用标准 `generate_content()` 方法
 5. **字段处理**：从原始HTTP请求体提取TTS字段（`responseModalities`, `speechConfig`）
 6. **API调用**：构建优化的payload并调用Gemini API
-7. **自动回退**：如果多人TTS处理失败，自动回退到标准服务
+7. **自动回退**：如果原生TTS处理失败，自动回退到标准服务
 8. **响应处理**：
    - **TTS响应**：检测音频数据，直接返回原始响应
    - **普通响应**：使用标准处理方法
@@ -203,11 +234,13 @@ TTSGenerationConfig
 
 ### ✅ 已实现功能
 
-- **智能多人语音合成**：支持 `multiSpeakerVoiceConfig` 配置
+- **智能原生TTS支持**：支持单人和多人语音合成
-- **智能检测机制**：只有多人TTS请求才启用增强服务
+  - **单人TTS**：支持 `voiceConfig.prebuiltVoiceConfig` 配置
+  - **多人TTS**：支持 `multiSpeakerVoiceConfig` 配置
+- **智能检测机制**：自动检测所有原生Gemini TTS格式的请求
 - **动态模型选择**：支持用户在URL中指定不同TTS模型
-- **完全向后兼容**：原有TTS功能（单人TTS、OpenAI兼容TTS）完全不受影响
+- **完全向后兼容**：原有TTS功能（OpenAI兼容TTS）完全不受影响
-- **自动回退机制**：多人TTS处理失败时自动使用标准服务
+- **自动回退机制**：原生TTS处理失败时自动使用标准服务
 - **完整日志记录**：请求日志、错误日志、性能监控
 - **API配额管理**：自动重试和密钥轮换
 - **零配置启用**：无需环境变量或配置文件修改
@@ -215,6 +248,23 @@ TTSGenerationConfig
 
 ### 🎵 支持的语音配置
 
+#### 单人语音配置
+
+```json
+{
+  "responseModalities": ["AUDIO"],
+  "speechConfig": {
+    "voiceConfig": {
+      "prebuiltVoiceConfig": {
+        "voiceName": "Kore|Puck|其他预设语音"
+      }
+    }
+  }
+}
+```
+
+#### 多人语音配置
+
 ```json
 {
   "responseModalities": ["AUDIO"],
@@ -278,7 +328,7 @@ tail -f logs/app.log
 | TTS类型 | 路径 | 模型选择 | 语音配置 | 使用场景 | 我们的影响 |
 |---------|------|----------|----------|----------|------------|
 | **OpenAI兼容TTS** | `/v1/audio/speech` | 固定配置文件 | 单人语音 | OpenAI API兼容 | ✅ 无影响 |
-| **Gemini单人TTS** | `/v1beta/models/{model}:generateContent` | 用户指定 | 单人语音 | 原生Gemini TTS | ✅ 无影响 |
+| **Gemini单人TTS** | `/v1beta/models/{model}:generateContent` | 用户指定 | 单人语音 | 原生Gemini TTS | ✅ 我们的增强 |
 | **Gemini多人TTS** | `/v1beta/models/{model}:generateContent` | 用户指定 | 多人语音 | 对话场景 | ✅ 我们的增强 |
 
 ### 智能路由机制
@@ -289,11 +339,11 @@ flowchart TD
     B -->|/v1/audio/speech| C[OpenAI兼容TTS服务]
     B -->|/v1beta/models/{model}:generateContent| D{模型名包含'tts'?}
     D -->|否| E[标准Gemini聊天服务]
-    D -->|是| F{包含multiSpeakerVoiceConfig?}
+    D -->|是| F{包含responseModalities和speechConfig?}
-    F -->|否| G[原有Gemini TTS服务]
+    F -->|否| G[标准Gemini聊天服务]
-    F -->|是| H[多人TTS增强服务]
+    F -->|是| H[原生TTS增强服务]
     H --> I{处理成功?}
-    I -->|是| J[返回多人TTS响应]
+    I -->|是| J[返回原生TTS响应]
     I -->|否| K[自动回退到标准服务]
     C --> L[完成]
     E --> L
@@ -304,14 +354,14 @@ flowchart TD
 
 ## 🎉 成功案例
 
-基于智能检测的多人TTS解决方案已经成功实现：
+基于智能检测的原生Gemini TTS解决方案已经成功实现：
 
 - ✅ **零配置启用**：无需任何环境变量或配置修改
-- ✅ **智能检测**：只有多人TTS请求才使用增强服务
+- ✅ **智能检测**：自动检测所有原生Gemini TTS格式的请求
 - ✅ **完全向后兼容**：所有原有TTS功能零影响
 - ✅ **动态模型选择**：支持用户指定不同TTS模型
 - ✅ **自动回退机制**：处理失败时自动使用标准服务
-- ✅ **多人语音合成**：支持复杂的对话场景
+- ✅ **单人和多人语音合成**：支持所有原生Gemini TTS场景
 - ✅ **完整日志记录**：可在管理界面查看所有请求
 - ✅ **错误处理完善**：API配额和重试机制
 - ✅ **易于维护**：更新原始代码无冲突

app/service/tts/native/__init__.py

@@ -1,6 +1,6 @@
 """
-多人对话TTS功能模块
+原生Gemini TTS功能模块
-Multi-speaker TTS functionality for conversation scenarios
+Native Gemini TTS functionality for both single and multi-speaker scenarios
 """
 
 from .tts_chat_service import TTSGeminiChatService

app/service/tts/native/tts_chat_service.py

@@ -1,13 +1,13 @@
 """
-TTS聊天服务扩展
+原生Gemini TTS聊天服务扩展
-继承自原始聊天服务，添加TTS支持，保持向后兼容
+继承自原始聊天服务，添加原生Gemini TTS支持（单人和多人），保持向后兼容
 """
 
 import time
 import datetime
 from typing import Any, Dict, Optional
 from app.service.chat.gemini_chat_service import GeminiChatService
-from app.service.tts.multi_speaker.tts_response_handler import TTSResponseHandler
+from app.service.tts.native.tts_response_handler import TTSResponseHandler
 from app.domain.gemini_models import GeminiRequest
 from app.log.logger import get_gemini_logger
 from app.database.services import add_request_log, add_error_log

app/service/tts/native/tts_config.py

@@ -6,7 +6,7 @@ TTS扩展配置
 import os
 from typing import Union
 from app.service.chat.gemini_chat_service import GeminiChatService
-from app.service.tts.multi_speaker.tts_chat_service import TTSGeminiChatService
+from app.service.tts.native.tts_chat_service import TTSGeminiChatService
 
 
 class TTSConfig:

app/service/tts/native/tts_models.py

@@ -1,6 +1,6 @@
 """
-TTS扩展数据模型
+原生Gemini TTS扩展数据模型
-继承自原始模型，添加TTS相关字段，保持向后兼容
+继承自原始模型，添加原生Gemini TTS相关字段，保持向后兼容
 """
 
 from typing import Any, Dict, List, Optional

app/service/tts/native/tts_response_handler.py

@@ -1,6 +1,6 @@
 """
-TTS响应处理器扩展
+原生Gemini TTS响应处理器扩展
-继承自原始响应处理器，添加TTS支持，保持向后兼容
+继承自原始响应处理器，添加原生Gemini TTS支持，保持向后兼容
 """
 
 from typing import Any, Dict, Optional

app/service/tts/native/tts_routes.py

@@ -1,13 +1,13 @@
 """
 TTS路由扩展
-提供多人TTS增强服务
+提供原生Gemini TTS增强服务，支持单人和多人语音
 """
 
 from fastapi import Depends
 
 from app.config.config import settings
 from app.service.key.key_manager import KeyManager, get_key_manager_instance
-from app.service.tts.multi_speaker.tts_chat_service import TTSGeminiChatService
+from app.service.tts.native.tts_chat_service import TTSGeminiChatService
 
 
 async def get_key_manager():
@@ -17,7 +17,7 @@ async def get_key_manager():
 
 async def get_tts_chat_service(key_manager: KeyManager = Depends(get_key_manager)) -> TTSGeminiChatService:
     """
-    获取多人TTS增强聊天服务实例
+    获取原生Gemini TTS增强聊天服务实例，支持单人和多人语音
     """
     return TTSGeminiChatService(settings.BASE_URL, key_manager)