Merge pull request #275 from cindyxu1030/feat/sonilo-sfx

feat(sfx): 新增 Sonilo AI 音效模式（可选，默认关闭）

.gitignore

@@ -1,6 +1,8 @@
 .DS_Store
 /config.toml
 /storage/
+.venv/
+venv/
 /.idea/
 /app/services/__pycache__
 /app/__pycache__/
@@ -51,6 +53,9 @@ tests/*
 !tests/test_script_service_documentary_unittest.py
 !tests/test_generate_narration_script_documentary_unittest.py
 !tests/test_generate_script_docu_unittest.py
+!tests/test_streamlit_widget_session_state.py
+!tests/test_sonilo_bgm_unittest.py
+!tests/test_sonilo_sfx_unittest.py
 
 docs/reddit-community
 docs/wechat-0.8

.python-version

@@ -0,0 +1 @@
+3.12

Dockerfile

@@ -15,16 +15,18 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     pkg-config \
     && rm -rf /var/lib/apt/lists/*
 
-# 升级 pip 并创建虚拟环境
+# 安装 uv 并创建构建虚拟环境
-RUN python -m pip install --upgrade pip setuptools wheel && \
+RUN python -m pip install --upgrade pip setuptools wheel uv
-    python -m venv /opt/venv
 
-# 激活虚拟环境
+# 让 uv 将项目依赖同步到运行阶段复用的虚拟环境
-ENV PATH="/opt/venv/bin:$PATH"
+ENV UV_PROJECT_ENVIRONMENT="/opt/venv" \
+    UV_LINK_MODE=copy \
+    UV_COMPILE_BYTECODE=1 \
+    PATH="/opt/venv/bin:$PATH"
 
-# 复制 requirements.txt 并使用镜像安装 Python 依赖
+# 复制 uv 项目文件并安装 Python 依赖
-COPY requirements.txt .
+COPY pyproject.toml uv.lock ./
-RUN pip install --no-cache-dir -i https://pypi.tuna.tsinghua.edu.cn/simple -r requirements.txt
+RUN uv sync --frozen --no-dev
 
 # 运行阶段
 FROM python:3.12-slim-bookworm

LICENSE

@@ -1,18 +1,16 @@
-Modified MIT License - Non-Commercial Use Only
+MIT License
 
 Copyright (c) 2024 linyq
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to use,
+of this software and associated documentation files (the "Software"), to deal
-copy, modify, merge, publish, and distribute the Software, subject to the
+in the Software without restriction, including without limitation the rights
-following conditions:
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-1. The Software is provided **for personal, educational, or research purposes only**.
+The above copyright notice and this permission notice shall be included in all
-2. Commercial use of the Software, including but not limited to incorporating
+copies or substantial portions of the Software.
-   it into paid products, services, or platforms, is strictly prohibited
-   without prior written permission from the copyright holder.
-3. The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
@@ -21,25 +19,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-
-
--------------------------------------------------------
-中文说明（仅供参考，以英文条款为准）：
-
-修改后的 MIT 协议 - 仅限非商业用途
-
-版权所有 (c) 2024 linyq
-
-任何人均可免费获取本软件及相关文档的副本，并享有以下权利：
-- 使用、复制、修改、合并、发布、分发本软件；
-
-但必须遵守以下条件：
-1. 本软件仅限用于 **个人、学习或科研用途**。
-2. 严禁任何商业用途，包括但不限于将本软件用于收费产品、商业服务、
-   SaaS 平台或任何形式的营利行为。若需商业授权，必须事先获得版权所有者书面许可。
-3. 上述版权声明及许可条款必须包含在本软件的所有副本或重要部分中。
-
-免责声明：
-本软件按“现状”提供，不附带任何明示或暗示的担保，包括但不限于
-适销性、特定用途适用性和非侵权担保。作者或版权持有人在任何情况下
-不对因使用本软件或与本软件有关的行为造成的任何损害承担责任。

README-en.md

@@ -91,6 +91,17 @@ Below is a screenshot of this person's x (Twitter) homepage
 - Windows 10/11 or MacOS 11.0 or above
 - [Python 3.12+](https://www.python.org/downloads/)
 
+## Local Run 🚀
+
+```bash
+git clone https://github.com/linyqh/NarratoAI.git
+cd NarratoAI
+
+uv sync
+cp config.example.toml config.toml
+uv run streamlit run webui.py --server.maxUploadSize=2048
+```
+
 ## Feedback & Suggestions 📢
 
 👏 1. You can submit [issue](https://github.com/linyqh/NarratoAI/issues) or [pull request](https://github.com/linyqh/NarratoAI/pulls)

README.md

@@ -3,22 +3,12 @@
 <h3 align="center">一站式 AI 影视解说+自动化剪辑工具🎬🎞️ </h3>
 
 <p align="center">
-  📖 <a href="README-en.md">English</a> | 简体中文 | <a href="https://www.narratoai.cn">☁️ <b>云端版入口 (NarratoAI.cn)</b></a>
+  📖 <a href="README-en.md">English</a> | 简体中文 | <a href="https://www.narratoai.co">☁️ <b>云端版入口 (NarratoAI.co)</b></a>
 </p>
 
-<div align="center">
 <br>
 
-> **🔥 隆重推荐：VibeCut 的新范式 —— [speclip.com](https://speclip.com)**
+NarratoAI 是一款自动化影视解说工具，基于 LLM 实现文案撰写、自动化视频剪辑、配音和字幕生成的一站式流程，助力高效内容创作。支持本地部署开源版及 [云端托管版](https://www.narratoai.co)。
->
-> **一个真正意义上的视频剪辑 Agent！像聊天(vibecoding)一样剪辑视频。**
-> **[👉 点击立即免费下载 Speclip](https://speclip.com)**
-
-</div>
-
-<br>
-
-NarratoAI 是一款自动化影视解说工具，基于 LLM 实现文案撰写、自动化视频剪辑、配音和字幕生成的一站式流程，助力高效内容创作。支持本地部署开源版及 [云端托管版](https://www.narratoai.cn)。
 
 <br>
 
@@ -37,10 +27,10 @@ NarratoAI 是一款自动化影视解说工具，基于 LLM 实现文案撰写
 ![](docs/index-zh.png)
 
 </div>
-## 许可证
-本项目仅供学习和研究使用，不得商用。如需商业授权，请联系作者。
 
 ## 最新资讯
+- 2026.07.16 发布新版本 0.8.6，新增可选的 **Sonilo AI 配乐**，支持 Apple Silicon 的 **IndexTTS-1.5 MLX**，更新 IndexTTS-2 MLX API 适配，并补充 OmniVoice 部署包下载入口
+- 2026.07.13 发布新版本 0.8.5，完善 `uv` + Python 3.12 本地运行流程，新增一键清理系统缓存和自定义 OpenAI 兼容 Base URL 的格式校验与 API Key 风险提示，并优化短脚本解析、字幕预览和音频设置的跨平台兼容性
 - 2026.07.02 发布新版本 0.8.4，升级豆包语音 TTS 新版 API Key 配置并保留旧版凭据兼容
 - 2026.06.10 发布新版本 0.8.1，**大版本更新**，优化多个核心流程
 - 2026.04.27 发布新版本 0.7.9，新增 **Fun-ASR一键转录字幕**
@@ -58,6 +48,17 @@ NarratoAI 是一款自动化影视解说工具，基于 LLM 实现文案撰写
 - 2024.11.10 发布官方文档，详情参见 [官方文档](https://p9mf6rjv3c.feishu.cn/wiki/SP8swLLZki5WRWkhuFvc2CyInDg)
 - 2024.11.10 发布新版本 v0.3.5；优化视频剪辑流程，
 
+### v0.8.6 更新亮点
+
+| 功能 | 说明 |
+| --- | --- |
+| Sonilo AI 配乐 | 在 WebUI 的背景音乐来源中选择“AI 生成配乐（Sonilo）”，即可根据画面内容和剪辑节奏生成配乐。该功能默认关闭，需自行配置 [Sonilo](https://sonilo.com) API Key；当前支持最长 6 分钟的视频，生成失败时会自动回退到随机背景音乐，不中断成片任务。 |
+| IndexTTS-1.5 macOS | 新增面向 Apple Silicon 的 MLX 本地语音克隆引擎，可上传或从资源目录选择参考音频。[下载部署包](https://cutagent.online/resources/indextts15-mlx-macos) |
+| IndexTTS-2 MLX | 更新 MLX Pack API 适配，支持参考音频、情感控制、随机种子和更完整的生成参数。[macOS 部署包](https://cutagent.online/resources/indextts2-full-macos)（Windows 版本待更新） |
+| OmniVoice | 补充 OmniVoice-Pack 部署包下载入口；该引擎支持自动音色、指令音色和参考音频克隆。[macOS 部署包](https://cutagent.online/resources/omnivoice-macos) / [Windows 部署包](https://cutagent.online/resources/omnivoice-windows) |
+
+> 使用 Sonilo AI 配乐时，合成完成且尚未添加背景音乐的视频会上传至 Sonilo API。请在启用前确认视频内容符合相关服务条款与隐私要求；生成音乐的授权和商用范围以 Sonilo 最新条款为准。
+
 ## 重磅福利 🎉
 
 > 即日起全面支持硅基流动！注册即享2000万免费Token（价值16元平台配额），剪辑10分钟视频仅需0.1元！  
@@ -76,6 +77,8 @@ NarratoAI 是一款自动化影视解说工具，基于 LLM 实现文案撰写
 
 ## ⚠️谨防被骗 📢
 
+> 🔎 名称辨析：[**NarratoAI 与 NarratorAI 项目关系、开源范围与使用方式说明**](https://github.com/linyqh/NarratoAI/wiki/NarratoAI-%E4%B8%8E-NarratorAI-%E9%A1%B9%E7%9B%AE%E5%85%B3%E7%B3%BB%E5%92%8C%E5%8C%BA%E5%88%AB)
+
 _**1. NarratoAI 是一款完全免费的软件，近期在社交媒体(抖音,B站等)上发现，有人将 NarratoAI 改名后售卖，下面是部分截图，请大家务必提高警惕，切勿上当受骗**_
 
 ---
@@ -104,11 +107,38 @@ _**1. NarratoAI 是一款完全免费的软件，近期在社交媒体(抖音,B
 - [ ] 主角人脸匹配
 - [ ] 支持根据口播，文案，视频素材自动匹配
 - [X] 支持更多 TTS 引擎
+- [X] 支持可选的 AI 自动配乐
 - [ ] ...
 
 ## 快速启动 🚀
 
-### 方式一：macos Docker 部署（macos 推荐）
+### 方式一：整合包（推荐）
+> 下载地址：[https://cutagent.online/](https://cutagent.online/)
+
+请下载与系统对应的整合包并完整解压；不要单独移动其中的 `NarratoAI`、`runtime` 或 `tools` 等目录。Windows 使用 x64 版本；macOS 使用 Apple Silicon（M1/M2/M3/M4）arm64 版本。
+
+#### Windows
+
+1. 打开解压后的 `NarratoAI-windows-x64` 目录。
+2. 先双击 `update-windows.bat` 更新项目，等待窗口提示更新完成。
+3. 再双击 `start.bat` 启动应用，并保持启动窗口打开。
+4. 在浏览器访问 `http://127.0.0.1:8501`。
+
+#### macOS（Apple Silicon）
+
+1. 打开解压后的 `NarratoAI-macos-arm64` 目录。
+2. 若系统阻止打开脚本，请在“终端”中执行（将路径替换为实际解压位置）：
+
+   ```bash
+   xattr -cr "/path/to/NarratoAI-macos-arm64"
+   chmod +x "/path/to/NarratoAI-macos-arm64/"*.command
+   ```
+
+3. 先双击 `update-macos.command` 更新项目，等待更新完成。
+4. 再双击 `start-macos.command` 启动应用，并保持终端窗口打开。
+5. 在浏览器访问 `http://127.0.0.1:8501`。
+
+### 方式二：macos Docker 部署（macos 推荐）
 ```bash
 # 1. 克隆项目
 git clone https://github.com/linyqh/NarratoAI.git
@@ -120,17 +150,14 @@ docker compose up -d
 # 3. 访问应用
 # 浏览器打开 http://localhost:8501
 ```
-### 方式二：整合包（Windows 推荐）
-> *关注微信公众号 **NarratoAI 助手** 右下角菜单栏获取下载链接*
-
 ### 方式三：本地运行
 ```bash
 # 1. 克隆项目
 git clone https://github.com/linyqh/NarratoAI.git
 cd NarratoAI
 
-# 2. 安装依赖
+# 2. 使用 uv 安装依赖
-pip install -r requirements.txt
+uv sync
 
 # 3. 复制配置文件
 cp config.example.toml config.toml
@@ -138,7 +165,7 @@ cp config.example.toml config.toml
 # 4. 编辑 config.toml，配置你的 API 密钥
 
 # 5. 启动应用
-streamlit run webui.py --server.maxUploadSize=2048
+uv run streamlit run webui.py --server.maxUploadSize=2048
 
 # 6. 访问应用
 # 浏览器打开 http://localhost:8501

app/config/config.py

@@ -10,14 +10,33 @@ root_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__fi
 config_file = f"{root_dir}/config.toml"
 version_file = f"{root_dir}/project_version"
 INDEXTTS_ENGINE = "indextts"
-INDEXTTS_DISPLAY_NAME = "IndexTTS-1.5"
+INDEXTTS_DISPLAY_NAME = "IndexTTS-1.5-windows"
+INDEXTTS_MACOS_ENGINE = "indextts_macos"
+INDEXTTS_MACOS_DISPLAY_NAME = "IndexTTS-1.5-macOS"
 INDEXTTS2_ENGINE = "indextts2"
 INDEXTTS2_DISPLAY_NAME = "IndexTTS-2"
 OMNIVOICE_ENGINE = "omnivoice"
 OMNIVOICE_DISPLAY_NAME = "OmniVoice"
+VOXCPM_ENGINE = "voxcpm_05b"
+VOXCPM_DISPLAY_NAME = "VoxCPM-0.5B"
+VOXCPM2_ENGINE = "voxcpm_2b"
+VOXCPM2_DISPLAY_NAME = "VoxCPM-2B"
 INDEXTTS_VOICE_PREFIX = f"{INDEXTTS_ENGINE}:"
+INDEXTTS_MACOS_VOICE_PREFIX = f"{INDEXTTS_MACOS_ENGINE}:"
 INDEXTTS2_VOICE_PREFIX = f"{INDEXTTS2_ENGINE}:"
 OMNIVOICE_VOICE_PREFIX = f"{OMNIVOICE_ENGINE}:"
+VOXCPM_VOICE_PREFIX = f"{VOXCPM_ENGINE}:"
+VOXCPM2_VOICE_PREFIX = f"{VOXCPM2_ENGINE}:"
+INDEXTTS2_EMOTION_VECTOR_FIELDS = (
+    ("happy", "vec_happy"),
+    ("angry", "vec_angry"),
+    ("sad", "vec_sad"),
+    ("afraid", "vec_afraid"),
+    ("disgusted", "vec_disgusted"),
+    ("melancholic", "vec_melancholic"),
+    ("surprised", "vec_surprised"),
+    ("calm", "vec_calm"),
+)
 
 
 def normalize_tts_engine_name(tts_engine: str) -> str:
@@ -28,6 +47,32 @@ def normalize_indextts_voice_prefix(voice_name: str) -> str:
     return voice_name
 
 
+def get_indextts2_pack_emotion(indextts2_config) -> str:
+    """Return the MLX Pack emotion string for current or legacy settings."""
+    if not isinstance(indextts2_config, dict):
+        return ""
+
+    configured_emotion = str(indextts2_config.get("emotion", "")).strip()
+    if configured_emotion:
+        return configured_emotion
+
+    emotion_mode = indextts2_config.get("emotion_mode", "speaker")
+    if emotion_mode == "text":
+        return str(indextts2_config.get("emotion_text", "")).strip()
+    if emotion_mode != "vector":
+        return ""
+
+    weights = []
+    for emotion, field in INDEXTTS2_EMOTION_VECTOR_FIELDS:
+        try:
+            weight = float(indextts2_config.get(field, 0.0))
+        except (TypeError, ValueError):
+            continue
+        if weight > 0:
+            weights.append(f"{emotion}:{weight:g}")
+    return ",".join(weights)
+
+
 def _is_legacy_indextts2_config(indextts2_config) -> bool:
     if not isinstance(indextts2_config, dict):
         return False
@@ -133,8 +178,11 @@ def save_config():
         _cfg["tts_qwen"] = tts_qwen
         _cfg["fun_asr"] = fun_asr
         _cfg["indextts"] = indextts
+        _cfg["indextts_macos"] = indextts_macos
         _cfg["indextts2"] = indextts2
         _cfg["omnivoice"] = omnivoice
+        _cfg["voxcpm_05b"] = voxcpm_05b
+        _cfg["voxcpm_2b"] = voxcpm_2b
         _cfg["doubaotts"] = doubaotts
         f.write(toml.dumps(_cfg))
 
@@ -151,8 +199,11 @@ frames = _cfg.get("frames", {})
 tts_qwen = _cfg.get("tts_qwen", {})
 fun_asr = _cfg.get("fun_asr", {})
 indextts = _cfg.get("indextts", {})
+indextts_macos = _cfg.get("indextts_macos", {})
 indextts2 = _cfg.get("indextts2", {})
 omnivoice = _cfg.get("omnivoice", {})
+voxcpm_05b = _cfg.get("voxcpm_05b", {})
+voxcpm_2b = _cfg.get("voxcpm_2b", {})
 doubaotts = _cfg.get("doubaotts", {})
 
 hostname = socket.gethostname()

app/config/defaults.py

@@ -10,6 +10,7 @@ DEFAULT_VISION_OPENAI_MODEL_NAME = "Qwen/Qwen3.5-122B-A10B"
 
 DEFAULT_TEXT_LLM_PROVIDER = DEFAULT_OPENAI_COMPATIBLE_PROVIDER
 DEFAULT_TEXT_OPENAI_MODEL_NAME = "Pro/zai-org/GLM-5"
+DEFAULT_TEXT_OPENAI_FAST_MODEL_NAME = ""
 
 DEFAULT_LLM_GENERATION_CONFIG = {
     "temperature": 1.0,
@@ -33,6 +34,7 @@ DEFAULT_LLM_APP_CONFIG = {
     "vision_openai_base_url": DEFAULT_OPENAI_COMPATIBLE_BASE_URL,
     "text_llm_provider": DEFAULT_TEXT_LLM_PROVIDER,
     "text_openai_model_name": DEFAULT_TEXT_OPENAI_MODEL_NAME,
+    "text_openai_fast_model_name": DEFAULT_TEXT_OPENAI_FAST_MODEL_NAME,
     "text_openai_api_key": "",
     "text_openai_base_url": DEFAULT_OPENAI_COMPATIBLE_BASE_URL,
     "tavily_api_key": "",
@@ -69,6 +71,31 @@ def normalize_openai_compatible_model_name(
     return normalized
 
 
+def resolve_text_model_name(
+    app_config: dict,
+    provider: str = DEFAULT_OPENAI_COMPATIBLE_PROVIDER,
+    *,
+    prefer_fast: bool = False,
+) -> str:
+    """Resolve the configured reasoning or fast text model with legacy fallback."""
+    provider = (provider or DEFAULT_OPENAI_COMPATIBLE_PROVIDER).strip().lower()
+    reasoning_model = normalize_openai_compatible_model_name(
+        str(app_config.get(f"text_{provider}_model_name") or ""),
+        provider=provider,
+    )
+    if not reasoning_model and provider == DEFAULT_OPENAI_COMPATIBLE_PROVIDER:
+        reasoning_model = DEFAULT_TEXT_OPENAI_MODEL_NAME
+
+    if not prefer_fast:
+        return reasoning_model
+
+    fast_model = normalize_openai_compatible_model_name(
+        str(app_config.get(f"text_{provider}_fast_model_name") or ""),
+        provider=provider,
+    )
+    return fast_model or reasoning_model
+
+
 def get_openai_compatible_ui_values(
     full_model_name: str,
     default_model: str,

app/config/test_config_bootstrap_unittest.py

@@ -1,6 +1,7 @@
 import tempfile
 import unittest
 from pathlib import Path
+from unittest.mock import patch
 
 try:
     import tomllib
@@ -11,10 +12,35 @@ from app.config import config as cfg
 from app.config.defaults import (
     get_openai_compatible_ui_values,
     normalize_openai_compatible_model_name,
+    resolve_text_model_name,
 )
 
 
 class ConfigBootstrapDefaultsTests(unittest.TestCase):
+    def test_save_config_keeps_macos_tts_settings_independent(self):
+        macos_settings = {
+            "api_url": "http://127.0.0.1:7866",
+            "reference_audio": "/tmp/macos-reference.wav",
+            "speed": 1.1,
+        }
+        windows_settings = {
+            "api_url": "http://127.0.0.1:8081/tts",
+            "reference_audio": "/tmp/windows-reference.wav",
+        }
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            config_path = Path(tmp_dir) / "config.toml"
+            with (
+                patch.object(cfg, "config_file", str(config_path)),
+                patch.object(cfg, "indextts_macos", dict(macos_settings)),
+                patch.object(cfg, "indextts", dict(windows_settings)),
+            ):
+                cfg.save_config()
+            saved_config = tomllib.loads(config_path.read_text(encoding="utf-8"))
+
+        self.assertEqual(macos_settings, saved_config["indextts_macos"])
+        self.assertEqual(windows_settings, saved_config["indextts"])
+
     def test_load_config_bootstraps_webui_llm_defaults(self):
         original_root_dir = cfg.root_dir
         original_config_file = cfg.config_file
@@ -57,11 +83,13 @@ hide_config = true
         self.assertEqual(0.95, config_data["app"]["vision_openai_top_p"])
         self.assertEqual("openai", config_data["app"]["text_llm_provider"])
         self.assertEqual("Pro/zai-org/GLM-5", config_data["app"]["text_openai_model_name"])
+        self.assertEqual("", config_data["app"]["text_openai_fast_model_name"])
         self.assertEqual("https://api.siliconflow.cn/v1", config_data["app"]["text_openai_base_url"])
         self.assertEqual(1.0, config_data["app"]["text_openai_temperature"])
         self.assertEqual(0.95, config_data["app"]["text_openai_top_p"])
         self.assertEqual("Qwen/Qwen3.5-122B-A10B", saved_config["app"]["vision_openai_model_name"])
         self.assertEqual("Pro/zai-org/GLM-5", saved_config["app"]["text_openai_model_name"])
+        self.assertEqual("", saved_config["app"]["text_openai_fast_model_name"])
         self.assertTrue(saved_config["app"]["hide_config"])
 
     def test_legacy_indextts2_config_is_migrated_to_indextts_15(self):
@@ -102,6 +130,23 @@ hide_config = true
 
 
 class OpenAICompatibleModelDefaultsTests(unittest.TestCase):
+    def test_fast_text_model_falls_back_to_reasoning_model(self):
+        app_config = {
+            "text_openai_model_name": "reasoning-model",
+            "text_openai_fast_model_name": "",
+        }
+
+        self.assertEqual(
+            "reasoning-model",
+            resolve_text_model_name(app_config, "openai", prefer_fast=True),
+        )
+
+        app_config["text_openai_fast_model_name"] = "fast-model"
+        self.assertEqual(
+            "fast-model",
+            resolve_text_model_name(app_config, "openai", prefer_fast=True),
+        )
+
     def test_ui_keeps_full_model_name_and_openai_provider(self):
         provider, model_name = get_openai_compatible_ui_values(
             "Qwen/Qwen3.5-122B-A10B",

app/models/schema.py

@@ -183,6 +183,7 @@ class VideoClipParams(BaseModel):
     bgm_name: Optional[str] = Field(default="random", description="背景音乐名称")
     bgm_type: Optional[str] = Field(default="random", description="背景音乐类型")
     bgm_file: Optional[str] = Field(default="", description="背景音乐文件")
+    sonilo_sfx_enabled: Optional[bool] = Field(default=False, description="是否启用 Sonilo AI 音效（可选功能，默认关闭）")
 
     subtitle_enabled: bool = True
     subtitle_mask_enabled: bool = False

app/services/SDE/short_drama_explanation.py

@@ -409,6 +409,7 @@ class SubtitleAnalyzer:
         temperature: float = 0.7,
         narration_language: str = "简体中文（中国）",
         drama_genre: str = "逆袭/复仇",
+        narration_word_count: int = 500,
     ) -> Dict[str, Any]:
         """生成供用户审核修改的解说正文。"""
         try:
@@ -420,6 +421,7 @@ class SubtitleAnalyzer:
                     "plot_analysis": plot_analysis,
                     "subtitle_content": subtitle_content,
                     "narration_language": narration_language,
+                    "narration_word_count": int(narration_word_count),
                 },
             )
             return self._generate_plain_text(prompt, system_prompt, temperature)
@@ -964,6 +966,7 @@ def generate_narration_copy(
     narration_language: str = "简体中文（中国）",
     drama_genre: str = "逆袭/复仇",
     prompt_category: str = "short_drama_narration",
+    narration_word_count: int = 500,
 ) -> Dict[str, Any]:
     """生成可供用户审核修改的解说正文。"""
     analyzer = SubtitleAnalyzer(
@@ -982,6 +985,7 @@ def generate_narration_copy(
         temperature=temperature,
         narration_language=narration_language,
         drama_genre=drama_genre,
+        narration_word_count=narration_word_count,
     )
 
 

app/services/jianying_task.py

@@ -114,6 +114,10 @@ def _normalize_indextts_reference_audio(params: VideoClipParams) -> None:
         tts_config = config.indextts
         voice_prefix = config.INDEXTTS_VOICE_PREFIX
         display_name = "IndexTTS-1.5"
+    elif params.tts_engine == config.INDEXTTS_MACOS_ENGINE:
+        tts_config = config.indextts_macos
+        voice_prefix = config.INDEXTTS_MACOS_VOICE_PREFIX
+        display_name = config.INDEXTTS_MACOS_DISPLAY_NAME
     elif params.tts_engine == config.INDEXTTS2_ENGINE:
         tts_config = config.indextts2
         voice_prefix = config.INDEXTTS2_VOICE_PREFIX

app/services/llm.py

@@ -17,6 +17,10 @@ import subprocess
 from typing import Union, TextIO
 
 from app.config import config
+from app.utils.openai_base_url_security import (
+    openai_compatible_base_url_warning,
+    validate_openai_compatible_base_url,
+)
 from app.utils.utils import clean_model_output
 
 _max_retries = 5
@@ -330,6 +334,10 @@ def _generate_response(prompt: str, llm_provider: str = None) -> str:
                 azure_endpoint=base_url,
             )
         else:
+            base_url = validate_openai_compatible_base_url(base_url)
+            warning = openai_compatible_base_url_warning(base_url)
+            if warning:
+                logger.warning(warning)
             client = OpenAI(
                 api_key=api_key,
                 base_url=base_url,

app/services/llm/config_validator.py

@@ -164,11 +164,13 @@ class LLMConfigValidator:
             config_prefix = f"text_{provider_name}"
             api_key = config.app.get(f'{config_prefix}_api_key')
             model_name = config.app.get(f'{config_prefix}_model_name')
+            fast_model_name = config.app.get(f'{config_prefix}_fast_model_name')
             base_url = config.app.get(f'{config_prefix}_base_url')
             
             result["config"] = {
                 "api_key": "***" if api_key else None,
                 "model_name": model_name,
+                "fast_model_name": fast_model_name,
                 "base_url": base_url
             }
             
@@ -241,7 +243,8 @@ class LLMConfigValidator:
                     f"text_{provider}_model_name"
                 ],
                 "optional_configs": [
-                    f"text_{provider}_base_url"
+                    f"text_{provider}_base_url",
+                    f"text_{provider}_fast_model_name",
                 ],
                 "example_models": LLMConfigValidator._get_example_models(provider, "text")
             }

app/services/llm/migration_adapter.py

@@ -292,6 +292,7 @@ class SubtitleAnalyzerAdapter:
         temperature: float = 0.7,
         narration_language: str = "简体中文（中国）",
         drama_genre: str = "逆袭/复仇",
+        narration_word_count: int = 500,
     ) -> Dict[str, Any]:
         """Generate editable narration copy before timeline matching."""
         try:
@@ -303,6 +304,7 @@ class SubtitleAnalyzerAdapter:
                     "plot_analysis": plot_analysis,
                     "subtitle_content": subtitle_content,
                     "narration_language": narration_language,
+                    "narration_word_count": int(narration_word_count),
                 },
             )
             narration_copy = self._generate_plain_text(prompt, system_prompt, temperature)

app/services/llm/openai_compatible_provider.py

@@ -23,8 +23,13 @@ from openai import (
 
 from app.config import config
 from app.config.defaults import DEFAULT_LLM_GENERATION_CONFIG, normalize_openai_compatible_model_name
+from app.utils.openai_base_url_security import (
+    is_trusted_openai_compatible_base_url,
+    openai_compatible_base_url_warning,
+    validate_openai_compatible_base_url as _validate_openai_compatible_base_url_value,
+)
 from .base import TextModelProvider, VisionModelProvider
-from .exceptions import APICallError, AuthenticationError, ContentFilterError, RateLimitError
+from .exceptions import APICallError, AuthenticationError, ConfigurationError, ContentFilterError, RateLimitError
 
 
 def _normalize_model_name(model_name: str) -> str:
@@ -41,6 +46,17 @@ def _is_content_filter_error(message: str) -> bool:
     return "content_filter" in lowered or "safety" in lowered
 
 
+def validate_openai_compatible_base_url(base_url: Optional[str]) -> Optional[str]:
+    try:
+        normalized = _validate_openai_compatible_base_url_value(base_url)
+    except ValueError as exc:
+        raise ConfigurationError(str(exc), "base_url") from exc
+    warning = openai_compatible_base_url_warning(normalized)
+    if warning:
+        logger.warning(warning)
+    return normalized
+
+
 def _clean_json_output(output: str) -> str:
     """清理 JSON 输出中的 markdown 包裹。"""
     output = re.sub(r"^```json\s*", "", output, flags=re.MULTILINE)
@@ -118,6 +134,7 @@ class _OpenAICompatibleBase:
         """按请求构建 AsyncOpenAI 客户端，支持动态覆盖 api_key / base_url。"""
         api_key = api_key_override or self.api_key
         base_url = base_url_override or self.base_url or None
+        base_url = validate_openai_compatible_base_url(base_url)
 
         timeout_seconds: float = timeout_override or config.app.get("llm_text_timeout", 180)
         max_retries: int = max_retries_override or config.app.get("llm_max_retries", 3)
@@ -241,8 +258,9 @@ class OpenAICompatibleTextProvider(_OpenAICompatibleBase, TextModelProvider):
         response_format: Optional[str],
         kwargs: Dict[str, Any],
     ) -> Dict[str, Any]:
-        model_name = _normalize_model_name(self.model_name)
         generation_kwargs = dict(kwargs)
+        model_override = generation_kwargs.pop("model", None) or generation_kwargs.pop("model_name", None)
+        model_name = _normalize_model_name(model_override or self.model_name)
         temperature_override = generation_kwargs.pop("temperature", None)
         if temperature_override is None and temperature != 1.0:
             temperature_override = temperature

app/services/llm/test_openai_compat_unittest.py

@@ -6,10 +6,17 @@ from unittest.mock import patch
 
 from app.config import config
 from app.services.llm.base import TextModelProvider
+from app.services.llm.exceptions import ConfigurationError
 from app.services.llm.manager import LLMServiceManager
 from app.services.llm.migration_adapter import LegacyLLMAdapter, VisionAnalyzerAdapter
-from app.services.llm.openai_compatible_provider import OpenAICompatibleTextProvider, OpenAICompatibleVisionProvider
+from app.services.llm.openai_compatible_provider import (
+    OpenAICompatibleTextProvider,
+    OpenAICompatibleVisionProvider,
+    is_trusted_openai_compatible_base_url,
+    validate_openai_compatible_base_url,
+)
 from app.services.llm.providers import register_all_providers
+from app.utils.openai_base_url_security import openai_compatible_base_url_warning
 
 
 class DummyOpenAITextProvider(TextModelProvider):
@@ -142,6 +149,20 @@ class OpenAICompatGenerationOptionTests(unittest.TestCase):
         self.assertEqual(65536, options["max_tokens"])
         self.assertNotIn("extra_body", options)
 
+    def test_text_request_can_override_model_for_fast_tasks(self):
+        provider = OpenAICompatibleTextProvider(api_key="k", model_name="reasoning-model")
+
+        options = provider._build_text_completion_kwargs(
+            messages=[{"role": "user", "content": "hello"}],
+            temperature=0.2,
+            max_tokens=None,
+            response_format=None,
+            kwargs={"model": "fast-model", "thinking_level": "off"},
+        )
+
+        self.assertEqual("fast-model", options["model"])
+        self.assertNotIn("extra_body", options)
+
     def test_build_options_uses_per_model_generation_config(self):
         provider = OpenAICompatibleTextProvider(api_key="k", model_name="m")
         config.app.update(
@@ -170,6 +191,77 @@ class OpenAICompatGenerationOptionTests(unittest.TestCase):
         self.assertEqual(512, options["max_tokens"])
 
 
+class OpenAICompatBaseURLValidationTests(unittest.TestCase):
+    def setUp(self):
+        self._original_app = dict(config.app)
+
+    def tearDown(self):
+        config.app.clear()
+        config.app.update(self._original_app)
+
+    def test_known_providers_and_local_ollama_are_trusted(self):
+        trusted_urls = [
+            "https://api.openai.com/v1",
+            "https://api.siliconflow.cn/v1",
+            "https://openrouter.ai/api/v1",
+            "https://dashscope.aliyuncs.com/compatible-mode/v1",
+            "https://example.openai.azure.com/openai/deployments/demo",
+            "http://localhost:11434/v1",
+            "http://127.0.0.1:11434/v1",
+        ]
+
+        for url in trusted_urls:
+            with self.subTest(url=url):
+                self.assertTrue(is_trusted_openai_compatible_base_url(url))
+
+    def test_unrecognized_or_unsafe_base_urls_are_not_trusted(self):
+        untrusted_urls = [
+            "https://attacker.example/v1",
+            "http://api.openai.com/v1",
+            "https://user@api.openai.com/v1",
+            "https://127.0.0.1:9999/v1",
+            "not-a-url",
+        ]
+
+        for url in untrusted_urls:
+            with self.subTest(url=url):
+                self.assertFalse(is_trusted_openai_compatible_base_url(url))
+
+    def test_build_client_allows_well_formed_custom_base_url_by_default(self):
+        provider = OpenAICompatibleTextProvider(
+            api_key="test-key",
+            model_name="test-model",
+            base_url="https://custom.example/v1",
+        )
+
+        with patch("app.services.llm.openai_compatible_provider.AsyncOpenAI") as async_openai:
+            provider._build_client()
+
+        self.assertEqual("https://custom.example/v1", async_openai.call_args.kwargs["base_url"])
+
+    def test_custom_base_url_validation_returns_normalized_url(self):
+        self.assertEqual(
+            "https://custom.example/v1",
+            validate_openai_compatible_base_url(" https://custom.example/v1 "),
+        )
+
+    def test_custom_base_url_warning_only_for_untrusted_well_formed_urls(self):
+        warning = openai_compatible_base_url_warning("https://custom.example/v1")
+        self.assertIn("custom.example", warning)
+        self.assertEqual("", openai_compatible_base_url_warning("https://api.openai.com/v1"))
+        self.assertEqual("", openai_compatible_base_url_warning(""))
+
+    def test_custom_base_url_validation_rejects_malformed_urls(self):
+        provider = OpenAICompatibleTextProvider(
+            api_key="test-key",
+            model_name="test-model",
+            base_url="https://user@custom.example/v1",
+        )
+
+        with self.assertRaises(ConfigurationError):
+            provider._build_client()
+
+
 class ExplicitVisionAdapterSettingsTests(unittest.IsolatedAsyncioTestCase):
     class _CapturingVisionProvider:
         last_init: tuple[str, str, str | None] | None = None

app/services/llm/test_subtitle_adapter_pipeline_unittest.py

@@ -24,11 +24,14 @@ class SubtitleAnalyzerAdapterPipelineTests(unittest.TestCase):
                 temperature=0.7,
                 narration_language="简体中文（中国）",
                 drama_genre="家庭伦理",
+                narration_word_count=800,
             )
 
         self.assertEqual("success", result["status"])
         self.assertIn("反击", result["narration_copy"])
         self.assertIn("家庭伦理", call.call_args.kwargs["prompt"])
+        self.assertIn("800", call.call_args.kwargs["prompt"])
+        self.assertNotIn("300-650", call.call_args.kwargs["prompt"])
         self.assertNotIn("response_format", call.call_args.kwargs)
 
     def test_generate_narration_copy_can_use_film_tv_prompt_category(self):
@@ -49,11 +52,14 @@ class SubtitleAnalyzerAdapterPipelineTests(unittest.TestCase):
                 temperature=0.7,
                 narration_language="简体中文（中国）",
                 drama_genre="悬疑/犯罪",
+                narration_word_count=1200,
             )
 
         self.assertEqual("success", result["status"])
         self.assertIn("影视解说正文创作任务", call.call_args.kwargs["prompt"])
         self.assertIn("用户选择的影视类型", call.call_args.kwargs["prompt"])
+        self.assertIn("1200", call.call_args.kwargs["prompt"])
+        self.assertNotIn("350-750", call.call_args.kwargs["prompt"])
         self.assertNotIn("短剧解说正文创作任务", call.call_args.kwargs["prompt"])
 
     def test_film_tv_script_prompts_exclude_intro_outro_and_ads(self):

app/services/prompts/film_tv_narration/narration_copy.py

@@ -22,7 +22,14 @@ class NarrationCopyPrompt(ParameterizedPrompt):
             model_type=ModelType.TEXT,
             output_format=OutputFormat.TEXT,
             tags=["影视", "解说文案", "电影解说", "剧情承接", "用户审核"],
-            parameters=["drama_name", "drama_genre", "plot_analysis", "subtitle_content", "narration_language"],
+            parameters=[
+                "drama_name",
+                "drama_genre",
+                "plot_analysis",
+                "subtitle_content",
+                "narration_language",
+                "narration_word_count",
+            ],
         )
         super().__init__(metadata, required_parameters=["drama_name", "plot_analysis", "subtitle_content"])
 
@@ -57,6 +64,11 @@ ${narration_language}
 ${drama_genre}
 </drama_genre>
 
+## 用户要求的文案字数
+<narration_word_count>
+${narration_word_count}
+</narration_word_count>
+
 ## 类型写作规则
 必须按用户选择的影视类型调整表达重点，不要自行改判类型：
 - 剧情/情感：突出人物选择、关系裂痕、命运压力和情绪余波。
@@ -81,7 +93,7 @@ ${drama_genre}
 4. 每句话只表达一个信息点，适合后续按句匹配画面。
 5. 句子尽量短，单句优先 15-35 字；信息复杂时拆成多句。
 6. 每 2-3 句要有明确承接，让观众知道为什么从上一幕来到下一幕。
-7. 总长度控制在 350-750 字；短素材取下限，长素材取上限。
+7. 总长度以 ${narration_word_count} 字为目标，允许上下浮动 10%；中日韩语言按非空白字符计数，其他语言按单词计数。不得再套用固定长度区间。
 8. 不要使用编号、项目符号、章节标题或括号说明。
 
 ## 输出要求

app/services/prompts/short_drama_narration/narration_copy.py

@@ -22,7 +22,14 @@ class NarrationCopyPrompt(ParameterizedPrompt):
             model_type=ModelType.TEXT,
             output_format=OutputFormat.TEXT,
             tags=["短剧", "解说文案", "爆款开头", "叙事连续性", "用户审核"],
-            parameters=["drama_name", "drama_genre", "plot_analysis", "subtitle_content", "narration_language"],
+            parameters=[
+                "drama_name",
+                "drama_genre",
+                "plot_analysis",
+                "subtitle_content",
+                "narration_language",
+                "narration_word_count",
+            ],
         )
         super().__init__(metadata, required_parameters=["drama_name", "plot_analysis", "subtitle_content"])
 
@@ -57,6 +64,11 @@ ${narration_language}
 ${drama_genre}
 </drama_genre>
 
+## 用户要求的文案字数
+<narration_word_count>
+${narration_word_count}
+</narration_word_count>
+
 ## 类型写作规则
 必须按用户选择的短剧类型调整表达重点，不要自行改判类型：
 - 霸总/甜宠：突出误会、身份差、暧昧拉扯、守护感和情绪反差。
@@ -81,7 +93,7 @@ ${drama_genre}
 4. 每句话只表达一个信息点，适合后续按句匹配画面。
 5. 句子尽量短，单句优先 15-35 字；信息复杂时拆成多句。
 6. 每 2-3 句要有明确因果承接，让观众知道为什么从上一幕来到下一幕。
-7. 总长度控制在 300-650 字；短素材取下限，长素材取上限。
+7. 总长度以 ${narration_word_count} 字为目标，允许上下浮动 10%；中日韩语言按非空白字符计数，其他语言按单词计数。不得再套用固定长度区间。
 8. 不要使用编号、项目符号、章节标题或括号说明。
 
 ## 输出要求

app/services/sonilo.py

@@ -0,0 +1,626 @@
+"""
+Sonilo (https://sonilo.com) AI 配乐（BGM）与 AI 音效（SFX）集成 ——
+均为可选功能，默认关闭。
+
+配乐（BGM）：将合成完成的视频（未加 BGM）上传到 Sonilo API
+（`POST /v1/video-to-music`），根据画面内容与剪辑节奏生成一段背景音乐，
+作为普通音频文件交还给现有的合成流程混音。生成的音乐已获授权、
+可商用（以条款为准）。
+
+音效（SFX）：将合成完成的视频上传到 Sonilo API
+（`POST /v1/video-to-sfx`），根据画面内容生成贴合画面的音效。该接口是
+异步任务：提交后返回 task_id，轮询 `GET /v1/tasks/{task_id}` 直到终态，
+成功后从预签名 URL 下载音效音频，再用 ffmpeg 混在成片现有音轨之下
+（解说配音在后续合成步骤中单独混入，音量策略不受影响）。生成的音效为
+免版税素材。
+
+设计约束（完全不影响现有合成逻辑）：
+  * 默认关闭。配乐仅当用户在 WebUI 中把背景音乐来源切换为 Sonilo 时启用；
+    音效仅当用户勾选 "AI 音效（Sonilo）" 时启用。两者都要求配置了
+    Sonilo API Key（config.toml 的 `sonilo_api_key`，或环境变量
+    `SONILO_API_KEY` 兜底）。
+  * 配乐模块只负责生成音频文件；音量、淡出、循环与混音全部复用
+    app/services/generate_video.py 中现有的音频处理逻辑，解说配音的
+    音量压制策略保持不变。
+  * 任何失败（超时、HTTP 错误、流中断、时长超限、混音失败）都只记录
+    日志并返回空字符串，由调用方回退到现有逻辑，绝不中断成片任务。
+  * 上传属于计费操作，上传前先用 ffprobe 在本地校验视频时长（配乐接口
+    目前拒绝超过 6 分钟的视频，音效接口拒绝超过 3 分钟的视频），避免
+    白传一次注定被拒绝的成片。
+
+配乐接口返回 NDJSON 事件流：`audio_chunk`（base64 音频分片，按
+stream_index 分组）、`title`、`complete`（成功终止事件）与 `error`
+（失败终止事件）。进度事件与无法解析的行一律忽略。生成的音频为 AAC
+编码的 .m4a 文件。
+
+音效接口为异步任务管线：`POST /v1/video-to-sfx` 受理后即计费并返回
+`{"task_id": ...}`；`GET /v1/tasks/{task_id}` 返回
+`{"status": "succeeded"/"failed"/..., "audio": {"url": ...}, "error": ...,
+"refunded": ...}`。结果地址是预签名 URL，下载时绝不能携带 API Key。
+
+配置（config.toml 的 [app] 段）：
+    sonilo_api_key = "..."             # 必填，启用开关（配乐与音效共用）
+    # sonilo_base_url = "https://api.sonilo.com"
+    # sonilo_timeout_seconds = 600
+    # sonilo_bgm_prompt = ""           # 可选：配乐风格提示
+    # sonilo_sfx_prompt = ""           # 可选：音效风格提示
+    # sonilo_sfx_volume = 0.6          # 音效混入原声之下的音量（0-2]
+"""
+
+import base64
+import binascii
+import json
+import os
+import subprocess
+import time
+from typing import Iterable, Optional
+
+import requests
+from loguru import logger
+
+from app.config import config
+
+DEFAULT_BASE_URL = "https://api.sonilo.com"
+VIDEO_TO_MUSIC_PATH = "/v1/video-to-music"
+VIDEO_TO_SFX_PATH = "/v1/video-to-sfx"
+TASKS_PATH = "/v1/tasks"
+# 后端生成接口的读超时约为 600 秒。生成一旦开始就会计费，客户端过早超时
+# 只会浪费一次已经付费的请求，所以默认读超时与后端保持一致，并允许覆盖。
+DEFAULT_TIMEOUT_SECONDS = 600
+_CONNECT_TIMEOUT_SECONDS = 15
+# 轮询任务状态是免费且幂等的 GET，单次请求用短读超时即可。
+_POLL_READ_TIMEOUT_SECONDS = 30
+_SFX_POLL_INTERVAL_SECONDS = 5.0
+# 测试接缝：单测里替换为 no-op，避免真实等待。
+_sleep = time.sleep
+# 配乐接口目前拒绝超过 6 分钟的视频；上传前先在本地校验时长。
+MAX_VIDEO_DURATION_SECONDS = 360
+# 音效接口目前拒绝超过 3 分钟的视频。
+MAX_SFX_VIDEO_DURATION_SECONDS = 180
+# 音效混入原声之下的默认音量（解说配音在后续合成步骤中以 1.0 混入，
+# 音效保持在其之下）。可通过 sonilo_sfx_volume 配置覆盖。
+DEFAULT_SFX_VOLUME = 0.6
+
+
+class SoniloError(Exception):
+    """Sonilo 配乐生成失败。"""
+
+
+def get_api_key() -> str:
+    """返回配置的 Sonilo API Key（优先 config.toml，其次环境变量）。"""
+    api_key = config.app.get("sonilo_api_key", "") or os.getenv("SONILO_API_KEY", "")
+    return str(api_key).strip()
+
+
+def is_enabled() -> bool:
+    """仅当配置了 Sonilo API Key 时返回 True。"""
+    return bool(get_api_key())
+
+
+def _get_base_url() -> str:
+    return str(config.app.get("sonilo_base_url", "") or DEFAULT_BASE_URL).rstrip("/")
+
+
+def generate_bgm(video_path: str, save_path: str) -> str:
+    """
+    上传合成完成的视频（未加 BGM）到 Sonilo，生成配乐并保存到
+    `save_path`（.m4a）。
+
+    成功时返回音频文件路径，任何失败都返回空字符串，由调用方回退到
+    现有的 BGM 逻辑。本函数绝不抛出异常 —— 配乐问题绝不能中断成片任务。
+    """
+    if not is_enabled():
+        logger.warning("Sonilo 配乐已跳过: 未配置 API Key")
+        return ""
+
+    if not video_path or not os.path.isfile(video_path):
+        logger.warning(f"Sonilo 配乐已跳过: 视频文件不存在: {video_path}")
+        return ""
+
+    # 上传即计费，先在本地校验时长，避免白传一次注定被拒绝的成片。
+    duration = _probe_video_duration(video_path)
+    if duration and duration > MAX_VIDEO_DURATION_SECONDS:
+        logger.warning(
+            f"Sonilo 配乐已跳过: 视频时长 {duration:.1f}s 超过接口上限 "
+            f"{MAX_VIDEO_DURATION_SECONDS}s"
+        )
+        return ""
+
+    try:
+        audio = _request_video_to_music(video_path)
+    except Exception as e:
+        # 任何失败（超时、HTTP 错误、流中断）都降级，由调用方回退到
+        # 现有 BGM 逻辑，绝不让配乐问题中断成片任务。
+        logger.error(f"Sonilo 配乐生成失败: {str(e)}")
+        return ""
+
+    try:
+        with open(save_path, "wb") as f:
+            f.write(audio)
+    except OSError as e:
+        logger.error(f"Sonilo 配乐文件保存失败: {str(e)}")
+        return ""
+
+    logger.success(f"Sonilo 配乐已生成: {save_path}")
+    return save_path
+
+
+def _get_ffprobe_binary() -> str:
+    """与 generate_video 保持一致的 ffprobe 查找逻辑（环境变量优先）。"""
+    for env_name in ("NARRATO_FFPROBE_EXE", "IMAGEIO_FFPROBE_EXE"):
+        candidate = os.environ.get(env_name, "").strip()
+        if candidate and os.path.isfile(candidate):
+            return candidate
+    return "ffprobe"
+
+
+def _probe_video_duration(video_path: str) -> float:
+    """
+    尽力而为的本地 ffprobe 时长探测。ffprobe 不可用、超时或输出无法解析
+    时返回 0.0，交给后端做最终校验。
+    """
+    try:
+        result = subprocess.run(
+            [
+                _get_ffprobe_binary(),
+                "-v",
+                "quiet",
+                "-print_format",
+                "json",
+                "-show_format",
+                video_path,
+            ],
+            capture_output=True,
+            timeout=30,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return 0.0
+    if result.returncode != 0:
+        return 0.0
+    try:
+        return float(json.loads(result.stdout)["format"]["duration"])
+    except (json.JSONDecodeError, KeyError, TypeError, ValueError):
+        return 0.0
+
+
+def _error_detail(body: str) -> str:
+    try:
+        parsed = json.loads(body)
+    except (json.JSONDecodeError, TypeError):
+        return body
+    if isinstance(parsed, dict):
+        detail = parsed.get("detail") or parsed.get("error") or parsed.get("message")
+        if isinstance(detail, str) and detail.strip():
+            return detail.strip()
+    return body
+
+
+def _http_error_message(status_code: int, body: str) -> str:
+    detail = _error_detail(body)
+    if status_code == 401:
+        return "Sonilo API Key 无效，请检查配置"
+    if status_code == 402:
+        return detail or "Sonilo 账户余额不足"
+    if status_code == 413:
+        return f"视频文件过大: {detail}"
+    if status_code == 429:
+        return f"触发 Sonilo 频率限制: {detail}"
+    return f"Sonilo 接口错误 ({status_code}): {detail}"
+
+
+def _get_timeout_seconds() -> float:
+    try:
+        return float(
+            config.app.get("sonilo_timeout_seconds", DEFAULT_TIMEOUT_SECONDS)
+        )
+    except (TypeError, ValueError):
+        return DEFAULT_TIMEOUT_SECONDS
+
+
+def _request_video_to_music(video_path: str) -> bytes:
+    base_url = _get_base_url()
+    timeout_seconds = _get_timeout_seconds()
+
+    prompt = str(config.app.get("sonilo_bgm_prompt", "") or "").strip()
+    data: Optional[dict] = {"prompt": prompt} if prompt else None
+    headers = {"Authorization": f"Bearer {get_api_key()}"}
+
+    logger.info(
+        f"正在使用 Sonilo 生成配乐, 视频: {video_path}, "
+        f"读超时: {timeout_seconds:.0f}s"
+    )
+
+    try:
+        with open(video_path, "rb") as video_file:
+            files = {
+                "video": (os.path.basename(video_path), video_file, "video/mp4"),
+            }
+            # 生成接口非幂等（生成即计费），失败不做自动重试，直接降级。
+            with requests.post(
+                f"{base_url}{VIDEO_TO_MUSIC_PATH}",
+                headers=headers,
+                data=data,
+                files=files,
+                stream=True,
+                timeout=(_CONNECT_TIMEOUT_SECONDS, timeout_seconds),
+            ) as response:
+                if response.status_code >= 400:
+                    body = response.content.decode("utf-8", errors="replace")
+                    raise SoniloError(
+                        _http_error_message(response.status_code, body)
+                    )
+                return _consume_ndjson_stream(
+                    response.iter_lines(decode_unicode=True)
+                )
+    except requests.exceptions.Timeout as exc:
+        raise SoniloError(
+            f"Sonilo 请求超时 ({timeout_seconds:.0f}s)"
+        ) from exc
+    except requests.exceptions.RequestException as exc:
+        raise SoniloError(f"Sonilo 请求失败: {str(exc)}") from exc
+
+
+def _consume_ndjson_stream(lines: Iterable[str]) -> bytes:
+    """
+    消费 NDJSON 事件流，按 stream_index 分组 base64 音频分片，
+    返回第一条音轨。
+    """
+    streams = {}
+    completed = False
+    for line in lines:
+        if not line or not line.strip():
+            continue
+        try:
+            event = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if not isinstance(event, dict):
+            continue
+        event_type = event.get("type")
+        if event_type == "audio_chunk":
+            chunk = event.get("data")
+            if not isinstance(chunk, str):
+                continue
+            try:
+                index = int(event.get("stream_index", 0))
+            except (TypeError, ValueError):
+                continue
+            if index < 0:
+                continue
+            try:
+                decoded = base64.b64decode(chunk, validate=True)
+            except (binascii.Error, ValueError):
+                continue
+            streams.setdefault(index, bytearray()).extend(decoded)
+        elif event_type == "complete":
+            completed = True
+        elif event_type == "error":
+            message = event.get("message") or event.get("code") or "stream error"
+            raise SoniloError(f"Sonilo 生成失败: {message}")
+        # title / stage_start 等进度事件一律忽略。
+
+    if not completed:
+        raise SoniloError("Sonilo 事件流意外终止（未收到 complete 事件）")
+    if not streams:
+        raise SoniloError("Sonilo 事件流已完成但未返回音频数据")
+    first_index = sorted(streams)[0]
+    return bytes(streams[first_index])
+
+
+# ---------- AI 音效（SFX，可选功能，默认关闭） ----------
+
+
+def apply_sfx(video_path: str, output_path: str) -> str:
+    """
+    为合成完成的视频生成 Sonilo 音效，并用 ffmpeg 混在现有音轨之下，
+    输出新视频到 `output_path`（视频流直接复制，不重编码画面）。
+
+    成功时返回输出视频路径，任何失败都返回空字符串，由调用方沿用
+    原视频。本函数绝不抛出异常 —— 音效问题绝不能中断成片任务。
+    """
+    sfx_audio_path = os.path.splitext(output_path)[0] + ".m4a"
+    if not generate_sfx(video_path, sfx_audio_path):
+        return ""
+    return _mix_sfx_under_original(video_path, sfx_audio_path, output_path)
+
+
+def generate_sfx(video_path: str, save_path: str) -> str:
+    """
+    上传合成完成的视频到 Sonilo，生成音效音频并保存到 `save_path`（.m4a）。
+
+    成功时返回音频文件路径，任何失败都返回空字符串。与 generate_bgm
+    的约定一致：本函数绝不抛出异常。
+    """
+    if not is_enabled():
+        logger.warning("Sonilo 音效已跳过: 未配置 API Key")
+        return ""
+
+    if not video_path or not os.path.isfile(video_path):
+        logger.warning(f"Sonilo 音效已跳过: 视频文件不存在: {video_path}")
+        return ""
+
+    # 任务受理即计费，先在本地校验时长，避免白传一次注定被拒绝的成片。
+    duration = _probe_video_duration(video_path)
+    if duration and duration > MAX_SFX_VIDEO_DURATION_SECONDS:
+        logger.warning(
+            f"Sonilo 音效已跳过: 视频时长 {duration:.1f}s 超过接口上限 "
+            f"{MAX_SFX_VIDEO_DURATION_SECONDS}s"
+        )
+        return ""
+
+    try:
+        audio = _request_video_to_sfx(video_path)
+    except Exception as e:
+        logger.error(f"Sonilo 音效生成失败: {str(e)}")
+        return ""
+
+    try:
+        with open(save_path, "wb") as f:
+            f.write(audio)
+    except OSError as e:
+        logger.error(f"Sonilo 音效文件保存失败: {str(e)}")
+        return ""
+
+    logger.success(f"Sonilo 音效已生成: {save_path}")
+    return save_path
+
+
+def _request_video_to_sfx(video_path: str) -> bytes:
+    """提交音效任务、轮询到终态、下载结果音频。失败抛出 SoniloError。"""
+    task_id = _submit_sfx_task(video_path)
+    body = _poll_sfx_task(task_id)
+    return _download_sfx_audio(_extract_sfx_audio_url(body, task_id))
+
+
+def _submit_sfx_task(video_path: str) -> str:
+    """POST /v1/video-to-sfx，受理后返回 task_id（受理即计费，不做重试）。"""
+    timeout_seconds = _get_timeout_seconds()
+    prompt = str(config.app.get("sonilo_sfx_prompt", "") or "").strip()
+    data: Optional[dict] = {"prompt": prompt} if prompt else None
+    headers = {"Authorization": f"Bearer {get_api_key()}"}
+
+    logger.info(f"正在提交 Sonilo 音效任务, 视频: {video_path}")
+
+    try:
+        with open(video_path, "rb") as video_file:
+            files = {
+                "video": (os.path.basename(video_path), video_file, "video/mp4"),
+            }
+            response = requests.post(
+                f"{_get_base_url()}{VIDEO_TO_SFX_PATH}",
+                headers=headers,
+                data=data,
+                files=files,
+                timeout=(_CONNECT_TIMEOUT_SECONDS, timeout_seconds),
+            )
+    except requests.exceptions.Timeout as exc:
+        raise SoniloError(
+            f"Sonilo 音效任务提交超时 ({timeout_seconds:.0f}s)"
+        ) from exc
+    except requests.exceptions.RequestException as exc:
+        raise SoniloError(f"Sonilo 音效任务提交失败: {str(exc)}") from exc
+
+    if response.status_code >= 400:
+        body = response.content.decode("utf-8", errors="replace")
+        raise SoniloError(_http_error_message(response.status_code, body))
+
+    try:
+        task_id = response.json().get("task_id")
+    except (ValueError, AttributeError):
+        task_id = None
+    if not task_id:
+        raise SoniloError("Sonilo 音效任务已受理但未返回 task_id")
+    task_id = str(task_id)
+    # 受理即计费；先把 task_id 落进日志，后续轮询失败时仍有据可查。
+    logger.info(f"Sonilo 音效任务已提交: {task_id}")
+    return task_id
+
+
+def _poll_sfx_task(task_id: str) -> dict:
+    """
+    轮询 GET /v1/tasks/{task_id} 直到任务终态（succeeded/failed）或超时。
+
+    succeeded 时返回任务体；failed / 超时 / 不可恢复的 HTTP 错误抛出
+    SoniloError。轮询是免费且幂等的 GET，网络抖动与 5xx 不该报废一次
+    已计费的任务，在截止时间内继续重试。
+    """
+    headers = {"Authorization": f"Bearer {get_api_key()}"}
+    timeout_seconds = _get_timeout_seconds()
+    deadline = time.monotonic() + timeout_seconds
+
+    while True:
+        response = None
+        try:
+            response = requests.get(
+                f"{_get_base_url()}{TASKS_PATH}/{task_id}",
+                headers=headers,
+                timeout=(_CONNECT_TIMEOUT_SECONDS, _POLL_READ_TIMEOUT_SECONDS),
+            )
+        except requests.exceptions.RequestException as exc:
+            logger.warning(f"Sonilo 音效任务查询失败（将重试）: {str(exc)}")
+
+        if response is not None:
+            if response.status_code >= 500:
+                logger.warning(
+                    f"Sonilo 音效任务查询返回 {response.status_code}（将重试）"
+                )
+            elif response.status_code >= 400:
+                body = response.content.decode("utf-8", errors="replace")
+                raise SoniloError(
+                    f"{_http_error_message(response.status_code, body)}"
+                    f"（任务已提交, task_id: {task_id}）"
+                )
+            else:
+                try:
+                    body = response.json()
+                except ValueError:
+                    body = None
+                if isinstance(body, dict):
+                    status = body.get("status")
+                    if status == "succeeded":
+                        return body
+                    if status == "failed":
+                        raise SoniloError(_task_failure_message(body, task_id))
+                # 非终态（pending / processing 等）继续等待。
+
+        if time.monotonic() >= deadline:
+            raise SoniloError(
+                f"等待 Sonilo 音效任务超时 ({timeout_seconds:.0f}s), "
+                f"task_id: {task_id}"
+            )
+        _sleep(_SFX_POLL_INTERVAL_SECONDS)
+
+
+def _task_failure_message(body: dict, task_id: str) -> str:
+    err = body.get("error")
+    if isinstance(err, dict):
+        message = err.get("message") or err.get("code") or "生成失败"
+    elif isinstance(err, str) and err:
+        message = err
+    else:
+        message = "生成失败"
+    refund_note = "，费用已退还" if body.get("refunded") is True else ""
+    return f"Sonilo 音效生成失败: {message}（task_id: {task_id}{refund_note}）"
+
+
+def _extract_sfx_audio_url(body: dict, task_id: str) -> str:
+    audio = body.get("audio")
+    if isinstance(audio, dict):
+        url = audio.get("url")
+        if isinstance(url, str) and url:
+            return url
+    raise SoniloError(
+        f"Sonilo 音效任务成功但未返回音频结果 (task_id: {task_id})"
+    )
+
+
+def _download_sfx_audio(url: str) -> bytes:
+    """下载任务结果音频。结果地址是预签名 URL，自带鉴权 ——
+    绝不能把 API Key 发给存储域名，因此这里不带任何鉴权头。"""
+    try:
+        response = requests.get(
+            url, timeout=(_CONNECT_TIMEOUT_SECONDS, _get_timeout_seconds())
+        )
+    except requests.exceptions.RequestException as exc:
+        raise SoniloError(f"Sonilo 音效结果下载失败: {str(exc)}") from exc
+    if response.status_code >= 400:
+        raise SoniloError(
+            f"Sonilo 音效结果下载失败 (HTTP {response.status_code})"
+        )
+    if not response.content:
+        raise SoniloError("Sonilo 音效结果为空")
+    return response.content
+
+
+def _get_sfx_volume() -> float:
+    """音效混入原声之下的音量。非法值或 <=0 回退默认值，上限 2.0。"""
+    try:
+        volume = float(config.app.get("sonilo_sfx_volume", DEFAULT_SFX_VOLUME))
+    except (TypeError, ValueError):
+        return DEFAULT_SFX_VOLUME
+    if volume <= 0:
+        return DEFAULT_SFX_VOLUME
+    return min(volume, 2.0)
+
+
+def _get_ffmpeg_binary() -> str:
+    """与 generate_video 保持一致的 ffmpeg 查找逻辑（环境变量优先）。"""
+    for env_name in ("NARRATO_FFMPEG_EXE", "IMAGEIO_FFMPEG_EXE"):
+        candidate = os.environ.get(env_name, "").strip()
+        if candidate and os.path.isfile(candidate):
+            return candidate
+    try:
+        import imageio_ffmpeg
+
+        candidate = imageio_ffmpeg.get_ffmpeg_exe()
+        if candidate and os.path.isfile(candidate):
+            return candidate
+    except Exception:
+        pass
+    return "ffmpeg"
+
+
+def _probe_has_audio_stream(video_path: str) -> bool:
+    """尽力而为地探测视频是否带音轨。探测失败按无音轨处理。"""
+    try:
+        result = subprocess.run(
+            [
+                _get_ffprobe_binary(),
+                "-v",
+                "quiet",
+                "-print_format",
+                "json",
+                "-show_streams",
+                "-select_streams",
+                "a",
+                video_path,
+            ],
+            capture_output=True,
+            timeout=30,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+    if result.returncode != 0:
+        return False
+    try:
+        return bool(json.loads(result.stdout).get("streams"))
+    except (json.JSONDecodeError, AttributeError, TypeError, ValueError):
+        return False
+
+
+def _mix_sfx_under_original(
+    video_path: str, sfx_audio_path: str, output_path: str
+) -> str:
+    """
+    用 ffmpeg 把音效混在成片现有音轨之下（音效音量默认 0.6，原声音量
+    不变），视频流直接复制不重编码。成片没有音轨时，音效直接作为音轨
+    写入。成功返回 output_path，任何失败返回空字符串。
+    """
+    volume = _get_sfx_volume()
+    has_audio = _probe_has_audio_stream(video_path)
+    if has_audio:
+        filter_complex = (
+            f"[1:a]volume={volume}[sfx];"
+            "[0:a][sfx]amix=inputs=2:duration=first:"
+            "dropout_transition=0:normalize=0[aout]"
+        )
+    else:
+        filter_complex = f"[1:a]volume={volume}[aout]"
+
+    cmd = [
+        _get_ffmpeg_binary(),
+        "-y",
+        "-i",
+        video_path,
+        "-i",
+        sfx_audio_path,
+        "-filter_complex",
+        filter_complex,
+        "-map",
+        "0:v",
+        "-map",
+        "[aout]",
+        "-c:v",
+        "copy",
+        "-c:a",
+        "aac",
+        "-b:a",
+        "192k",
+    ]
+    if not has_audio:
+        cmd.append("-shortest")
+    cmd.append(output_path)
+
+    logger.info(f"正在混入 Sonilo 音效 (音量 {volume}): {output_path}")
+    try:
+        result = subprocess.run(cmd, capture_output=True, timeout=300)
+    except (OSError, subprocess.TimeoutExpired) as e:
+        logger.error(f"Sonilo 音效混音失败: {str(e)}")
+        return ""
+    if result.returncode != 0:
+        stderr_tail = (result.stderr or b"").decode("utf-8", errors="replace")[-500:]
+        logger.error(f"Sonilo 音效混音失败 (ffmpeg 退出码 {result.returncode}): {stderr_tail}")
+        return ""
+
+    logger.success(f"Sonilo 音效已混入: {output_path}")
+    return output_path

app/services/subtitle_corrector.py

@@ -10,6 +10,8 @@ from typing import Any
 
 from loguru import logger
 
+from app.config import config
+from app.config.defaults import resolve_text_model_name
 from app.services.llm.manager import LLMServiceManager
 from app.services.llm.migration_adapter import _run_async_safely
 from app.services.llm.unified_service import UnifiedLLMService
@@ -174,12 +176,16 @@ def correct_srt_content(
     provider: str = "",
     api_key: str = "",
     base_url: str = "",
+    model_name: str = "",
     temperature: float = 0.1,
 ) -> str:
     blocks = parse_srt_blocks(srt_content)
     _ensure_llm_providers_registered()
 
-    logger.info(f"开始校准字幕，共 {len(blocks)} 条")
+    resolved_model_name = str(
+        model_name or resolve_text_model_name(config.app, provider, prefer_fast=True)
+    ).strip()
+    logger.info(f"开始使用高效率模型 {resolved_model_name} 校准字幕，共 {len(blocks)} 条")
     prompt = _build_correction_prompt(blocks)
     raw_output = _run_async_safely(
         UnifiedLLMService.generate_text,
@@ -190,6 +196,8 @@ def correct_srt_content(
         response_format="json",
         api_key=api_key,
         api_base=base_url,
+        model=resolved_model_name,
+        thinking_level="off",
     )
     corrections = _parse_corrections(raw_output, {block.order for block in blocks})
     corrected_srt = _render_srt(blocks, corrections)
@@ -215,6 +223,7 @@ def correct_subtitle_file(
     provider: str = "",
     api_key: str = "",
     base_url: str = "",
+    model_name: str = "",
     temperature: float = 0.1,
 ) -> str:
     if not subtitle_file or not os.path.isfile(subtitle_file):
@@ -226,6 +235,7 @@ def correct_subtitle_file(
         provider=provider,
         api_key=api_key,
         base_url=base_url,
+        model_name=model_name,
         temperature=temperature,
     )
     return write_srt_file(corrected_srt, output_file)

app/services/subtitle_translator.py

@@ -11,6 +11,7 @@ from typing import Any, Callable
 from loguru import logger
 
 from app.config import config
+from app.config.defaults import resolve_text_model_name
 from app.services.llm.migration_adapter import _run_async_safely
 from app.services.llm.unified_service import UnifiedLLMService
 from app.services.subtitle_corrector import (
@@ -151,6 +152,7 @@ def _translate_chunk(
     provider: str,
     api_key: str,
     base_url: str,
+    model_name: str,
     temperature: float,
     max_repair_attempts: int,
 ) -> dict[int, str]:
@@ -189,6 +191,8 @@ def _translate_chunk(
             response_format="json",
             api_key=api_key,
             api_base=base_url,
+            model=model_name,
+            thinking_level="off",
         )
         last_output = str(raw_output or "")
         try:
@@ -243,6 +247,7 @@ def translate_srt_content(
     provider: str = "",
     api_key: str = "",
     base_url: str = "",
+    model_name: str = "",
     temperature: float = 0.2,
     batch_size: int | None = None,
     max_workers: int | None = None,
@@ -251,6 +256,9 @@ def translate_srt_content(
     target_language = str(target_language or "").strip() or "中文"
     blocks = parse_srt_blocks(srt_content)
     _ensure_llm_providers_registered()
+    resolved_model_name = str(
+        model_name or resolve_text_model_name(config.app, provider, prefer_fast=True)
+    ).strip()
 
     resolved_batch_size = _resolve_batch_size(batch_size)
     chunks = _split_blocks(blocks, resolved_batch_size)
@@ -260,7 +268,8 @@ def translate_srt_content(
 
     logger.info(
         f"开始批量翻译字幕: 共 {total_blocks} 条, {total_chunks} 批, "
-        f"每批最多 {resolved_batch_size} 条, 并发 {resolved_max_workers}, 目标语言: {target_language}"
+        f"每批最多 {resolved_batch_size} 条, 并发 {resolved_max_workers}, "
+        f"目标语言: {target_language}, 高效率模型: {resolved_model_name}"
     )
 
     translations: dict[int, str] = {}
@@ -282,6 +291,7 @@ def translate_srt_content(
                 provider=provider,
                 api_key=api_key,
                 base_url=base_url,
+                model_name=resolved_model_name,
                 temperature=temperature,
                 max_repair_attempts=DEFAULT_MAX_REPAIR_ATTEMPTS,
             )
@@ -301,6 +311,7 @@ def translate_srt_content(
                     provider=provider,
                     api_key=api_key,
                     base_url=base_url,
+                    model_name=resolved_model_name,
                     temperature=temperature,
                     max_repair_attempts=DEFAULT_MAX_REPAIR_ATTEMPTS,
                 )
@@ -347,6 +358,7 @@ def translate_subtitle_file(
     provider: str = "",
     api_key: str = "",
     base_url: str = "",
+    model_name: str = "",
     temperature: float = 0.2,
     batch_size: int | None = None,
     max_workers: int | None = None,
@@ -362,6 +374,7 @@ def translate_subtitle_file(
         provider=provider,
         api_key=api_key,
         base_url=base_url,
+        model_name=model_name,
         temperature=temperature,
         batch_size=batch_size,
         max_workers=max_workers,

app/services/task.py

@@ -19,6 +19,7 @@ from app.services import (
     update_script,
     generate_video,
     script_subtitle,
+    sonilo,
 )
 from app.services import state as sm
 from app.utils import utils
@@ -214,6 +215,45 @@ def _build_subtitle_mask_options(params: VideoClipParams, enabled=None) -> dict:
     }
 
 
+def _resolve_bgm_path(task_id: str, params: VideoClipParams, combined_video_path: str) -> str:
+    """解析最终合成使用的背景音乐文件路径。
+
+    bgm_type 为 "sonilo" 时（可选功能，默认关闭），将合并后的成片上传到
+    Sonilo API 生成配乐；任何失败都只记录日志并回退到现有的随机背景音乐
+    逻辑，绝不中断成片任务。其余 bgm_type 走原有逻辑，保持不变。
+    """
+    if getattr(params, "bgm_type", "") == "sonilo":
+        save_path = path.join(utils.task_dir(task_id), "sonilo_bgm.m4a")
+        bgm_path = sonilo.generate_bgm(combined_video_path, save_path)
+        if bgm_path:
+            return bgm_path
+        logger.warning("Sonilo 配乐不可用，回退到随机背景音乐")
+        return utils.get_bgm_file(bgm_type="random", bgm_file="")
+
+    return utils.get_bgm_file(
+        bgm_type=getattr(params, "bgm_type", "random"),
+        bgm_file=getattr(params, "bgm_file", ""),
+    )
+
+
+def _apply_sonilo_sfx(task_id: str, params: VideoClipParams, combined_video_path: str) -> str:
+    """为合并后的成片混入 Sonilo AI 音效（可选功能，默认关闭）。
+
+    仅当 params.sonilo_sfx_enabled 为 True 时启用：把合并后的成片上传到
+    Sonilo API 生成音效，再用 ffmpeg 混在现有音轨之下，返回新视频路径。
+    解说配音在后续 merge_materials 中单独混入，音量策略不受影响。任何
+    失败都只记录日志并沿用原视频，绝不中断成片任务。
+    """
+    if not getattr(params, "sonilo_sfx_enabled", False):
+        return combined_video_path
+    output_path = path.join(utils.task_dir(task_id), "merger_sfx.mp4")
+    sfx_video_path = sonilo.apply_sfx(combined_video_path, output_path)
+    if sfx_video_path:
+        return sfx_video_path
+    logger.warning("Sonilo 音效不可用，继续使用未加音效的成片")
+    return combined_video_path
+
+
 def _transcribe_final_video(task_id: str, video_path: str, params: VideoClipParams) -> str:
     """Transcribe the fully merged video into an SRT file."""
     from app.services import fun_asr_subtitle
@@ -520,11 +560,11 @@ def start_subclip(task_id: str, params: VideoClipParams, subclip_path_videos: di
     )
     logger.info(f"\n\n## 6. 最后一步: 合并字幕/BGM/配音/视频 -> {merge_output_video_path}")
 
+    # 可选功能，默认关闭：混入 Sonilo AI 音效（失败时沿用原视频）
+    combined_video_path = _apply_sonilo_sfx(task_id, params, combined_video_path)
+
     # bgm_path = '/Users/apple/Desktop/home/NarratoAI/resource/songs/bgm.mp3'
-    bgm_path = utils.get_bgm_file(
+    bgm_path = _resolve_bgm_path(task_id, params, combined_video_path)
-        bgm_type=getattr(params, "bgm_type", "random"),
-        bgm_file=getattr(params, "bgm_file", ""),
-    )
 
     # 获取优化的音量配置
     optimized_volumes = get_recommended_volumes_for_content('mixed')
@@ -850,10 +890,10 @@ def start_subclip_unified(task_id: str, params: VideoClipParams):
         ffmpeg_progress=0,
     )
 
-    bgm_path = utils.get_bgm_file(
+    # 可选功能，默认关闭：混入 Sonilo AI 音效（失败时沿用原视频）
-        bgm_type=getattr(params, "bgm_type", "random"),
+    combined_video_path = _apply_sonilo_sfx(task_id, params, combined_video_path)
-        bgm_file=getattr(params, "bgm_file", ""),
+
-    )
+    bgm_path = _resolve_bgm_path(task_id, params, combined_video_path)
 
     # 获取优化的音量配置
     optimized_volumes = get_recommended_volumes_for_content('mixed')

app/services/test_indextts2_tts_unittest.py

@@ -0,0 +1,211 @@
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from app.services import voice
+
+
+class FakeResponse:
+    def __init__(self, *, status_code=200, content=b"", payload=None, content_type="application/json"):
+        self.status_code = status_code
+        self.content = content
+        self._payload = payload or {}
+        self.headers = {"content-type": content_type}
+        self.text = "OK"
+
+    def json(self):
+        return self._payload
+
+
+class IndexTTS2TtsTests(unittest.TestCase):
+    def setUp(self):
+        self.original_indextts2 = dict(voice.config.indextts2)
+        self.original_proxy = dict(voice.config.proxy)
+
+    def tearDown(self):
+        voice.config.indextts2.clear()
+        voice.config.indextts2.update(self.original_indextts2)
+        voice.config.proxy.clear()
+        voice.config.proxy.update(self.original_proxy)
+
+    def test_uploads_reference_audio_and_downloads_pack_output_url(self):
+        voice.config.indextts2.clear()
+        voice.config.indextts2.update(
+            {
+                "api_url": "http://127.0.0.1:7860",
+                "emotion": "happy:0.7,calm:0.3",
+                "emo_alpha": 0.6,
+                "speed": 1.15,
+                "seed": 20260713,
+                "max_mel_tokens": 1500,
+                "max_text_tokens_per_segment": 120,
+                "interval_silence": 200,
+                "temperature": 0.8,
+                "top_p": 0.8,
+                "top_k": 30,
+                "repetition_penalty": 10.0,
+                "diffusion_steps": 25,
+                "cfg_rate": 0.7,
+                "segment_overlap_ms": 50,
+            }
+        )
+        voice.config.proxy.clear()
+
+        generation_response = FakeResponse(
+            payload={"output": {"url": "/outputs/audio/speech.wav"}}
+        )
+        download_response = FakeResponse(content=b"wav-bytes", content_type="audio/wav")
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            reference_audio = Path(temp_dir) / "reference.wav"
+            output_file = Path(temp_dir) / "output.wav"
+            reference_audio.write_bytes(b"reference-wav")
+
+            with (
+                patch("app.services.voice.requests.post", return_value=generation_response) as post,
+                patch("app.services.voice.requests.get", return_value=download_response) as get,
+                patch("app.services.voice.get_audio_duration_from_file", return_value=1.25),
+            ):
+                result = voice.indextts2_tts(
+                    text="  新版接口测试。  ",
+                    voice_name=f"indextts2:{reference_audio}",
+                    voice_file=str(output_file),
+                )
+
+            output_bytes = output_file.read_bytes() if output_file.exists() else b""
+
+        self.assertIsNotNone(result)
+        self.assertEqual(output_bytes, b"wav-bytes")
+        self.assertEqual(
+            post.call_args.args[0],
+            "http://127.0.0.1:7860/v1/audio/speech/upload",
+        )
+        self.assertEqual(
+            post.call_args.kwargs["data"],
+            {
+                "text": "新版接口测试。",
+                "emotion": "happy:0.7,calm:0.3",
+                "emo_alpha": 0.6,
+                "speed": 1.15,
+                "seed": 20260713,
+                "max_mel_tokens": 1500,
+                "max_text_tokens_per_segment": 120,
+                "interval_silence": 200,
+                "temperature": 0.8,
+                "top_p": 0.8,
+                "top_k": 30,
+                "repetition_penalty": 10.0,
+                "diffusion_steps": 25,
+                "cfg_rate": 0.7,
+                "segment_overlap_ms": 50,
+            },
+        )
+        self.assertIn("reference_audio", post.call_args.kwargs["files"])
+        self.assertEqual(
+            get.call_args.args[0],
+            "http://127.0.0.1:7860/outputs/audio/speech.wav",
+        )
+
+    def test_maps_legacy_vector_settings_to_pack_emotion_and_endpoint(self):
+        voice.config.indextts2.clear()
+        voice.config.indextts2.update(
+            {
+                "api_url": "http://127.0.0.1:7860/tts",
+                "emotion_mode": "vector",
+                "emotion_alpha": 0.65,
+                "vec_happy": 0.3,
+                "vec_calm": 0.7,
+            }
+        )
+        voice.config.proxy.clear()
+
+        generation_response = FakeResponse(content=b"wav-bytes", content_type="audio/wav")
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            reference_audio = Path(temp_dir) / "reference.wav"
+            output_file = Path(temp_dir) / "output.wav"
+            reference_audio.write_bytes(b"reference-wav")
+
+            with (
+                patch("app.services.voice.requests.post", return_value=generation_response) as post,
+                patch("app.services.voice.get_audio_duration_from_file", return_value=1.0),
+            ):
+                result = voice.indextts2_tts(
+                    text="旧配置兼容测试。",
+                    voice_name=f"indextts2:{reference_audio}",
+                    voice_file=str(output_file),
+                )
+
+        self.assertIsNotNone(result)
+        self.assertEqual(
+            post.call_args.args[0],
+            "http://127.0.0.1:7860/v1/audio/speech/upload",
+        )
+        self.assertEqual(post.call_args.kwargs["data"]["emotion"], "happy:0.3,calm:0.7")
+        self.assertEqual(post.call_args.kwargs["data"]["emo_alpha"], 0.65)
+        self.assertNotIn("emotion_mode", post.call_args.kwargs["data"])
+        self.assertNotIn("vec_happy", post.call_args.kwargs["data"])
+
+    def test_normalizes_saved_values_to_pack_request_ranges(self):
+        voice.config.indextts2.clear()
+        voice.config.indextts2.update(
+            {
+                "api_url": "http://127.0.0.1:7860",
+                "emo_alpha": 2.0,
+                "speed": 0.1,
+                "max_mel_tokens": 50,
+                "max_text_tokens_per_segment": 1,
+                "interval_silence": -10,
+                "temperature": 0.0,
+                "top_p": 0.0,
+                "top_k": 0,
+                "repetition_penalty": 0.1,
+                "diffusion_steps": 0,
+                "cfg_rate": -1.0,
+                "segment_overlap_ms": -5,
+                "seed": "not-an-integer",
+            }
+        )
+        voice.config.proxy.clear()
+
+        generation_response = FakeResponse(content=b"wav-bytes", content_type="audio/wav")
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            reference_audio = Path(temp_dir) / "reference.wav"
+            output_file = Path(temp_dir) / "output.wav"
+            reference_audio.write_bytes(b"reference-wav")
+
+            with (
+                patch("app.services.voice.requests.post", return_value=generation_response) as post,
+                patch("app.services.voice.get_audio_duration_from_file", return_value=1.0),
+            ):
+                result = voice.indextts2_tts(
+                    text="参数范围测试。",
+                    voice_name=f"indextts2:{reference_audio}",
+                    voice_file=str(output_file),
+                )
+
+        self.assertIsNotNone(result)
+        self.assertEqual(
+            post.call_args.kwargs["data"],
+            {
+                "text": "参数范围测试。",
+                "emo_alpha": 1.0,
+                "speed": 0.5,
+                "max_mel_tokens": 64,
+                "max_text_tokens_per_segment": 20,
+                "interval_silence": 0,
+                "temperature": 0.05,
+                "top_p": 0.05,
+                "top_k": 1,
+                "repetition_penalty": 1.0,
+                "diffusion_steps": 1,
+                "cfg_rate": 0.0,
+                "segment_overlap_ms": 0,
+            },
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

app/services/test_indextts_macos_tts_unittest.py

@@ -0,0 +1,102 @@
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from app.services import voice
+
+
+class FakeResponse:
+    def __init__(self, *, status_code=200, content=b"", payload=None, content_type="application/json"):
+        self.status_code = status_code
+        self.content = content
+        self._payload = payload or {}
+        self.headers = {"content-type": content_type}
+        self.text = "OK"
+
+    def json(self):
+        return self._payload
+
+
+class IndexTTSMacOSTtsTests(unittest.TestCase):
+    def setUp(self):
+        self.original_config = dict(voice.config.indextts_macos)
+        self.original_proxy = dict(voice.config.proxy)
+
+    def tearDown(self):
+        voice.config.indextts_macos.clear()
+        voice.config.indextts_macos.update(self.original_config)
+        voice.config.proxy.clear()
+        voice.config.proxy.update(self.original_proxy)
+
+    def test_uploads_reference_audio_and_downloads_pack_output_url(self):
+        voice.config.indextts_macos.clear()
+        voice.config.indextts_macos.update(
+            {
+                "api_url": "http://127.0.0.1:7866",
+                "speed": 1.1,
+                "seed": 42,
+                "max_mel_tokens": 800,
+                "max_text_tokens_per_segment": 120,
+                "interval_silence": 200,
+                "temperature": 1.0,
+                "top_p": 0.8,
+                "top_k": 30,
+                "repetition_penalty": 10.0,
+                "segment_overlap_ms": 50,
+            }
+        )
+        voice.config.proxy.clear()
+
+        generation_response = FakeResponse(payload={"output_url": "/outputs/speech.wav"})
+        download_response = FakeResponse(content=b"wav-bytes", content_type="audio/wav")
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            reference_audio = Path(temp_dir) / "reference.wav"
+            output_file = Path(temp_dir) / "output.wav"
+            reference_audio.write_bytes(b"reference-wav")
+
+            with (
+                patch("app.services.voice.requests.post", return_value=generation_response) as post,
+                patch("app.services.voice.requests.get", return_value=download_response) as get,
+                patch("app.services.voice.get_audio_duration_from_file", return_value=1.25),
+            ):
+                result = voice.indextts_macos_tts(
+                    text="  macOS 接口测试。  ",
+                    voice_name=f"indextts_macos:{reference_audio}",
+                    voice_file=str(output_file),
+                )
+
+            output_bytes = output_file.read_bytes() if output_file.exists() else b""
+
+        self.assertIsNotNone(result)
+        self.assertEqual(output_bytes, b"wav-bytes")
+        self.assertEqual(
+            post.call_args.args[0],
+            "http://127.0.0.1:7866/v1/audio/speech/upload",
+        )
+        self.assertEqual(
+            post.call_args.kwargs["data"],
+            {
+                "text": "macOS 接口测试。",
+                "speed": 1.1,
+                "seed": 42,
+                "max_mel_tokens": 800,
+                "max_text_tokens_per_segment": 120,
+                "interval_silence": 200,
+                "temperature": 1.0,
+                "top_p": 0.8,
+                "top_k": 30,
+                "repetition_penalty": 10.0,
+                "segment_overlap_ms": 50,
+            },
+        )
+        self.assertIn("reference_audio", post.call_args.kwargs["files"])
+        self.assertEqual(
+            get.call_args.args[0],
+            "http://127.0.0.1:7866/outputs/speech.wav",
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

app/services/test_subtitle_corrector_unittest.py

@@ -27,6 +27,14 @@ class SubtitleCorrectorTests(unittest.TestCase):
         }
 
         with (
+            mock.patch.dict(
+                corrector.config.app,
+                {
+                    "text_openai_model_name": "reasoning-model",
+                    "text_openai_fast_model_name": "fast-subtitle-model",
+                },
+                clear=False,
+            ),
             mock.patch("app.services.subtitle_corrector._ensure_llm_providers_registered"),
             mock.patch(
                 "app.services.subtitle_corrector._run_async_safely",
@@ -49,6 +57,8 @@ class SubtitleCorrectorTests(unittest.TestCase):
         self.assertEqual("openai", call_kwargs["provider"])
         self.assertEqual("sk-test", call_kwargs["api_key"])
         self.assertEqual("https://llm.example/v1", call_kwargs["api_base"])
+        self.assertEqual("fast-subtitle-model", call_kwargs["model"])
+        self.assertEqual("off", call_kwargs["thinking_level"])
         self.assertEqual("json", call_kwargs["response_format"])
         self.assertIn("多语言字幕校对员", call_kwargs["system_prompt"])
         self.assertIn("保持原语言", call_kwargs["prompt"])

app/services/test_subtitle_translator_unittest.py

@@ -48,6 +48,14 @@ class SubtitleTranslatorTests(unittest.TestCase):
         }
 
         with (
+            mock.patch.dict(
+                translator.config.app,
+                {
+                    "text_openai_model_name": "reasoning-model",
+                    "text_openai_fast_model_name": "fast-subtitle-model",
+                },
+                clear=False,
+            ),
             mock.patch("app.services.subtitle_translator._ensure_llm_providers_registered"),
             mock.patch(
                 "app.services.subtitle_translator._run_async_safely",
@@ -71,6 +79,8 @@ class SubtitleTranslatorTests(unittest.TestCase):
         self.assertEqual("openai", call_kwargs["provider"])
         self.assertEqual("sk-test", call_kwargs["api_key"])
         self.assertEqual("https://llm.example/v1", call_kwargs["api_base"])
+        self.assertEqual("fast-subtitle-model", call_kwargs["model"])
+        self.assertEqual("off", call_kwargs["thinking_level"])
         self.assertEqual("json", call_kwargs["response_format"])
         self.assertIn("专业字幕翻译员", call_kwargs["system_prompt"])
         self.assertIn("翻译为中文", call_kwargs["prompt"])

app/services/test_voxcpm2_tts_unittest.py

@@ -0,0 +1,81 @@
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from app.services import voice
+
+
+class FakeResponse:
+    def __init__(self, *, status_code=200, content=b"", payload=None):
+        self.status_code = status_code
+        self.content = content
+        self._payload = payload or {}
+        self.text = "OK"
+
+    def json(self):
+        return self._payload
+
+
+class VoxCPM2TtsTests(unittest.TestCase):
+    def setUp(self):
+        self.original_config = dict(voice.config.voxcpm_2b)
+        self.original_proxy = dict(voice.config.proxy)
+
+    def tearDown(self):
+        voice.config.voxcpm_2b.clear()
+        voice.config.voxcpm_2b.update(self.original_config)
+        voice.config.proxy.clear()
+        voice.config.proxy.update(self.original_proxy)
+
+    def test_voice_design_sends_control_and_downloads_wav(self):
+        voice.config.voxcpm_2b.clear()
+        voice.config.voxcpm_2b.update({
+            "api_url": "http://127.0.0.1:7863/v1/audio/speech",
+            "mode": "design", "control": "温暖自然的年轻女声",
+            "cfg_value": 2.0, "inference_timesteps": 10,
+            "normalize": True, "denoise": False, "output_48k": True,
+            "context_aware": True, "streaming": False,
+        })
+        voice.config.proxy.clear()
+        with tempfile.TemporaryDirectory() as temp_dir:
+            output = Path(temp_dir) / "output.wav"
+            with (
+                patch("app.services.voice.requests.post", return_value=FakeResponse(payload={"downloads": {"wav": "/download/result.wav"}})) as post,
+                patch("app.services.voice.requests.get", return_value=FakeResponse(content=b"wav-2b")) as get,
+                patch("app.services.voice.get_audio_duration_from_file", return_value=2.0),
+            ):
+                result = voice.voxcpm2_tts("  高质量旁白。 ", "voxcpm_2b:design", str(output))
+            self.assertIsNotNone(result)
+            self.assertEqual(output.read_bytes(), b"wav-2b")
+            self.assertEqual(post.call_args.args[0], "http://127.0.0.1:7863/tts")
+            self.assertIsNone(post.call_args.kwargs["files"])
+            self.assertEqual(post.call_args.kwargs["data"]["control"], "温暖自然的年轻女声")
+            self.assertEqual(post.call_args.kwargs["data"]["output_48k"], "true")
+            self.assertEqual(get.call_args.args[0], "http://127.0.0.1:7863/download/result.wav")
+
+    def test_clone_uploads_reference_audio(self):
+        voice.config.voxcpm_2b.clear()
+        voice.config.voxcpm_2b.update({
+            "api_url": "http://127.0.0.1:7863/tts/batch",
+            "mode": "clone", "prompt_text": "参考音频文本",
+        })
+        voice.config.proxy.clear()
+        with tempfile.TemporaryDirectory() as temp_dir:
+            reference = Path(temp_dir) / "reference.wav"
+            output = Path(temp_dir) / "output.wav"
+            reference.write_bytes(b"reference")
+            with (
+                patch("app.services.voice.requests.post", return_value=FakeResponse(payload={"downloads": {"wav": "/download/result.wav"}})) as post,
+                patch("app.services.voice.requests.get", return_value=FakeResponse(content=b"wav")),
+                patch("app.services.voice.get_audio_duration_from_file", return_value=1.0),
+            ):
+                result = voice.voxcpm2_tts("克隆测试", f"voxcpm_2b:{reference}", str(output))
+        self.assertIsNotNone(result)
+        self.assertEqual(post.call_args.args[0], "http://127.0.0.1:7863/tts")
+        self.assertIn("reference_audio", post.call_args.kwargs["files"])
+        self.assertEqual(post.call_args.kwargs["data"]["prompt_text"], "参考音频文本")
+
+
+if __name__ == "__main__":
+    unittest.main()

app/services/test_voxcpm_tts_unittest.py

@@ -0,0 +1,83 @@
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from app.services import voice
+
+
+class FakeResponse:
+    def __init__(self, *, status_code=200, content=b"", payload=None):
+        self.status_code = status_code
+        self.content = content
+        self._payload = payload or {}
+        self.text = "OK"
+
+    def json(self):
+        return self._payload
+
+
+class VoxCPMTtsTests(unittest.TestCase):
+    def setUp(self):
+        self.original_config = dict(voice.config.voxcpm_05b)
+        self.original_proxy = dict(voice.config.proxy)
+
+    def tearDown(self):
+        voice.config.voxcpm_05b.clear()
+        voice.config.voxcpm_05b.update(self.original_config)
+        voice.config.proxy.clear()
+        voice.config.proxy.update(self.original_proxy)
+
+    def test_uploads_prompt_audio_and_downloads_generated_wav(self):
+        voice.config.voxcpm_05b.clear()
+        voice.config.voxcpm_05b.update({
+            "api_url": "http://127.0.0.1:7864/v1/audio/speech",
+            "prompt_text": "参考文本",
+            "cfg_value": 2.1,
+            "inference_timesteps": 12,
+            "max_length": 2048,
+            "normalize": True,
+            "denoise": False,
+        })
+        voice.config.proxy.clear()
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            reference = Path(temp_dir) / "reference.wav"
+            output = Path(temp_dir) / "output.wav"
+            reference.write_bytes(b"reference")
+            with (
+                patch("app.services.voice.requests.post", return_value=FakeResponse(payload={"audio_url": "/outputs/result.wav"})) as post,
+                patch("app.services.voice.requests.get", return_value=FakeResponse(content=b"wav-bytes")) as get,
+                patch("app.services.voice.get_audio_duration_from_file", return_value=1.5),
+            ):
+                result = voice.voxcpm_tts("  测试文本。  ", f"voxcpm_05b:{reference}", str(output))
+
+            self.assertIsNotNone(result)
+            self.assertEqual(output.read_bytes(), b"wav-bytes")
+            self.assertEqual(post.call_args.args[0], "http://127.0.0.1:7864/tts")
+            self.assertEqual(post.call_args.kwargs["data"], {
+                "text": "测试文本。", "prompt_text": "参考文本", "cfg_value": 2.1,
+                "inference_timesteps": 12, "max_length": 2048,
+                "normalize": "true", "denoise": "false",
+            })
+            self.assertIn("prompt_audio", post.call_args.kwargs["files"])
+            self.assertEqual(get.call_args.args[0], "http://127.0.0.1:7864/outputs/result.wav")
+
+    def test_default_voice_does_not_upload_audio(self):
+        voice.config.voxcpm_05b.clear()
+        voice.config.voxcpm_05b.update({"api_url": "http://127.0.0.1:7864"})
+        voice.config.proxy.clear()
+        with tempfile.TemporaryDirectory() as temp_dir:
+            output = Path(temp_dir) / "output.wav"
+            with (
+                patch("app.services.voice.requests.post", return_value=FakeResponse(payload={"audio_url": "/outputs/result.wav"})) as post,
+                patch("app.services.voice.requests.get", return_value=FakeResponse(content=b"wav")),
+                patch("app.services.voice.get_audio_duration_from_file", return_value=1.0),
+            ):
+                result = voice.voxcpm_tts("默认音色", "voxcpm_05b:default", str(output))
+        self.assertIsNotNone(result)
+        self.assertIsNone(post.call_args.kwargs["files"])
+
+
+if __name__ == "__main__":
+    unittest.main()

app/services/voice.py

@@ -1302,6 +1302,10 @@ def tts(
         logger.info("分发到 IndexTTS-1.5")
         return indextts_tts(text, voice_name, voice_file, speed=voice_rate)
 
+    if tts_engine == config.INDEXTTS_MACOS_ENGINE:
+        logger.info("分发到 IndexTTS-1.5-macOS")
+        return indextts_macos_tts(text, voice_name, voice_file)
+
     if tts_engine == config.INDEXTTS2_ENGINE:
         logger.info("分发到 IndexTTS-2")
         return indextts2_tts(text, voice_name, voice_file)
@@ -1310,6 +1314,14 @@ def tts(
         logger.info("分发到 OmniVoice")
         return omnivoice_tts(text, voice_name, voice_file, speed=voice_rate)
 
+    if tts_engine == config.VOXCPM_ENGINE:
+        logger.info("分发到 VoxCPM-0.5B")
+        return voxcpm_tts(text, voice_name, voice_file)
+
+    if tts_engine == config.VOXCPM2_ENGINE:
+        logger.info("分发到 VoxCPM-2B")
+        return voxcpm2_tts(text, voice_name, voice_file)
+    
     if tts_engine == "doubaotts":
         logger.info("分发到豆包语音 TTS")
         return doubaotts_tts(text, voice_name, voice_file, speed=voice_rate)
@@ -1796,8 +1808,11 @@ def tts_multiple(task_id: str, list_script: list, voice_name: str, voice_rate: f
     tts_results = []
     audio_extension = ".wav" if tts_engine in (
         config.INDEXTTS_ENGINE,
+        config.INDEXTTS_MACOS_ENGINE,
         config.INDEXTTS2_ENGINE,
         config.OMNIVOICE_ENGINE,
+        config.VOXCPM_ENGINE,
+        config.VOXCPM2_ENGINE,
     ) else ".mp3"
 
     for item in list_script:
@@ -1828,7 +1843,14 @@ def tts_multiple(task_id: str, list_script: list, voice_name: str, voice_rate: f
                 if (
                     is_soulvoice_voice(voice_name)
                     or is_qwen_engine(tts_engine)
-                    or tts_engine in (config.INDEXTTS_ENGINE, config.INDEXTTS2_ENGINE, config.OMNIVOICE_ENGINE)
+                    or tts_engine in (
+                        config.INDEXTTS_ENGINE,
+                        config.INDEXTTS_MACOS_ENGINE,
+                        config.INDEXTTS2_ENGINE,
+                        config.OMNIVOICE_ENGINE,
+                        config.VOXCPM_ENGINE,
+                        config.VOXCPM2_ENGINE,
+                    )
                     or tts_engine == "doubaotts"
                 ):
                     # 获取实际音频文件的时长
@@ -2271,6 +2293,13 @@ def parse_indextts2_voice(voice_name: str) -> str:
     return voice_name
 
 
+def parse_indextts_macos_voice(voice_name: str) -> str:
+    """解析 IndexTTS-1.5-macOS 参考音频路径。"""
+    if isinstance(voice_name, str) and voice_name.startswith(config.INDEXTTS_MACOS_VOICE_PREFIX):
+        return voice_name[len(config.INDEXTTS_MACOS_VOICE_PREFIX):]
+    return voice_name
+
+
 def parse_omnivoice_voice(voice_name: str) -> str:
     """
     解析 OmniVoice 语音名称
@@ -2282,6 +2311,20 @@ def parse_omnivoice_voice(voice_name: str) -> str:
     return voice_name
 
 
+def parse_voxcpm_voice(voice_name: str) -> str:
+    """解析 VoxCPM-0.5B 的可选参考音频路径。"""
+    if isinstance(voice_name, str) and voice_name.startswith(config.VOXCPM_VOICE_PREFIX):
+        return voice_name[len(config.VOXCPM_VOICE_PREFIX):]
+    return voice_name
+
+
+def parse_voxcpm2_voice(voice_name: str) -> str:
+    """解析 VoxCPM-2B 的模式或参考音频路径。"""
+    if isinstance(voice_name, str) and voice_name.startswith(config.VOXCPM2_VOICE_PREFIX):
+        return voice_name[len(config.VOXCPM2_VOICE_PREFIX):]
+    return voice_name
+
+
 def indextts_tts(text: str, voice_name: str, voice_file: str, speed: float = 1.0) -> Union[SubMaker, None]:
     """
     使用 IndexTTS-1.5 API 进行零样本语音克隆
@@ -2395,10 +2438,166 @@ def indextts_tts(text: str, voice_name: str, voice_file: str, speed: float = 1.0
 
 
 def _normalize_indextts2_api_url(api_url: str) -> str:
-    api_url = (api_url or "http://192.168.3.6:7863/tts").strip()
+    """Return the IndexTTS-2 MLX Pack upload endpoint for a configured URL.
-    if api_url.endswith("/tts"):
+
+    The Pack accepts a server root, the JSON speech endpoint, or the multipart
+    upload endpoint.  Treat an old ``/tts`` value as a server root so existing
+    saved settings move to the new Pack route instead of continuing to 404.
+    """
+    api_url = (api_url or "http://127.0.0.1:7860").strip().rstrip("/")
+    upload_path = "/v1/audio/speech/upload"
+    speech_path = "/v1/audio/speech"
+
+    if api_url.endswith(upload_path):
         return api_url
-    return f"{api_url.rstrip('/')}/tts"
+    if api_url.endswith(speech_path):
+        return f"{api_url}/upload"
+    if api_url.endswith("/tts"):
+        api_url = api_url[: -len("/tts")]
+    return f"{api_url}{upload_path}"
+
+
+def _normalize_indextts_macos_api_url(api_url: str) -> str:
+    """Return the IndexTTS 1.5 MLX Pack multipart upload endpoint."""
+    api_url = (api_url or "http://127.0.0.1:7866").strip().rstrip("/")
+    upload_path = "/v1/audio/speech/upload"
+    speech_path = "/v1/audio/speech"
+    if api_url.endswith(upload_path):
+        return api_url
+    if api_url.endswith(speech_path):
+        return f"{api_url}/upload"
+    return f"{api_url}{upload_path}"
+
+
+def _get_indextts_macos_number(
+    key: str,
+    default: float | int,
+    minimum: float | int,
+    maximum: float | int,
+    *,
+    integer: bool = False,
+) -> float | int:
+    try:
+        raw_value = config.indextts_macos.get(key, default)
+        value = int(float(raw_value)) if integer else float(raw_value)
+    except (TypeError, ValueError):
+        value = default
+    return max(minimum, min(maximum, value))
+
+
+def _get_indextts_macos_seed() -> int | None:
+    seed = config.indextts_macos.get("seed")
+    if seed in (None, ""):
+        return None
+    try:
+        return int(seed)
+    except (TypeError, ValueError):
+        logger.warning("IndexTTS-1.5-macOS 随机种子无效，将使用随机采样: {}", seed)
+        return None
+
+
+def _download_indextts_macos_audio(
+    response: requests.Response,
+    api_url: str,
+    voice_file: str,
+    proxies: dict,
+) -> bool:
+    try:
+        result = response.json()
+    except ValueError:
+        logger.error("IndexTTS-1.5-macOS API 返回了无效的 JSON 响应")
+        return False
+
+    download_url = result.get("output_url") if isinstance(result, dict) else ""
+    if not download_url:
+        logger.error(f"IndexTTS-1.5-macOS API 响应中没有音频下载地址: {result}")
+        return False
+
+    audio_response = requests.get(
+        urljoin(api_url, download_url),
+        proxies=proxies,
+        timeout=120,
+    )
+    if audio_response.status_code != 200:
+        logger.error(
+            f"IndexTTS-1.5-macOS 音频下载失败: "
+            f"{audio_response.status_code} - {audio_response.text}"
+        )
+        return False
+
+    with open(voice_file, "wb") as f:
+        f.write(audio_response.content)
+    return os.path.getsize(voice_file) > 0
+
+
+def indextts_macos_tts(text: str, voice_name: str, voice_file: str) -> Union[SubMaker, None]:
+    """使用 IndexTTS-MLX-1.5-Pack 的上传接口进行零样本语音克隆。"""
+    api_url = _normalize_indextts_macos_api_url(
+        config.indextts_macos.get("api_url", "http://127.0.0.1:7866")
+    )
+    reference_audio_path = parse_indextts_macos_voice(voice_name)
+    if not reference_audio_path or not os.path.exists(reference_audio_path):
+        logger.error(f"IndexTTS-1.5-macOS 参考音频文件不存在: {reference_audio_path}")
+        return None
+
+    data = {
+        "text": text.strip(),
+        "speed": _get_indextts_macos_number("speed", 1.0, 0.5, 2.0),
+        "max_mel_tokens": _get_indextts_macos_number(
+            "max_mel_tokens", 800, 64, 1600, integer=True
+        ),
+        "max_text_tokens_per_segment": _get_indextts_macos_number(
+            "max_text_tokens_per_segment", 120, 20, 600, integer=True
+        ),
+        "interval_silence": _get_indextts_macos_number(
+            "interval_silence", 200, 0, 2000, integer=True
+        ),
+        "temperature": _get_indextts_macos_number("temperature", 1.0, 0.0, 2.0),
+        "top_p": _get_indextts_macos_number("top_p", 0.8, 0.05, 1.0),
+        "top_k": _get_indextts_macos_number("top_k", 30, 0, 200, integer=True),
+        "repetition_penalty": _get_indextts_macos_number(
+            "repetition_penalty", 10.0, 1.0, 20.0
+        ),
+        "segment_overlap_ms": _get_indextts_macos_number(
+            "segment_overlap_ms", 50, 0, 500, integer=True
+        ),
+    }
+    seed = _get_indextts_macos_seed()
+    if seed is not None:
+        data["seed"] = seed
+
+    proxies = _get_configured_proxies()
+    for attempt in range(3):
+        try:
+            with open(reference_audio_path, "rb") as reference_audio:
+                logger.info(f"第 {attempt + 1} 次调用 IndexTTS-1.5-macOS API: {api_url}")
+                response = requests.post(
+                    api_url,
+                    files={"reference_audio": reference_audio},
+                    data=data,
+                    proxies=proxies,
+                    timeout=600,
+                )
+            if response.status_code == 200 and _download_indextts_macos_audio(
+                response, api_url, voice_file, proxies
+            ):
+                sub_maker = new_sub_maker()
+                duration = get_audio_duration_from_file(voice_file)
+                duration_ms = int(duration * 1000) if duration > 0 else max(1000, int(len(text) * 200))
+                add_subtitle_event(sub_maker, 0, duration_ms * 10000, text)
+                return sub_maker
+            logger.error(
+                f"IndexTTS-1.5-macOS API 调用失败: {response.status_code} - {response.text}"
+            )
+        except requests.exceptions.Timeout:
+            logger.error(f"IndexTTS-1.5-macOS API 调用超时 (尝试 {attempt + 1}/3)")
+        except requests.exceptions.RequestException as e:
+            logger.error(f"IndexTTS-1.5-macOS API 网络错误: {str(e)} (尝试 {attempt + 1}/3)")
+        except Exception as e:
+            logger.error(f"IndexTTS-1.5-macOS TTS 处理错误: {str(e)} (尝试 {attempt + 1}/3)")
+        if attempt < 2:
+            time.sleep(2)
+    return None
 
 
 def _get_configured_proxies() -> dict:
@@ -2410,6 +2609,49 @@ def _get_configured_proxies() -> dict:
     }
 
 
+def _get_indextts2_number(
+    key: str,
+    default: float | int,
+    minimum: float | int,
+    maximum: float | int,
+    *,
+    integer: bool = False,
+) -> float | int:
+    """Read an IndexTTS-2 option and constrain it to the MLX Pack schema."""
+    try:
+        raw_value = config.indextts2.get(key, default)
+        value = int(float(raw_value)) if integer else float(raw_value)
+    except (TypeError, ValueError):
+        value = default
+    return max(minimum, min(maximum, value))
+
+
+def _get_indextts2_seed() -> int | None:
+    """Return the optional Pack seed, omitting invalid legacy text values."""
+    seed = config.indextts2.get("seed")
+    if seed in (None, ""):
+        return None
+    try:
+        return int(seed)
+    except (TypeError, ValueError):
+        logger.warning("IndexTTS-2 随机种子无效，将使用随机采样: {}", seed)
+        return None
+
+
+def _get_indextts2_emotion() -> str:
+    """Map current and legacy IndexTTS-2 emotion settings to the MLX Pack API."""
+    emotion = config.get_indextts2_pack_emotion(config.indextts2)
+    if emotion:
+        return emotion
+
+    emotion_mode = config.indextts2.get("emotion_mode", "speaker")
+    if emotion_mode == "audio" and config.indextts2.get("emotion_audio"):
+        logger.warning(
+            "IndexTTS-2 MLX Pack 不支持单独的情感参考音频，将使用音色参考音频的情感。"
+        )
+    return ""
+
+
 def _download_indextts2_audio(response: requests.Response, api_url: str, voice_file: str, proxies: dict) -> bool:
     content_type = response.headers.get("content-type", "").lower()
     if "application/json" not in content_type:
@@ -2417,9 +2659,14 @@ def _download_indextts2_audio(response: requests.Response, api_url: str, voice_f
             f.write(response.content)
         return os.path.getsize(voice_file) > 0
 
+    try:
         result = response.json()
-    downloads = result.get("downloads") if isinstance(result, dict) else {}
+    except ValueError:
-    download_url = downloads.get("wav") if isinstance(downloads, dict) else ""
+        logger.error("IndexTTS-2 API 返回了无效的 JSON 响应")
+        return False
+
+    output = result.get("output") if isinstance(result, dict) else {}
+    download_url = output.get("url") if isinstance(output, dict) else ""
     if not download_url:
         logger.error(f"IndexTTS-2 API 响应中没有音频下载地址: {result}")
         return False
@@ -2437,56 +2684,62 @@ def _download_indextts2_audio(response: requests.Response, api_url: str, voice_f
 
 def indextts2_tts(text: str, voice_name: str, voice_file: str) -> Union[SubMaker, None]:
     """
-    使用 IndexTTS-2 API 进行零样本语音克隆。
+    使用 IndexTTS-2 MLX Pack API 进行零样本语音克隆。
-    接口兼容 IndexTTS2-Pack 的 POST /tts multipart form。
+
+    参考音频通过 ``POST /v1/audio/speech/upload`` 上传，这样 Pack 即使
+    运行在另一台机器上，也不需要访问 NarratoAI 的本地文件路径。
     """
-    api_url = _normalize_indextts2_api_url(config.indextts2.get("api_url", "http://192.168.3.6:7863/tts"))
+    api_url = _normalize_indextts2_api_url(config.indextts2.get("api_url", "http://127.0.0.1:7860"))
     reference_audio_path = parse_indextts2_voice(voice_name)
 
     if not reference_audio_path or not os.path.exists(reference_audio_path):
         logger.error(f"IndexTTS-2 参考音频文件不存在: {reference_audio_path}")
         return None
 
-    emotion_mode = config.indextts2.get("emotion_mode", "speaker")
-    emotion_audio_path = config.indextts2.get("emotion_audio", "")
     data = {
         "text": text.strip(),
-        "emotion_mode": emotion_mode,
+        "emo_alpha": _get_indextts2_number(
-        "emotion_alpha": config.indextts2.get("emotion_alpha", 0.65),
+            "emo_alpha", config.indextts2.get("emotion_alpha", 0.6), 0.0, 1.0
-        "emotion_text": config.indextts2.get("emotion_text", ""),
+        ),
-        "use_random": str(bool(config.indextts2.get("use_random", False))).lower(),
+        "speed": _get_indextts2_number("speed", 1.0, 0.5, 2.0),
-        "max_text_tokens_per_segment": config.indextts2.get("max_text_tokens_per_segment", 120),
+        "max_mel_tokens": _get_indextts2_number(
-        "vec_happy": config.indextts2.get("vec_happy", 0.0),
+            "max_mel_tokens", 1500, 64, 1815, integer=True
-        "vec_angry": config.indextts2.get("vec_angry", 0.0),
+        ),
-        "vec_sad": config.indextts2.get("vec_sad", 0.0),
+        "max_text_tokens_per_segment": _get_indextts2_number(
-        "vec_afraid": config.indextts2.get("vec_afraid", 0.0),
+            "max_text_tokens_per_segment", 120, 20, 600, integer=True
-        "vec_disgusted": config.indextts2.get("vec_disgusted", 0.0),
+        ),
-        "vec_melancholic": config.indextts2.get("vec_melancholic", 0.0),
+        "interval_silence": _get_indextts2_number(
-        "vec_surprised": config.indextts2.get("vec_surprised", 0.0),
+            "interval_silence", 200, 0, 5000, integer=True
-        "vec_calm": config.indextts2.get("vec_calm", 0.8),
+        ),
-        "temperature": config.indextts2.get("temperature", 0.8),
+        "temperature": _get_indextts2_number("temperature", 0.8, 0.05, 2.0),
-        "top_p": config.indextts2.get("top_p", 0.8),
+        "top_p": _get_indextts2_number("top_p", 0.8, 0.05, 1.0),
-        "top_k": config.indextts2.get("top_k", 30),
+        "top_k": _get_indextts2_number("top_k", 30, 1, 200, integer=True),
-        "num_beams": config.indextts2.get("num_beams", 3),
+        "repetition_penalty": _get_indextts2_number(
-        "repetition_penalty": config.indextts2.get("repetition_penalty", 10.0),
+            "repetition_penalty", 10.0, 1.0, 30.0
-        "max_mel_tokens": config.indextts2.get("max_mel_tokens", 1500),
+        ),
+        "diffusion_steps": _get_indextts2_number(
+            "diffusion_steps", 25, 1, 100, integer=True
+        ),
+        "cfg_rate": _get_indextts2_number("cfg_rate", 0.7, 0.0, 2.0),
+        "segment_overlap_ms": _get_indextts2_number(
+            "segment_overlap_ms", 50, 0, 1000, integer=True
+        ),
     }
+    emotion = _get_indextts2_emotion()
+    if emotion:
+        data["emotion"] = emotion
+    seed = _get_indextts2_seed()
+    if seed is not None:
+        data["seed"] = seed
 
     proxies = _get_configured_proxies()
     for attempt in range(3):
-        files = {}
         try:
-            files["speaker_audio"] = open(reference_audio_path, "rb")
+            with open(reference_audio_path, "rb") as reference_audio:
-            if emotion_mode == "audio":
-                if not emotion_audio_path or not os.path.exists(emotion_audio_path):
-                    logger.error(f"IndexTTS-2 情感参考音频文件不存在: {emotion_audio_path}")
-                    return None
-                files["emotion_audio"] = open(emotion_audio_path, "rb")
-
                 logger.info(f"第 {attempt + 1} 次调用 IndexTTS-2 API: {api_url}")
                 response = requests.post(
                     api_url,
-                files=files,
+                    files={"reference_audio": reference_audio},
                     data=data,
                     proxies=proxies,
                     timeout=180,
@@ -2507,12 +2760,6 @@ def indextts2_tts(text: str, voice_name: str, voice_file: str) -> Union[SubMaker
             logger.error(f"IndexTTS-2 API 网络错误: {str(e)} (尝试 {attempt + 1}/3)")
         except Exception as e:
             logger.error(f"IndexTTS-2 TTS 处理错误: {str(e)} (尝试 {attempt + 1}/3)")
-        finally:
-            for file_obj in files.values():
-                try:
-                    file_obj.close()
-                except Exception:
-                    pass
 
         if attempt < 2:
             time.sleep(2)
@@ -2521,6 +2768,144 @@ def indextts2_tts(text: str, voice_name: str, voice_file: str) -> Union[SubMaker
     return None
 
 
+def _normalize_voxcpm_api_url(api_url: str) -> str:
+    api_url = (api_url or "http://127.0.0.1:7864").strip().rstrip("/")
+    if api_url.endswith("/v1/audio/speech"):
+        api_url = api_url[:-len("/v1/audio/speech")]
+    if api_url.endswith("/tts"):
+        return api_url
+    return f"{api_url}/tts"
+
+
+def voxcpm_tts(text: str, voice_name: str, voice_file: str) -> Union[SubMaker, None]:
+    """使用 VoxCPM-0.5B-Pack 的 multipart /tts 接口生成 WAV。"""
+    voxcpm_config = getattr(config, "voxcpm_05b", {}) or {}
+    api_url = _normalize_voxcpm_api_url(voxcpm_config.get("api_url", "http://127.0.0.1:7864"))
+    reference_audio = parse_voxcpm_voice(voice_name)
+    if reference_audio in ("", "default") or not os.path.isfile(reference_audio):
+        reference_audio = voxcpm_config.get("reference_audio", "") or ""
+    if reference_audio and not os.path.isfile(reference_audio):
+        logger.error(f"VoxCPM-0.5B 参考音频文件不存在: {reference_audio}")
+        return None
+
+    data = {"text": text.strip()}
+    optional_fields = {
+        "prompt_text": voxcpm_config.get("prompt_text"),
+        "cfg_value": voxcpm_config.get("cfg_value"),
+        "inference_timesteps": voxcpm_config.get("inference_timesteps"),
+        "max_length": voxcpm_config.get("max_length"),
+    }
+    for key, value in optional_fields.items():
+        if value not in (None, ""):
+            data[key] = value
+    for key in ("normalize", "denoise"):
+        if key in voxcpm_config:
+            data[key] = str(bool(voxcpm_config[key])).lower()
+
+    proxies = _get_configured_proxies()
+    for attempt in range(3):
+        files = {}
+        try:
+            if reference_audio:
+                files["prompt_audio"] = open(reference_audio, "rb")
+            response = requests.post(api_url, data=data, files=files or None, proxies=proxies, timeout=300)
+            if response.status_code == 200:
+                result = response.json()
+                audio_url = result.get("audio_url", "") if isinstance(result, dict) else ""
+                if audio_url:
+                    audio_response = requests.get(urljoin(api_url, audio_url), proxies=proxies, timeout=180)
+                    if audio_response.status_code == 200:
+                        with open(voice_file, "wb") as output:
+                            output.write(audio_response.content)
+                        if os.path.getsize(voice_file) > 0:
+                            sub_maker = new_sub_maker()
+                            duration = get_audio_duration_from_file(voice_file)
+                            duration_ms = int(duration * 1000) if duration > 0 else max(1000, len(text) * 200)
+                            add_subtitle_event(sub_maker, 0, duration_ms * 10000, text)
+                            return sub_maker
+                logger.error(f"VoxCPM-0.5B API 响应中没有有效音频地址: {result}")
+            else:
+                logger.error(f"VoxCPM-0.5B API 调用失败: {response.status_code} - {response.text}")
+        except (ValueError, requests.exceptions.RequestException) as exc:
+            logger.error(f"VoxCPM-0.5B TTS 请求失败 (尝试 {attempt + 1}/3): {exc}")
+        finally:
+            for file_obj in files.values():
+                file_obj.close()
+        if attempt < 2:
+            time.sleep(2)
+    return None
+
+
+def _normalize_voxcpm2_api_url(api_url: str) -> str:
+    api_url = (api_url or "http://127.0.0.1:7863").strip().rstrip("/")
+    for suffix in ("/v1/audio/speech", "/tts/batch"):
+        if api_url.endswith(suffix):
+            api_url = api_url[:-len(suffix)]
+    return api_url if api_url.endswith("/tts") else f"{api_url}/tts"
+
+
+def voxcpm2_tts(text: str, voice_name: str, voice_file: str) -> Union[SubMaker, None]:
+    """使用 VoxCPM-2B-Pack 的 /tts 接口进行音色设计或参考音频克隆。"""
+    pack_config = getattr(config, "voxcpm_2b", {}) or {}
+    api_url = _normalize_voxcpm2_api_url(pack_config.get("api_url", "http://127.0.0.1:7863"))
+    mode = str(pack_config.get("mode", "design"))
+    parsed_voice = parse_voxcpm2_voice(voice_name)
+    reference_audio = ""
+    if mode == "clone":
+        reference_audio = parsed_voice if parsed_voice and os.path.isfile(parsed_voice) else pack_config.get("reference_audio", "")
+        if not reference_audio or not os.path.isfile(reference_audio):
+            logger.error(f"VoxCPM-2B 参考音频文件不存在: {reference_audio}")
+            return None
+
+    data = {"text": text.strip()}
+    optional_fields = {
+        "control": pack_config.get("control"),
+        "prompt_text": pack_config.get("prompt_text") if mode == "clone" else None,
+        "cfg_value": pack_config.get("cfg_value"),
+        "inference_timesteps": pack_config.get("inference_timesteps"),
+    }
+    for key, value in optional_fields.items():
+        if value not in (None, ""):
+            data[key] = value
+    for key in ("normalize", "denoise", "output_48k", "context_aware", "streaming"):
+        if key in pack_config:
+            data[key] = str(bool(pack_config[key])).lower()
+
+    proxies = _get_configured_proxies()
+    for attempt in range(3):
+        files = {}
+        try:
+            if reference_audio:
+                files["reference_audio"] = open(reference_audio, "rb")
+            response = requests.post(api_url, data=data, files=files or None, proxies=proxies, timeout=600)
+            if response.status_code == 200:
+                result = response.json()
+                downloads = result.get("downloads", {}) if isinstance(result, dict) else {}
+                audio_url = downloads.get("wav", "") if isinstance(downloads, dict) else ""
+                if audio_url:
+                    audio_response = requests.get(urljoin(api_url, audio_url), proxies=proxies, timeout=180)
+                    if audio_response.status_code == 200:
+                        with open(voice_file, "wb") as output:
+                            output.write(audio_response.content)
+                        if os.path.getsize(voice_file) > 0:
+                            sub_maker = new_sub_maker()
+                            duration = get_audio_duration_from_file(voice_file)
+                            duration_ms = int(duration * 1000) if duration > 0 else max(1000, len(text) * 200)
+                            add_subtitle_event(sub_maker, 0, duration_ms * 10000, text)
+                            return sub_maker
+                logger.error(f"VoxCPM-2B API 响应中没有有效 WAV 下载地址: {result}")
+            else:
+                logger.error(f"VoxCPM-2B API 调用失败: {response.status_code} - {response.text}")
+        except (ValueError, requests.exceptions.RequestException) as exc:
+            logger.error(f"VoxCPM-2B TTS 请求失败 (尝试 {attempt + 1}/3): {exc}")
+        finally:
+            for file_obj in files.values():
+                file_obj.close()
+        if attempt < 2:
+            time.sleep(2)
+    return None
+
+
 def _normalize_omnivoice_api_url(api_url: str) -> str:
     api_url = (api_url or "http://127.0.0.1:7866/tts").strip()
     if api_url.endswith("/tts"):

app/utils/openai_base_url_security.py

@@ -0,0 +1,111 @@
+import ipaddress
+from typing import Optional
+from urllib.parse import urlparse
+
+
+TRUSTED_OPENAI_COMPATIBLE_BASE_HOSTS = {
+    "api.openai.com",
+    "openrouter.ai",
+    "api.siliconflow.cn",
+    "dashscope.aliyuncs.com",
+    "api.deepseek.com",
+    "api.moonshot.cn",
+    "api.together.xyz",
+    "api.cohere.ai",
+    "generativelanguage.googleapis.com",
+    "open.bigmodel.cn",
+    "api.z.ai",
+    "ark.cn-beijing.volces.com",
+    "ark.cn-shanghai.volces.com",
+}
+
+TRUSTED_OPENAI_COMPATIBLE_BASE_SUFFIXES = (
+    ".openai.azure.com",
+    ".services.ai.azure.com",
+    ".cognitiveservices.azure.com",
+)
+
+OPENAI_COMPATIBLE_BASE_URL_ERROR = (
+    "OpenAI-compatible base_url must be a valid http(s) URL without embedded credentials."
+)
+
+OPENAI_COMPATIBLE_BASE_URL_WARNING = (
+    "OpenAI-compatible base_url host '{host}' is not in the trusted provider list. "
+    "Only continue if you trust this endpoint, because it will receive the configured API key."
+)
+
+
+def _is_loopback_ollama_url(scheme: str, host: str, port: Optional[int]) -> bool:
+    if scheme not in {"http", "https"} or port != 11434:
+        return False
+    if host == "localhost":
+        return True
+    try:
+        return ipaddress.ip_address(host).is_loopback
+    except ValueError:
+        return False
+
+
+def _is_well_formed_http_base_url(base_url: str) -> bool:
+    parsed = urlparse(str(base_url).strip())
+    if parsed.scheme not in {"http", "https"} or not parsed.hostname:
+        return False
+    if parsed.username or parsed.password:
+        return False
+    try:
+        parsed.port
+    except ValueError:
+        return False
+    return True
+
+
+def is_trusted_openai_compatible_base_url(base_url: Optional[str]) -> bool:
+    if not base_url:
+        return True
+
+    parsed = urlparse(str(base_url).strip())
+    host = (parsed.hostname or "").rstrip(".").lower()
+    if not parsed.scheme or not host or parsed.username or parsed.password:
+        return False
+
+    try:
+        port = parsed.port
+    except ValueError:
+        return False
+
+    if _is_loopback_ollama_url(parsed.scheme, host, port):
+        return True
+
+    if parsed.scheme != "https":
+        return False
+
+    if host in TRUSTED_OPENAI_COMPATIBLE_BASE_HOSTS:
+        return True
+
+    return any(host.endswith(suffix) for suffix in TRUSTED_OPENAI_COMPATIBLE_BASE_SUFFIXES)
+
+
+def openai_compatible_base_url_warning(base_url: Optional[str]) -> str:
+    if not base_url:
+        return ""
+
+    normalized = str(base_url).strip()
+    if is_trusted_openai_compatible_base_url(normalized) or not _is_well_formed_http_base_url(normalized):
+        return ""
+
+    parsed = urlparse(normalized)
+    host = (parsed.hostname or "").rstrip(".").lower()
+    return OPENAI_COMPATIBLE_BASE_URL_WARNING.format(host=host)
+
+
+def validate_openai_compatible_base_url(base_url: Optional[str]) -> Optional[str]:
+    if not base_url:
+        return None
+
+    normalized = str(base_url).strip()
+    if is_trusted_openai_compatible_base_url(normalized):
+        return normalized
+    if _is_well_formed_http_base_url(normalized):
+        return normalized
+
+    raise ValueError(OPENAI_COMPATIBLE_BASE_URL_ERROR)

config.example.toml

@@ -26,7 +26,7 @@
     #   - SiliconFlow: siliconflow/Qwen/Qwen2.5-VL-32B-Instruct
     vision_openai_model_name = "Qwen/Qwen3.5-122B-A10B"
     vision_openai_api_key = ""  # 填入对应 provider 的 API key
-    vision_openai_base_url = "https://api.siliconflow.cn/v1"  # 可选：自定义 API base URL（官方 OpenAI 可留空）
+    vision_openai_base_url = "https://api.siliconflow.cn/v1"  # 可选：自定义 API base URL；界面会提示 API key 将发送到对应端点
     vision_openai_temperature = 1.0
     vision_openai_top_p = 0.95
     vision_openai_max_tokens = 65536
@@ -53,9 +53,10 @@
     #   - Qwen: qwen/qwen-plus, qwen/qwen-turbo
     #   - SiliconFlow: siliconflow/deepseek-ai/DeepSeek-R1
     #   - Moonshot: moonshot/moonshot-v1-8k
-    text_openai_model_name = "Pro/zai-org/GLM-5"
+    text_openai_model_name = "Pro/zai-org/GLM-5"  # 高推理模型：剧情分析、文案生成、脚本匹配
+    text_openai_fast_model_name = ""  # 高效率模型：字幕翻译、字幕校准；留空时回退到高推理模型
     text_openai_api_key = ""  # 填入对应 provider 的 API key
-    text_openai_base_url = "https://api.siliconflow.cn/v1"  # 可选：自定义 API base URL（官方 OpenAI 可留空）
+    text_openai_base_url = "https://api.siliconflow.cn/v1"  # 可选：自定义 API base URL；界面会提示 API key 将发送到对应端点
     text_openai_temperature = 1.0
     text_openai_top_p = 0.95
     text_openai_max_tokens = 65536
@@ -67,6 +68,20 @@
     tavily_search_depth = "basic"  # basic / advanced / fast / ultra-fast
     tavily_max_results = 5
 
+    # ===== 可选：Sonilo AI 配乐（BGM）/ AI 音效（SFX）=====
+    # 配乐：在 WebUI 背景音乐来源中选择 "AI 生成配乐（Sonilo）" 即可启用（默认关闭，不影响现有 BGM 逻辑）。
+    # 启用后会将合成完成的视频（未加 BGM）上传到 Sonilo API，根据画面内容与剪辑节奏生成配乐；
+    # 生成的音乐已获授权、可商用（以条款为准）。视频时长上限 6 分钟，生成失败时自动回退到随机背景音乐。
+    # 音效：在 WebUI 音频设置中勾选 "AI 音效（Sonilo）" 即可启用（默认关闭）。
+    # 启用后会将合成完成的视频上传到 Sonilo API，根据画面内容生成音效，并混在现有音轨之下（解说不受影响）；
+    # 生成的音效为免版税素材。视频时长上限 3 分钟，生成失败时自动跳过音效。
+    sonilo_api_key = ""  # 获取地址：https://sonilo.com（配乐与音效共用）
+    # sonilo_base_url = "https://api.sonilo.com"
+    # sonilo_timeout_seconds = 600  # 生成接口读超时 / 音效任务等待上限（秒）
+    # sonilo_bgm_prompt = ""        # 可选：配乐风格提示，留空则完全根据画面生成
+    # sonilo_sfx_prompt = ""        # 可选：音效风格提示，留空则完全根据画面生成
+    # sonilo_sfx_volume = 0.6       # 音效混入原声之下的音量，范围 (0, 2]，默认 0.6
+
     # ===== API Keys 参考 =====
     # 主流 LLM Providers API Key 获取地址：
     #
@@ -160,40 +175,51 @@
     num_beams = 3
     repetition_penalty = 10.0
 
+[indextts_macos]
+    # IndexTTS-1.5 macOS MLX Pack 语音克隆配置（仅适用于 Apple Silicon）
+    # 参考音频会通过 POST /v1/audio/speech/upload 上传
+    api_url = "http://127.0.0.1:7866"
+    reference_audio_source = "resource"
+    # reference_audio = "/path/to/reference_audio.wav"
+
+    speed = 1.0
+    # seed = 42
+    max_mel_tokens = 800
+    max_text_tokens_per_segment = 120
+    interval_silence = 200
+    temperature = 1.0
+    top_p = 0.8
+    top_k = 30
+    repetition_penalty = 10.0
+    segment_overlap_ms = 50
+
 [indextts2]
-    # IndexTTS-2 语音克隆配置
+    # IndexTTS-2 MLX Pack 语音克隆配置
-    # 支持 IndexTTS2-Pack FastAPI 接口：POST /tts
+    # 参考音频会通过 POST /v1/audio/speech/upload 上传；可填写服务根地址或完整接口地址
-    api_url = "http://192.168.3.6:7863/tts"
+    api_url = "http://127.0.0.1:7860"
 
     # 默认参考音频（可选），音色列表复用 IndexTTS-1.5 的资源目录
     reference_audio_source = "resource"
     # reference_audio = "/path/to/reference_audio.wav"
 
-    # 情感控制：speaker / audio / vector / text
+    # 留空时保留参考音频情绪；支持单个情绪或混合权重，例如 happy:0.7,calm:0.3
-    emotion_mode = "speaker"
+    emotion = ""
-    emotion_audio = ""
+    emo_alpha = 0.6
-    emotion_alpha = 0.65
+    speed = 1.0
-    emotion_text = ""
+    # 可选：设置固定随机种子以复现生成结果
-    use_random = false
+    # seed = 20260713
-    max_text_tokens_per_segment = 120
-
-    # 8 维情感向量，顺序：happy, angry, sad, afraid, disgusted, melancholic, surprised, calm
-    vec_happy = 0.0
-    vec_angry = 0.0
-    vec_sad = 0.0
-    vec_afraid = 0.0
-    vec_disgusted = 0.0
-    vec_melancholic = 0.0
-    vec_surprised = 0.0
-    vec_calm = 0.8
 
     # 高级生成参数
+    max_text_tokens_per_segment = 120
+    interval_silence = 200
     temperature = 0.8
     top_p = 0.8
     top_k = 30
-    num_beams = 3
     repetition_penalty = 10.0
     max_mel_tokens = 1500
+    diffusion_steps = 25
+    cfg_rate = 0.7
+    segment_overlap_ms = 50
 
 [omnivoice]
     # OmniVoice-Pack 语音合成配置
@@ -219,6 +245,35 @@
     postprocess_output = true
     preprocess_prompt = true
 
+[voxcpm_05b]
+    # VoxCPM-0.5B-Pack 本地语音合成/参考音频克隆配置
+    # 启动整合包后，可填写服务根地址或完整 /tts 地址
+    api_url = "http://127.0.0.1:7864"
+    reference_audio_source = "resource"
+    reference_audio = ""
+    prompt_text = ""
+    cfg_value = 2.0
+    inference_timesteps = 10
+    max_length = 4096
+    normalize = true
+    denoise = false
+
+[voxcpm_2b]
+    # VoxCPM-2B-Pack 本地语音合成、音色设计与参考音频克隆
+    api_url = "http://127.0.0.1:7863"
+    mode = "design"
+    control = ""
+    reference_audio_source = "resource"
+    reference_audio = ""
+    prompt_text = ""
+    cfg_value = 2.0
+    inference_timesteps = 10
+    normalize = true
+    denoise = false
+    output_48k = true
+    context_aware = true
+    streaming = false
+
 [doubaotts]
     # 豆包语音 TTS 配置
     # 新版配置优先填写 API Key；旧版 appid/token 配置仍兼容

docs/voice-list.txt

@@ -1,965 +0,0 @@
-Name: af-ZA-AdriNeural
-Gender: Female
-
-Name: af-ZA-WillemNeural
-Gender: Male
-
-Name: am-ET-AmehaNeural
-Gender: Male
-
-Name: am-ET-MekdesNeural
-Gender: Female
-
-Name: ar-AE-FatimaNeural
-Gender: Female
-
-Name: ar-AE-HamdanNeural
-Gender: Male
-
-Name: ar-BH-AliNeural
-Gender: Male
-
-Name: ar-BH-LailaNeural
-Gender: Female
-
-Name: ar-DZ-AminaNeural
-Gender: Female
-
-Name: ar-DZ-IsmaelNeural
-Gender: Male
-
-Name: ar-EG-SalmaNeural
-Gender: Female
-
-Name: ar-EG-ShakirNeural
-Gender: Male
-
-Name: ar-IQ-BasselNeural
-Gender: Male
-
-Name: ar-IQ-RanaNeural
-Gender: Female
-
-Name: ar-JO-SanaNeural
-Gender: Female
-
-Name: ar-JO-TaimNeural
-Gender: Male
-
-Name: ar-KW-FahedNeural
-Gender: Male
-
-Name: ar-KW-NouraNeural
-Gender: Female
-
-Name: ar-LB-LaylaNeural
-Gender: Female
-
-Name: ar-LB-RamiNeural
-Gender: Male
-
-Name: ar-LY-ImanNeural
-Gender: Female
-
-Name: ar-LY-OmarNeural
-Gender: Male
-
-Name: ar-MA-JamalNeural
-Gender: Male
-
-Name: ar-MA-MounaNeural
-Gender: Female
-
-Name: ar-OM-AbdullahNeural
-Gender: Male
-
-Name: ar-OM-AyshaNeural
-Gender: Female
-
-Name: ar-QA-AmalNeural
-Gender: Female
-
-Name: ar-QA-MoazNeural
-Gender: Male
-
-Name: ar-SA-HamedNeural
-Gender: Male
-
-Name: ar-SA-ZariyahNeural
-Gender: Female
-
-Name: ar-SY-AmanyNeural
-Gender: Female
-
-Name: ar-SY-LaithNeural
-Gender: Male
-
-Name: ar-TN-HediNeural
-Gender: Male
-
-Name: ar-TN-ReemNeural
-Gender: Female
-
-Name: ar-YE-MaryamNeural
-Gender: Female
-
-Name: ar-YE-SalehNeural
-Gender: Male
-
-Name: az-AZ-BabekNeural
-Gender: Male
-
-Name: az-AZ-BanuNeural
-Gender: Female
-
-Name: bg-BG-BorislavNeural
-Gender: Male
-
-Name: bg-BG-KalinaNeural
-Gender: Female
-
-Name: bn-BD-NabanitaNeural
-Gender: Female
-
-Name: bn-BD-PradeepNeural
-Gender: Male
-
-Name: bn-IN-BashkarNeural
-Gender: Male
-
-Name: bn-IN-TanishaaNeural
-Gender: Female
-
-Name: bs-BA-GoranNeural
-Gender: Male
-
-Name: bs-BA-VesnaNeural
-Gender: Female
-
-Name: ca-ES-EnricNeural
-Gender: Male
-
-Name: ca-ES-JoanaNeural
-Gender: Female
-
-Name: cs-CZ-AntoninNeural
-Gender: Male
-
-Name: cs-CZ-VlastaNeural
-Gender: Female
-
-Name: cy-GB-AledNeural
-Gender: Male
-
-Name: cy-GB-NiaNeural
-Gender: Female
-
-Name: da-DK-ChristelNeural
-Gender: Female
-
-Name: da-DK-JeppeNeural
-Gender: Male
-
-Name: de-AT-IngridNeural
-Gender: Female
-
-Name: de-AT-JonasNeural
-Gender: Male
-
-Name: de-CH-JanNeural
-Gender: Male
-
-Name: de-CH-LeniNeural
-Gender: Female
-
-Name: de-DE-AmalaNeural
-Gender: Female
-
-Name: de-DE-ConradNeural
-Gender: Male
-
-Name: de-DE-FlorianMultilingualNeural
-Gender: Male
-
-Name: de-DE-KatjaNeural
-Gender: Female
-
-Name: de-DE-KillianNeural
-Gender: Male
-
-Name: de-DE-SeraphinaMultilingualNeural
-Gender: Female
-
-Name: el-GR-AthinaNeural
-Gender: Female
-
-Name: el-GR-NestorasNeural
-Gender: Male
-
-Name: en-AU-NatashaNeural
-Gender: Female
-
-Name: en-AU-WilliamMultilingualNeural
-Gender: Male
-
-Name: en-CA-ClaraNeural
-Gender: Female
-
-Name: en-CA-LiamNeural
-Gender: Male
-
-Name: en-GB-LibbyNeural
-Gender: Female
-
-Name: en-GB-MaisieNeural
-Gender: Female
-
-Name: en-GB-RyanNeural
-Gender: Male
-
-Name: en-GB-SoniaNeural
-Gender: Female
-
-Name: en-GB-ThomasNeural
-Gender: Male
-
-Name: en-HK-SamNeural
-Gender: Male
-
-Name: en-HK-YanNeural
-Gender: Female
-
-Name: en-IE-ConnorNeural
-Gender: Male
-
-Name: en-IE-EmilyNeural
-Gender: Female
-
-Name: en-IN-NeerjaExpressiveNeural
-Gender: Female
-
-Name: en-IN-NeerjaNeural
-Gender: Female
-
-Name: en-IN-PrabhatNeural
-Gender: Male
-
-Name: en-KE-AsiliaNeural
-Gender: Female
-
-Name: en-KE-ChilembaNeural
-Gender: Male
-
-Name: en-NG-AbeoNeural
-Gender: Male
-
-Name: en-NG-EzinneNeural
-Gender: Female
-
-Name: en-NZ-MitchellNeural
-Gender: Male
-
-Name: en-NZ-MollyNeural
-Gender: Female
-
-Name: en-PH-JamesNeural
-Gender: Male
-
-Name: en-PH-RosaNeural
-Gender: Female
-
-Name: en-SG-LunaNeural
-Gender: Female
-
-Name: en-SG-WayneNeural
-Gender: Male
-
-Name: en-TZ-ElimuNeural
-Gender: Male
-
-Name: en-TZ-ImaniNeural
-Gender: Female
-
-Name: en-US-AnaNeural
-Gender: Female
-
-Name: en-US-AndrewNeural
-Gender: Male
-
-Name: en-US-AndrewMultilingualNeural
-Gender: Male
-
-Name: en-US-AriaNeural
-Gender: Female
-
-Name: en-US-AvaNeural
-Gender: Female
-
-Name: en-US-AvaMultilingualNeural
-Gender: Female
-
-Name: en-US-BrianNeural
-Gender: Male
-
-Name: en-US-BrianMultilingualNeural
-Gender: Male
-
-Name: en-US-ChristopherNeural
-Gender: Male
-
-Name: en-US-EmmaNeural
-Gender: Female
-
-Name: en-US-EmmaMultilingualNeural
-Gender: Female
-
-Name: en-US-EricNeural
-Gender: Male
-
-Name: en-US-GuyNeural
-Gender: Male
-
-Name: en-US-JennyNeural
-Gender: Female
-
-Name: en-US-MichelleNeural
-Gender: Female
-
-Name: en-US-RogerNeural
-Gender: Male
-
-Name: en-US-SteffanNeural
-Gender: Male
-
-Name: en-ZA-LeahNeural
-Gender: Female
-
-Name: en-ZA-LukeNeural
-Gender: Male
-
-Name: es-AR-ElenaNeural
-Gender: Female
-
-Name: es-AR-TomasNeural
-Gender: Male
-
-Name: es-BO-MarceloNeural
-Gender: Male
-
-Name: es-BO-SofiaNeural
-Gender: Female
-
-Name: es-CL-CatalinaNeural
-Gender: Female
-
-Name: es-CL-LorenzoNeural
-Gender: Male
-
-Name: es-CO-GonzaloNeural
-Gender: Male
-
-Name: es-CO-SalomeNeural
-Gender: Female
-
-Name: es-CR-JuanNeural
-Gender: Male
-
-Name: es-CR-MariaNeural
-Gender: Female
-
-Name: es-CU-BelkysNeural
-Gender: Female
-
-Name: es-CU-ManuelNeural
-Gender: Male
-
-Name: es-DO-EmilioNeural
-Gender: Male
-
-Name: es-DO-RamonaNeural
-Gender: Female
-
-Name: es-EC-AndreaNeural
-Gender: Female
-
-Name: es-EC-LuisNeural
-Gender: Male
-
-Name: es-ES-AlvaroNeural
-Gender: Male
-
-Name: es-ES-ElviraNeural
-Gender: Female
-
-Name: es-ES-XimenaNeural
-Gender: Female
-
-Name: es-GQ-JavierNeural
-Gender: Male
-
-Name: es-GQ-TeresaNeural
-Gender: Female
-
-Name: es-GT-AndresNeural
-Gender: Male
-
-Name: es-GT-MartaNeural
-Gender: Female
-
-Name: es-HN-CarlosNeural
-Gender: Male
-
-Name: es-HN-KarlaNeural
-Gender: Female
-
-Name: es-MX-DaliaNeural
-Gender: Female
-
-Name: es-MX-JorgeNeural
-Gender: Male
-
-Name: es-NI-FedericoNeural
-Gender: Male
-
-Name: es-NI-YolandaNeural
-Gender: Female
-
-Name: es-PA-MargaritaNeural
-Gender: Female
-
-Name: es-PA-RobertoNeural
-Gender: Male
-
-Name: es-PE-AlexNeural
-Gender: Male
-
-Name: es-PE-CamilaNeural
-Gender: Female
-
-Name: es-PR-KarinaNeural
-Gender: Female
-
-Name: es-PR-VictorNeural
-Gender: Male
-
-Name: es-PY-MarioNeural
-Gender: Male
-
-Name: es-PY-TaniaNeural
-Gender: Female
-
-Name: es-SV-LorenaNeural
-Gender: Female
-
-Name: es-SV-RodrigoNeural
-Gender: Male
-
-Name: es-US-AlonsoNeural
-Gender: Male
-
-Name: es-US-PalomaNeural
-Gender: Female
-
-Name: es-UY-MateoNeural
-Gender: Male
-
-Name: es-UY-ValentinaNeural
-Gender: Female
-
-Name: es-VE-PaolaNeural
-Gender: Female
-
-Name: es-VE-SebastianNeural
-Gender: Male
-
-Name: et-EE-AnuNeural
-Gender: Female
-
-Name: et-EE-KertNeural
-Gender: Male
-
-Name: fa-IR-DilaraNeural
-Gender: Female
-
-Name: fa-IR-FaridNeural
-Gender: Male
-
-Name: fi-FI-HarriNeural
-Gender: Male
-
-Name: fi-FI-NooraNeural
-Gender: Female
-
-Name: fil-PH-AngeloNeural
-Gender: Male
-
-Name: fil-PH-BlessicaNeural
-Gender: Female
-
-Name: fr-BE-CharlineNeural
-Gender: Female
-
-Name: fr-BE-GerardNeural
-Gender: Male
-
-Name: fr-CA-AntoineNeural
-Gender: Male
-
-Name: fr-CA-JeanNeural
-Gender: Male
-
-Name: fr-CA-SylvieNeural
-Gender: Female
-
-Name: fr-CA-ThierryNeural
-Gender: Male
-
-Name: fr-CH-ArianeNeural
-Gender: Female
-
-Name: fr-CH-FabriceNeural
-Gender: Male
-
-Name: fr-FR-DeniseNeural
-Gender: Female
-
-Name: fr-FR-EloiseNeural
-Gender: Female
-
-Name: fr-FR-HenriNeural
-Gender: Male
-
-Name: fr-FR-RemyMultilingualNeural
-Gender: Male
-
-Name: fr-FR-VivienneMultilingualNeural
-Gender: Female
-
-Name: ga-IE-ColmNeural
-Gender: Male
-
-Name: ga-IE-OrlaNeural
-Gender: Female
-
-Name: gl-ES-RoiNeural
-Gender: Male
-
-Name: gl-ES-SabelaNeural
-Gender: Female
-
-Name: gu-IN-DhwaniNeural
-Gender: Female
-
-Name: gu-IN-NiranjanNeural
-Gender: Male
-
-Name: he-IL-AvriNeural
-Gender: Male
-
-Name: he-IL-HilaNeural
-Gender: Female
-
-Name: hi-IN-MadhurNeural
-Gender: Male
-
-Name: hi-IN-SwaraNeural
-Gender: Female
-
-Name: hr-HR-GabrijelaNeural
-Gender: Female
-
-Name: hr-HR-SreckoNeural
-Gender: Male
-
-Name: hu-HU-NoemiNeural
-Gender: Female
-
-Name: hu-HU-TamasNeural
-Gender: Male
-
-Name: id-ID-ArdiNeural
-Gender: Male
-
-Name: id-ID-GadisNeural
-Gender: Female
-
-Name: is-IS-GudrunNeural
-Gender: Female
-
-Name: is-IS-GunnarNeural
-Gender: Male
-
-Name: it-IT-DiegoNeural
-Gender: Male
-
-Name: it-IT-ElsaNeural
-Gender: Female
-
-Name: it-IT-GiuseppeMultilingualNeural
-Gender: Male
-
-Name: it-IT-IsabellaNeural
-Gender: Female
-
-Name: iu-Cans-CA-SiqiniqNeural
-Gender: Female
-
-Name: iu-Cans-CA-TaqqiqNeural
-Gender: Male
-
-Name: iu-Latn-CA-SiqiniqNeural
-Gender: Female
-
-Name: iu-Latn-CA-TaqqiqNeural
-Gender: Male
-
-Name: ja-JP-KeitaNeural
-Gender: Male
-
-Name: ja-JP-NanamiNeural
-Gender: Female
-
-Name: jv-ID-DimasNeural
-Gender: Male
-
-Name: jv-ID-SitiNeural
-Gender: Female
-
-Name: ka-GE-EkaNeural
-Gender: Female
-
-Name: ka-GE-GiorgiNeural
-Gender: Male
-
-Name: kk-KZ-AigulNeural
-Gender: Female
-
-Name: kk-KZ-DauletNeural
-Gender: Male
-
-Name: km-KH-PisethNeural
-Gender: Male
-
-Name: km-KH-SreymomNeural
-Gender: Female
-
-Name: kn-IN-GaganNeural
-Gender: Male
-
-Name: kn-IN-SapnaNeural
-Gender: Female
-
-Name: ko-KR-HyunsuMultilingualNeural
-Gender: Male
-
-Name: ko-KR-InJoonNeural
-Gender: Male
-
-Name: ko-KR-SunHiNeural
-Gender: Female
-
-Name: lo-LA-ChanthavongNeural
-Gender: Male
-
-Name: lo-LA-KeomanyNeural
-Gender: Female
-
-Name: lt-LT-LeonasNeural
-Gender: Male
-
-Name: lt-LT-OnaNeural
-Gender: Female
-
-Name: lv-LV-EveritaNeural
-Gender: Female
-
-Name: lv-LV-NilsNeural
-Gender: Male
-
-Name: mk-MK-AleksandarNeural
-Gender: Male
-
-Name: mk-MK-MarijaNeural
-Gender: Female
-
-Name: ml-IN-MidhunNeural
-Gender: Male
-
-Name: ml-IN-SobhanaNeural
-Gender: Female
-
-Name: mn-MN-BataaNeural
-Gender: Male
-
-Name: mn-MN-YesuiNeural
-Gender: Female
-
-Name: mr-IN-AarohiNeural
-Gender: Female
-
-Name: mr-IN-ManoharNeural
-Gender: Male
-
-Name: ms-MY-OsmanNeural
-Gender: Male
-
-Name: ms-MY-YasminNeural
-Gender: Female
-
-Name: mt-MT-GraceNeural
-Gender: Female
-
-Name: mt-MT-JosephNeural
-Gender: Male
-
-Name: my-MM-NilarNeural
-Gender: Female
-
-Name: my-MM-ThihaNeural
-Gender: Male
-
-Name: nb-NO-FinnNeural
-Gender: Male
-
-Name: nb-NO-PernilleNeural
-Gender: Female
-
-Name: ne-NP-HemkalaNeural
-Gender: Female
-
-Name: ne-NP-SagarNeural
-Gender: Male
-
-Name: nl-BE-ArnaudNeural
-Gender: Male
-
-Name: nl-BE-DenaNeural
-Gender: Female
-
-Name: nl-NL-ColetteNeural
-Gender: Female
-
-Name: nl-NL-FennaNeural
-Gender: Female
-
-Name: nl-NL-MaartenNeural
-Gender: Male
-
-Name: pl-PL-MarekNeural
-Gender: Male
-
-Name: pl-PL-ZofiaNeural
-Gender: Female
-
-Name: ps-AF-GulNawazNeural
-Gender: Male
-
-Name: ps-AF-LatifaNeural
-Gender: Female
-
-Name: pt-BR-AntonioNeural
-Gender: Male
-
-Name: pt-BR-FranciscaNeural
-Gender: Female
-
-Name: pt-BR-ThalitaMultilingualNeural
-Gender: Female
-
-Name: pt-PT-DuarteNeural
-Gender: Male
-
-Name: pt-PT-RaquelNeural
-Gender: Female
-
-Name: ro-RO-AlinaNeural
-Gender: Female
-
-Name: ro-RO-EmilNeural
-Gender: Male
-
-Name: ru-RU-DmitryNeural
-Gender: Male
-
-Name: ru-RU-SvetlanaNeural
-Gender: Female
-
-Name: si-LK-SameeraNeural
-Gender: Male
-
-Name: si-LK-ThiliniNeural
-Gender: Female
-
-Name: sk-SK-LukasNeural
-Gender: Male
-
-Name: sk-SK-ViktoriaNeural
-Gender: Female
-
-Name: sl-SI-PetraNeural
-Gender: Female
-
-Name: sl-SI-RokNeural
-Gender: Male
-
-Name: so-SO-MuuseNeural
-Gender: Male
-
-Name: so-SO-UbaxNeural
-Gender: Female
-
-Name: sq-AL-AnilaNeural
-Gender: Female
-
-Name: sq-AL-IlirNeural
-Gender: Male
-
-Name: sr-RS-NicholasNeural
-Gender: Male
-
-Name: sr-RS-SophieNeural
-Gender: Female
-
-Name: su-ID-JajangNeural
-Gender: Male
-
-Name: su-ID-TutiNeural
-Gender: Female
-
-Name: sv-SE-MattiasNeural
-Gender: Male
-
-Name: sv-SE-SofieNeural
-Gender: Female
-
-Name: sw-KE-RafikiNeural
-Gender: Male
-
-Name: sw-KE-ZuriNeural
-Gender: Female
-
-Name: sw-TZ-DaudiNeural
-Gender: Male
-
-Name: sw-TZ-RehemaNeural
-Gender: Female
-
-Name: ta-IN-PallaviNeural
-Gender: Female
-
-Name: ta-IN-ValluvarNeural
-Gender: Male
-
-Name: ta-LK-KumarNeural
-Gender: Male
-
-Name: ta-LK-SaranyaNeural
-Gender: Female
-
-Name: ta-MY-KaniNeural
-Gender: Female
-
-Name: ta-MY-SuryaNeural
-Gender: Male
-
-Name: ta-SG-AnbuNeural
-Gender: Male
-
-Name: ta-SG-VenbaNeural
-Gender: Female
-
-Name: te-IN-MohanNeural
-Gender: Male
-
-Name: te-IN-ShrutiNeural
-Gender: Female
-
-Name: th-TH-NiwatNeural
-Gender: Male
-
-Name: th-TH-PremwadeeNeural
-Gender: Female
-
-Name: tr-TR-AhmetNeural
-Gender: Male
-
-Name: tr-TR-EmelNeural
-Gender: Female
-
-Name: uk-UA-OstapNeural
-Gender: Male
-
-Name: uk-UA-PolinaNeural
-Gender: Female
-
-Name: ur-IN-GulNeural
-Gender: Female
-
-Name: ur-IN-SalmanNeural
-Gender: Male
-
-Name: ur-PK-AsadNeural
-Gender: Male
-
-Name: ur-PK-UzmaNeural
-Gender: Female
-
-Name: uz-UZ-MadinaNeural
-Gender: Female
-
-Name: uz-UZ-SardorNeural
-Gender: Male
-
-Name: vi-VN-HoaiMyNeural
-Gender: Female
-
-Name: vi-VN-NamMinhNeural
-Gender: Male
-
-Name: zh-CN-XiaoxiaoNeural
-Gender: Female
-
-Name: zh-CN-XiaoyiNeural
-Gender: Female
-
-Name: zh-CN-YunjianNeural
-Gender: Male
-
-Name: zh-CN-YunxiNeural
-Gender: Male
-
-Name: zh-CN-YunxiaNeural
-Gender: Male
-
-Name: zh-CN-YunyangNeural
-Gender: Male
-
-Name: zh-CN-liaoning-XiaobeiNeural
-Gender: Female
-
-Name: zh-CN-shaanxi-XiaoniNeural
-Gender: Female
-
-Name: zh-HK-HiuGaaiNeural
-Gender: Female
-
-Name: zh-HK-HiuMaanNeural
-Gender: Female
-
-Name: zh-HK-WanLungNeural
-Gender: Male
-
-Name: zh-TW-HsiaoChenNeural
-Gender: Female
-
-Name: zh-TW-HsiaoYuNeural
-Gender: Female
-
-Name: zh-TW-YunJheNeural
-Gender: Male
-
-Name: zu-ZA-ThandoNeural
-Gender: Female
-
-Name: zu-ZA-ThembaNeural
-Gender: Male

project_version

@@ -1 +1 @@
-0.8.4
+0.8.7

pyproject.toml

@@ -0,0 +1,50 @@
+[project]
+name = "narratoai"
+version = "0.8.4"
+description = "An all-in-one AI-powered tool for film commentary and automated video editing."
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "requests>=2.32.0",
+    "moviepy==2.1.1",
+    "edge-tts==7.2.7",
+    "streamlit==1.56.0",
+    "watchdog==6.0.0",
+    "loguru>=0.7.3",
+    "tomli>=2.2.1",
+    "tomli-w>=1.0.0",
+    "pydub==0.25.1",
+    "pysrt==1.1.2",
+    "openai>=1.77.0",
+    "google-generativeai>=0.8.5",
+    "azure-cognitiveservices-speech>=1.37.0",
+    "tencentcloud-sdk-python>=3.0.1200",
+    "dashscope>=1.24.6",
+    "Pillow>=10.3.0",
+    "tqdm>=4.66.6",
+    "tenacity>=9.0.0",
+]
+
+[project.optional-dependencies]
+twelvelabs = [
+    "twelvelabs>=1.2.8",
+]
+local-asr = [
+    "faster-whisper>=1.0.1",
+]
+opencv = [
+    "opencv-python>=4.11.0.86",
+]
+cuda = [
+    "torch>=2.0.0",
+    "torchvision>=0.15.0",
+    "torchaudio>=2.0.0",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0.0",
+]
+
+[tool.uv]
+package = false

tests/test_sonilo_bgm_unittest.py

@@ -0,0 +1,163 @@
+import base64
+import json
+import os
+import tempfile
+import unittest
+from unittest import mock
+
+from app.services import sonilo
+
+
+def _ndjson_lines(*events):
+    return [json.dumps(event) for event in events]
+
+
+class ConsumeNdjsonStreamTests(unittest.TestCase):
+    def test_returns_first_stream_audio_grouped_by_index(self):
+        lines = _ndjson_lines(
+            {"type": "audio_chunk", "stream_index": 0, "data": base64.b64encode(b"ab").decode()},
+            {"type": "audio_chunk", "stream_index": 1, "data": base64.b64encode(b"zz").decode()},
+            {"type": "audio_chunk", "stream_index": 0, "data": base64.b64encode(b"cd").decode()},
+            {"type": "title", "data": "some title"},
+            {"type": "complete"},
+        )
+
+        self.assertEqual(b"abcd", sonilo._consume_ndjson_stream(lines))
+
+    def test_ignores_blank_and_unparseable_lines(self):
+        lines = [
+            "",
+            "   ",
+            "not json",
+            json.dumps({"type": "audio_chunk", "stream_index": 0, "data": base64.b64encode(b"ok").decode()}),
+            json.dumps({"type": "complete"}),
+        ]
+
+        self.assertEqual(b"ok", sonilo._consume_ndjson_stream(lines))
+
+    def test_error_event_raises(self):
+        lines = _ndjson_lines(
+            {"type": "audio_chunk", "stream_index": 0, "data": base64.b64encode(b"ab").decode()},
+            {"type": "error", "message": "boom"},
+        )
+
+        with self.assertRaises(sonilo.SoniloError):
+            sonilo._consume_ndjson_stream(lines)
+
+    def test_missing_complete_event_raises(self):
+        lines = _ndjson_lines(
+            {"type": "audio_chunk", "stream_index": 0, "data": base64.b64encode(b"ab").decode()},
+        )
+
+        with self.assertRaises(sonilo.SoniloError):
+            sonilo._consume_ndjson_stream(lines)
+
+    def test_complete_without_audio_raises(self):
+        lines = _ndjson_lines({"type": "complete"})
+
+        with self.assertRaises(sonilo.SoniloError):
+            sonilo._consume_ndjson_stream(lines)
+
+
+class GenerateBgmTests(unittest.TestCase):
+    def setUp(self):
+        self._tmp_dir = tempfile.TemporaryDirectory()
+        self.addCleanup(self._tmp_dir.cleanup)
+        self.video_path = os.path.join(self._tmp_dir.name, "combined.mp4")
+        with open(self.video_path, "wb") as f:
+            f.write(b"fake video")
+        self.save_path = os.path.join(self._tmp_dir.name, "sonilo_bgm.m4a")
+
+    def test_returns_empty_without_api_key(self):
+        with mock.patch.object(sonilo, "get_api_key", return_value=""):
+            self.assertEqual("", sonilo.generate_bgm(self.video_path, self.save_path))
+
+    def test_returns_empty_when_video_missing(self):
+        with mock.patch.object(sonilo, "get_api_key", return_value="sk-test"):
+            missing = os.path.join(self._tmp_dir.name, "missing.mp4")
+            self.assertEqual("", sonilo.generate_bgm(missing, self.save_path))
+
+    def test_skips_upload_when_duration_exceeds_limit(self):
+        with mock.patch.object(sonilo, "get_api_key", return_value="sk-test"), \
+                mock.patch.object(sonilo, "_probe_video_duration", return_value=361.0), \
+                mock.patch.object(sonilo, "_request_video_to_music") as request_mock:
+            self.assertEqual("", sonilo.generate_bgm(self.video_path, self.save_path))
+            request_mock.assert_not_called()
+
+    def test_saves_audio_on_success(self):
+        with mock.patch.object(sonilo, "get_api_key", return_value="sk-test"), \
+                mock.patch.object(sonilo, "_probe_video_duration", return_value=60.0), \
+                mock.patch.object(sonilo, "_request_video_to_music", return_value=b"audio-bytes"):
+            self.assertEqual(self.save_path, sonilo.generate_bgm(self.video_path, self.save_path))
+
+        with open(self.save_path, "rb") as f:
+            self.assertEqual(b"audio-bytes", f.read())
+
+    def test_request_failure_degrades_to_empty(self):
+        with mock.patch.object(sonilo, "get_api_key", return_value="sk-test"), \
+                mock.patch.object(sonilo, "_probe_video_duration", return_value=60.0), \
+                mock.patch.object(
+                    sonilo,
+                    "_request_video_to_music",
+                    side_effect=sonilo.SoniloError("timeout"),
+                ):
+            self.assertEqual("", sonilo.generate_bgm(self.video_path, self.save_path))
+
+        self.assertFalse(os.path.exists(self.save_path))
+
+
+class ResolveBgmPathTests(unittest.TestCase):
+    """任务层的 BGM 解析：Sonilo 模式失败时回退到现有 BGM 逻辑。"""
+
+    def _make_params(self, bgm_type, bgm_file=""):
+        params = mock.Mock()
+        params.bgm_type = bgm_type
+        params.bgm_file = bgm_file
+        return params
+
+    def test_non_sonilo_type_uses_existing_logic(self):
+        from app.services import task
+
+        params = self._make_params("custom", "/tmp/some_bgm.mp3")
+        with mock.patch.object(task.utils, "get_bgm_file", return_value="/tmp/some_bgm.mp3") as get_bgm, \
+                mock.patch.object(task.sonilo, "generate_bgm") as generate_bgm:
+            result = task._resolve_bgm_path("task-id", params, "/tmp/combined.mp4")
+
+        self.assertEqual("/tmp/some_bgm.mp3", result)
+        get_bgm.assert_called_once_with(bgm_type="custom", bgm_file="/tmp/some_bgm.mp3")
+        generate_bgm.assert_not_called()
+
+    def test_sonilo_type_uses_generated_bgm(self):
+        from app.services import task
+
+        params = self._make_params("sonilo")
+        with mock.patch.object(task.utils, "task_dir", return_value="/tmp/task-id"), \
+                mock.patch.object(
+                    task.sonilo, "generate_bgm", return_value="/tmp/task-id/sonilo_bgm.m4a"
+                ) as generate_bgm, \
+                mock.patch.object(task.utils, "get_bgm_file") as get_bgm:
+            result = task._resolve_bgm_path("task-id", params, "/tmp/combined.mp4")
+
+        self.assertEqual("/tmp/task-id/sonilo_bgm.m4a", result)
+        generate_bgm.assert_called_once_with(
+            "/tmp/combined.mp4", os.path.join("/tmp/task-id", "sonilo_bgm.m4a")
+        )
+        get_bgm.assert_not_called()
+
+    def test_sonilo_failure_falls_back_to_random_bgm(self):
+        from app.services import task
+
+        params = self._make_params("sonilo")
+        with mock.patch.object(task.utils, "task_dir", return_value="/tmp/task-id"), \
+                mock.patch.object(task.sonilo, "generate_bgm", return_value=""), \
+                mock.patch.object(
+                    task.utils, "get_bgm_file", return_value="/resource/songs/output000.mp3"
+                ) as get_bgm:
+            result = task._resolve_bgm_path("task-id", params, "/tmp/combined.mp4")
+
+        self.assertEqual("/resource/songs/output000.mp3", result)
+        get_bgm.assert_called_once_with(bgm_type="random", bgm_file="")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_sonilo_sfx_unittest.py

@@ -0,0 +1,362 @@
+import os
+import tempfile
+import unittest
+from unittest import mock
+
+import requests
+
+from app.services import sonilo
+
+
+def _response(status_code=200, json_body=None, content=b"{}"):
+    resp = mock.Mock()
+    resp.status_code = status_code
+    resp.content = content
+    if json_body is None:
+        resp.json.side_effect = ValueError("no json")
+    else:
+        resp.json.return_value = json_body
+    return resp
+
+
+class SubmitSfxTaskTests(unittest.TestCase):
+    def setUp(self):
+        self._tmp_dir = tempfile.TemporaryDirectory()
+        self.addCleanup(self._tmp_dir.cleanup)
+        self.video_path = os.path.join(self._tmp_dir.name, "combined.mp4")
+        with open(self.video_path, "wb") as f:
+            f.write(b"fake video")
+
+    def test_returns_task_id(self):
+        with mock.patch.object(sonilo, "get_api_key", return_value="sk-test"), \
+                mock.patch.object(
+                    sonilo.requests,
+                    "post",
+                    return_value=_response(202, {"task_id": "task-123"}),
+                ) as post_mock:
+            self.assertEqual("task-123", sonilo._submit_sfx_task(self.video_path))
+
+        args, kwargs = post_mock.call_args
+        self.assertTrue(args[0].endswith("/v1/video-to-sfx"))
+        self.assertEqual("Bearer sk-test", kwargs["headers"]["Authorization"])
+
+    def test_http_error_raises(self):
+        with mock.patch.object(sonilo, "get_api_key", return_value="sk-test"), \
+                mock.patch.object(
+                    sonilo.requests,
+                    "post",
+                    return_value=_response(402, content=b'{"detail": "no credits"}'),
+                ):
+            with self.assertRaises(sonilo.SoniloError):
+                sonilo._submit_sfx_task(self.video_path)
+
+    def test_missing_task_id_raises(self):
+        with mock.patch.object(sonilo, "get_api_key", return_value="sk-test"), \
+                mock.patch.object(
+                    sonilo.requests, "post", return_value=_response(202, {})
+                ):
+            with self.assertRaises(sonilo.SoniloError):
+                sonilo._submit_sfx_task(self.video_path)
+
+
+class PollSfxTaskTests(unittest.TestCase):
+    def test_returns_body_when_succeeded(self):
+        responses = [
+            _response(200, {"status": "processing"}),
+            _response(
+                200,
+                {"status": "succeeded", "audio": {"url": "https://cdn/x.m4a"}},
+            ),
+        ]
+        with mock.patch.object(sonilo, "get_api_key", return_value="sk-test"), \
+                mock.patch.object(sonilo, "_sleep"), \
+                mock.patch.object(sonilo.requests, "get", side_effect=responses):
+            body = sonilo._poll_sfx_task("task-123")
+
+        self.assertEqual("succeeded", body["status"])
+
+    def test_failed_status_raises_with_task_id(self):
+        response = _response(
+            200,
+            {
+                "status": "failed",
+                "error": {"code": "GENERATION_FAILED", "message": "boom"},
+                "refunded": True,
+            },
+        )
+        with mock.patch.object(sonilo, "get_api_key", return_value="sk-test"), \
+                mock.patch.object(sonilo, "_sleep"), \
+                mock.patch.object(sonilo.requests, "get", return_value=response):
+            with self.assertRaises(sonilo.SoniloError) as ctx:
+                sonilo._poll_sfx_task("task-123")
+
+        self.assertIn("task-123", str(ctx.exception))
+        self.assertIn("boom", str(ctx.exception))
+
+    def test_transient_error_retries_until_succeeded(self):
+        responses = [
+            requests.exceptions.ConnectionError("blip"),
+            _response(
+                200,
+                {"status": "succeeded", "audio": {"url": "https://cdn/x.m4a"}},
+            ),
+        ]
+        with mock.patch.object(sonilo, "get_api_key", return_value="sk-test"), \
+                mock.patch.object(sonilo, "_sleep"), \
+                mock.patch.object(sonilo.requests, "get", side_effect=responses):
+            body = sonilo._poll_sfx_task("task-123")
+
+        self.assertEqual("succeeded", body["status"])
+
+    def test_non_recoverable_http_error_raises(self):
+        response = _response(401, content=b'{"detail": "bad key"}')
+        with mock.patch.object(sonilo, "get_api_key", return_value="sk-test"), \
+                mock.patch.object(sonilo, "_sleep"), \
+                mock.patch.object(sonilo.requests, "get", return_value=response):
+            with self.assertRaises(sonilo.SoniloError):
+                sonilo._poll_sfx_task("task-123")
+
+    def test_timeout_raises_with_task_id(self):
+        response = _response(200, {"status": "processing"})
+        with mock.patch.object(sonilo, "get_api_key", return_value="sk-test"), \
+                mock.patch.object(sonilo, "_sleep"), \
+                mock.patch.object(sonilo, "_get_timeout_seconds", return_value=0.0), \
+                mock.patch.object(sonilo.requests, "get", return_value=response):
+            with self.assertRaises(sonilo.SoniloError) as ctx:
+                sonilo._poll_sfx_task("task-123")
+
+        self.assertIn("task-123", str(ctx.exception))
+
+
+class DownloadSfxAudioTests(unittest.TestCase):
+    def test_returns_content_without_auth_headers(self):
+        response = _response(200, content=b"audio-bytes")
+        with mock.patch.object(
+            sonilo.requests, "get", return_value=response
+        ) as get_mock:
+            self.assertEqual(
+                b"audio-bytes", sonilo._download_sfx_audio("https://cdn/x.m4a")
+            )
+
+        # 预签名 URL 自带鉴权，绝不能把 API Key 发给存储域名。
+        _, kwargs = get_mock.call_args
+        self.assertNotIn("headers", kwargs)
+
+    def test_http_error_raises(self):
+        with mock.patch.object(
+            sonilo.requests, "get", return_value=_response(403, content=b"denied")
+        ):
+            with self.assertRaises(sonilo.SoniloError):
+                sonilo._download_sfx_audio("https://cdn/x.m4a")
+
+    def test_empty_content_raises(self):
+        with mock.patch.object(
+            sonilo.requests, "get", return_value=_response(200, content=b"")
+        ):
+            with self.assertRaises(sonilo.SoniloError):
+                sonilo._download_sfx_audio("https://cdn/x.m4a")
+
+
+class ExtractSfxAudioUrlTests(unittest.TestCase):
+    def test_returns_audio_url(self):
+        body = {"status": "succeeded", "audio": {"url": "https://cdn/x.m4a"}}
+        self.assertEqual(
+            "https://cdn/x.m4a", sonilo._extract_sfx_audio_url(body, "task-123")
+        )
+
+    def test_missing_audio_raises(self):
+        with self.assertRaises(sonilo.SoniloError):
+            sonilo._extract_sfx_audio_url({"status": "succeeded"}, "task-123")
+
+
+class GenerateSfxTests(unittest.TestCase):
+    def setUp(self):
+        self._tmp_dir = tempfile.TemporaryDirectory()
+        self.addCleanup(self._tmp_dir.cleanup)
+        self.video_path = os.path.join(self._tmp_dir.name, "combined.mp4")
+        with open(self.video_path, "wb") as f:
+            f.write(b"fake video")
+        self.save_path = os.path.join(self._tmp_dir.name, "sonilo_sfx.m4a")
+
+    def test_returns_empty_without_api_key(self):
+        with mock.patch.object(sonilo, "get_api_key", return_value=""):
+            self.assertEqual("", sonilo.generate_sfx(self.video_path, self.save_path))
+
+    def test_returns_empty_when_video_missing(self):
+        with mock.patch.object(sonilo, "get_api_key", return_value="sk-test"):
+            missing = os.path.join(self._tmp_dir.name, "missing.mp4")
+            self.assertEqual("", sonilo.generate_sfx(missing, self.save_path))
+
+    def test_skips_upload_when_duration_exceeds_limit(self):
+        with mock.patch.object(sonilo, "get_api_key", return_value="sk-test"), \
+                mock.patch.object(sonilo, "_probe_video_duration", return_value=181.0), \
+                mock.patch.object(sonilo, "_request_video_to_sfx") as request_mock:
+            self.assertEqual("", sonilo.generate_sfx(self.video_path, self.save_path))
+            request_mock.assert_not_called()
+
+    def test_saves_audio_on_success(self):
+        with mock.patch.object(sonilo, "get_api_key", return_value="sk-test"), \
+                mock.patch.object(sonilo, "_probe_video_duration", return_value=60.0), \
+                mock.patch.object(sonilo, "_request_video_to_sfx", return_value=b"audio-bytes"):
+            self.assertEqual(self.save_path, sonilo.generate_sfx(self.video_path, self.save_path))
+
+        with open(self.save_path, "rb") as f:
+            self.assertEqual(b"audio-bytes", f.read())
+
+    def test_request_failure_degrades_to_empty(self):
+        with mock.patch.object(sonilo, "get_api_key", return_value="sk-test"), \
+                mock.patch.object(sonilo, "_probe_video_duration", return_value=60.0), \
+                mock.patch.object(
+                    sonilo,
+                    "_request_video_to_sfx",
+                    side_effect=sonilo.SoniloError("timeout"),
+                ):
+            self.assertEqual("", sonilo.generate_sfx(self.video_path, self.save_path))
+
+        self.assertFalse(os.path.exists(self.save_path))
+
+
+class GetSfxVolumeTests(unittest.TestCase):
+    def test_default_when_unset(self):
+        with mock.patch.object(sonilo.config, "app", {}):
+            self.assertEqual(sonilo.DEFAULT_SFX_VOLUME, sonilo._get_sfx_volume())
+
+    def test_default_when_invalid(self):
+        with mock.patch.object(sonilo.config, "app", {"sonilo_sfx_volume": "abc"}):
+            self.assertEqual(sonilo.DEFAULT_SFX_VOLUME, sonilo._get_sfx_volume())
+
+    def test_default_when_non_positive(self):
+        with mock.patch.object(sonilo.config, "app", {"sonilo_sfx_volume": 0}):
+            self.assertEqual(sonilo.DEFAULT_SFX_VOLUME, sonilo._get_sfx_volume())
+
+    def test_clamped_to_upper_bound(self):
+        with mock.patch.object(sonilo.config, "app", {"sonilo_sfx_volume": 5}):
+            self.assertEqual(2.0, sonilo._get_sfx_volume())
+
+    def test_valid_value_passes_through(self):
+        with mock.patch.object(sonilo.config, "app", {"sonilo_sfx_volume": 0.8}):
+            self.assertEqual(0.8, sonilo._get_sfx_volume())
+
+
+class MixSfxUnderOriginalTests(unittest.TestCase):
+    def _run(self, has_audio, returncode=0, run_side_effect=None):
+        run_mock = mock.Mock(return_value=mock.Mock(returncode=returncode, stderr=b"err"))
+        if run_side_effect is not None:
+            run_mock = mock.Mock(side_effect=run_side_effect)
+        with mock.patch.object(sonilo, "_get_ffmpeg_binary", return_value="ffmpeg"), \
+                mock.patch.object(sonilo, "_probe_has_audio_stream", return_value=has_audio), \
+                mock.patch.object(sonilo, "_get_sfx_volume", return_value=0.6), \
+                mock.patch.object(sonilo.subprocess, "run", run_mock):
+            result = sonilo._mix_sfx_under_original(
+                "/tmp/combined.mp4", "/tmp/sfx.m4a", "/tmp/merger_sfx.mp4"
+            )
+        return result, run_mock
+
+    def test_mixes_under_existing_audio_with_amix(self):
+        result, run_mock = self._run(has_audio=True)
+
+        self.assertEqual("/tmp/merger_sfx.mp4", result)
+        cmd = run_mock.call_args[0][0]
+        filter_complex = cmd[cmd.index("-filter_complex") + 1]
+        self.assertIn("volume=0.6", filter_complex)
+        self.assertIn("amix", filter_complex)
+        # 视频流直接复制，不重编码画面。
+        self.assertIn("copy", cmd[cmd.index("-c:v") + 1])
+        self.assertNotIn("-shortest", cmd)
+
+    def test_sfx_becomes_audio_track_when_video_has_no_audio(self):
+        result, run_mock = self._run(has_audio=False)
+
+        self.assertEqual("/tmp/merger_sfx.mp4", result)
+        cmd = run_mock.call_args[0][0]
+        filter_complex = cmd[cmd.index("-filter_complex") + 1]
+        self.assertNotIn("amix", filter_complex)
+        self.assertIn("-shortest", cmd)
+
+    def test_ffmpeg_failure_returns_empty(self):
+        result, _ = self._run(has_audio=True, returncode=1)
+        self.assertEqual("", result)
+
+    def test_ffmpeg_oserror_returns_empty(self):
+        result, _ = self._run(has_audio=True, run_side_effect=OSError("no ffmpeg"))
+        self.assertEqual("", result)
+
+
+class ApplySfxTests(unittest.TestCase):
+    def test_success_returns_output_path(self):
+        with mock.patch.object(
+            sonilo, "generate_sfx", return_value="/tmp/merger_sfx.m4a"
+        ) as generate_mock, mock.patch.object(
+            sonilo, "_mix_sfx_under_original", return_value="/tmp/merger_sfx.mp4"
+        ) as mix_mock:
+            result = sonilo.apply_sfx("/tmp/combined.mp4", "/tmp/merger_sfx.mp4")
+
+        self.assertEqual("/tmp/merger_sfx.mp4", result)
+        generate_mock.assert_called_once_with("/tmp/combined.mp4", "/tmp/merger_sfx.m4a")
+        mix_mock.assert_called_once_with(
+            "/tmp/combined.mp4", "/tmp/merger_sfx.m4a", "/tmp/merger_sfx.mp4"
+        )
+
+    def test_generation_failure_skips_mixing(self):
+        with mock.patch.object(sonilo, "generate_sfx", return_value=""), \
+                mock.patch.object(sonilo, "_mix_sfx_under_original") as mix_mock:
+            self.assertEqual(
+                "", sonilo.apply_sfx("/tmp/combined.mp4", "/tmp/merger_sfx.mp4")
+            )
+            mix_mock.assert_not_called()
+
+    def test_mixing_failure_returns_empty(self):
+        with mock.patch.object(
+            sonilo, "generate_sfx", return_value="/tmp/merger_sfx.m4a"
+        ), mock.patch.object(sonilo, "_mix_sfx_under_original", return_value=""):
+            self.assertEqual(
+                "", sonilo.apply_sfx("/tmp/combined.mp4", "/tmp/merger_sfx.mp4")
+            )
+
+
+class ApplySoniloSfxTaskTests(unittest.TestCase):
+    """任务层的音效挂载：默认关闭，失败时沿用原视频，绝不中断成片任务。"""
+
+    def _make_params(self, sfx_enabled):
+        params = mock.Mock()
+        params.sonilo_sfx_enabled = sfx_enabled
+        return params
+
+    def test_disabled_returns_original_path_without_calling_sonilo(self):
+        from app.services import task
+
+        params = self._make_params(False)
+        with mock.patch.object(task.sonilo, "apply_sfx") as apply_mock:
+            result = task._apply_sonilo_sfx("task-id", params, "/tmp/merger.mp4")
+
+        self.assertEqual("/tmp/merger.mp4", result)
+        apply_mock.assert_not_called()
+
+    def test_enabled_returns_sfx_video_path(self):
+        from app.services import task
+
+        params = self._make_params(True)
+        with mock.patch.object(task.utils, "task_dir", return_value="/tmp/task-id"), \
+                mock.patch.object(
+                    task.sonilo, "apply_sfx", return_value="/tmp/task-id/merger_sfx.mp4"
+                ) as apply_mock:
+            result = task._apply_sonilo_sfx("task-id", params, "/tmp/merger.mp4")
+
+        self.assertEqual("/tmp/task-id/merger_sfx.mp4", result)
+        apply_mock.assert_called_once_with(
+            "/tmp/merger.mp4", os.path.join("/tmp/task-id", "merger_sfx.mp4")
+        )
+
+    def test_failure_falls_back_to_original_path(self):
+        from app.services import task
+
+        params = self._make_params(True)
+        with mock.patch.object(task.utils, "task_dir", return_value="/tmp/task-id"), \
+                mock.patch.object(task.sonilo, "apply_sfx", return_value=""):
+            result = task._apply_sonilo_sfx("task-id", params, "/tmp/merger.mp4")
+
+        self.assertEqual("/tmp/merger.mp4", result)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_streamlit_widget_session_state.py

@@ -0,0 +1,84 @@
+"""Regression coverage for Streamlit widget state initialization."""
+
+import ast
+from pathlib import Path
+
+import pytest
+
+
+PROJECT_ROOT = Path(__file__).parents[1]
+
+
+def _attribute_name(node: ast.expr) -> str | None:
+    if isinstance(node, ast.Name):
+        return node.id
+    if isinstance(node, ast.Attribute):
+        parent = _attribute_name(node.value)
+        return f"{parent}.{node.attr}" if parent else node.attr
+    return None
+
+
+def _session_state_key(target: ast.expr) -> str | None:
+    if not isinstance(target, ast.Subscript):
+        return None
+    if _attribute_name(target.value) != "st.session_state":
+        return None
+    if isinstance(target.slice, ast.Constant) and isinstance(target.slice.value, str):
+        return target.slice.value
+    return None
+
+
+@pytest.mark.parametrize(
+    ("source_path", "function_name", "widget_key"),
+    [
+        (
+            "webui/components/audio_settings.py",
+            "render_bgm_settings",
+            "bgm_source_selection",
+        ),
+        (
+            "webui/components/subtitle_settings.py",
+            "_render_subtitle_preview_image",
+            "subtitle_preview_orientation",
+        ),
+    ],
+)
+def test_state_initialized_widgets_do_not_also_declare_defaults(
+    source_path: str,
+    function_name: str,
+    widget_key: str,
+):
+    """Streamlit warns when a keyed widget has both a default and state value."""
+    module = ast.parse((PROJECT_ROOT / source_path).read_text(encoding="utf-8"))
+    function = next(
+        node
+        for node in module.body
+        if isinstance(node, ast.FunctionDef) and node.name == function_name
+    )
+
+    assigned_keys = {
+        key
+        for node in ast.walk(function)
+        if isinstance(node, ast.Assign)
+        for target in node.targets
+        if (key := _session_state_key(target)) is not None
+    }
+    assert widget_key in assigned_keys
+
+    widget_calls = []
+    for node in ast.walk(function):
+        if not isinstance(node, ast.Call):
+            continue
+        widget_name = _attribute_name(node.func)
+        keywords = {keyword.arg: keyword.value for keyword in node.keywords}
+        key_node = keywords.get("key")
+        if (
+            widget_name is not None
+            and widget_name.startswith("st.")
+            and isinstance(key_node, ast.Constant)
+            and key_node.value == widget_key
+        ):
+            widget_calls.append(keywords)
+
+    assert widget_calls
+    assert all("default" not in keywords for keywords in widget_calls)

webui/components/audio_settings.py

@@ -3,13 +3,14 @@ import os
 import shutil
 import json
 from uuid import uuid4
+from loguru import logger
 from app.config import config
-from app.services import voice
+from app.services import sonilo, voice
 from app.models.schema import AudioVolumeDefaults
 from app.utils import utils
 
 
-INDEXTTS_REFERENCE_AUDIO_SOURCE_DIR = "/Users/viccy/Downloads/tts-mp3-clone/mp3"
+INDEXTTS_REFERENCE_AUDIO_SOURCE_DIR = utils.resource_dir("tts_reference_audio")
 INDEXTTS_REFERENCE_AUDIO_COPY_SUBDIR = "indextts_refs"
 INDEXTTS_REFERENCE_AUDIO_MAP = [
     ("yingshijieshuo-zh-male.mp3", "影视解说", "Film Narration"),
@@ -36,17 +37,32 @@ INDEXTTS_REFERENCE_AUDIO_MAP = [
     ("sarah-en-female.mp3", "莎拉", "Sarah"),
 ]
 INDEXTTS_REFERENCE_AUDIO_EXTENSIONS = (".mp3", ".wav", ".flac", ".m4a", ".aac", ".ogg")
-BGM_RESOURCE_DIR = "/Users/viccy/Downloads/tts-mp3-clone/bgms-safe"
+BGM_RESOURCE_DIR = utils.resource_dir("bgm")
 BGM_TRACKS_JSON = os.path.join(BGM_RESOURCE_DIR, "tracks.json")
 BGM_UPLOAD_SUBDIR = "uploaded_bgms"
 BGM_AUDIO_EXTENSIONS = (".mp3", ".wav", ".flac", ".m4a", ".aac", ".ogg")
 LOCAL_TTS_ENGINES = {
     config.INDEXTTS_ENGINE,
+    config.INDEXTTS_MACOS_ENGINE,
     config.INDEXTTS2_ENGINE,
     config.OMNIVOICE_ENGINE,
+    config.VOXCPM_ENGINE,
+    config.VOXCPM2_ENGINE,
 }
 
 
+def _normalize_source_pills_value(value, option_labels, default_value, tr=lambda key: key):
+    if value in option_labels:
+        return value
+
+    label_values = {}
+    for option_value, label_key in option_labels.items():
+        label_values[label_key] = option_value
+        label_values[tr(label_key)] = option_value
+
+    return label_values.get(str(value), default_value)
+
+
 def get_soulvoice_voices():
     """获取 SoulVoice 语音列表"""
     # 检查是否配置了 SoulVoice API key
@@ -62,8 +78,11 @@ def get_tts_engine_options(tr=lambda key: key):
     """获取TTS引擎选项"""
     engine_options = {
         config.INDEXTTS_ENGINE: config.INDEXTTS_DISPLAY_NAME,
+        config.INDEXTTS_MACOS_ENGINE: config.INDEXTTS_MACOS_DISPLAY_NAME,
         config.INDEXTTS2_ENGINE: config.INDEXTTS2_DISPLAY_NAME,
         config.OMNIVOICE_ENGINE: config.OMNIVOICE_DISPLAY_NAME,
+        config.VOXCPM_ENGINE: config.VOXCPM_DISPLAY_NAME,
+        config.VOXCPM2_ENGINE: config.VOXCPM2_DISPLAY_NAME,
         "edge_tts": "Edge TTS",
         "qwen3_tts": tr("Tongyi Qwen3 TTS"),
         "tencent_tts": tr("Tencent Cloud TTS"),
@@ -124,6 +143,12 @@ def get_tts_engine_descriptions(tr=lambda key: key):
             "use_case": tr("IndexTTS use case"),
             "registration": None
         },
+        config.INDEXTTS_MACOS_ENGINE: {
+            "title": config.INDEXTTS_MACOS_DISPLAY_NAME,
+            "features": tr("IndexTTS macOS features"),
+            "use_case": tr("IndexTTS macOS use case"),
+            "registration": None
+        },
         config.INDEXTTS2_ENGINE: {
             "title": config.INDEXTTS2_DISPLAY_NAME,
             "features": tr("IndexTTS2 features"),
@@ -136,6 +161,18 @@ def get_tts_engine_descriptions(tr=lambda key: key):
             "use_case": tr("OmniVoice use case"),
             "registration": None
         },
+        config.VOXCPM_ENGINE: {
+            "title": config.VOXCPM_DISPLAY_NAME,
+            "features": tr("VoxCPM features"),
+            "use_case": tr("VoxCPM use case"),
+            "registration": None,
+        },
+        config.VOXCPM2_ENGINE: {
+            "title": config.VOXCPM2_DISPLAY_NAME,
+            "features": tr("VoxCPM2 features"),
+            "use_case": tr("VoxCPM2 use case"),
+            "registration": None,
+        },
         "doubaotts": {
             "title": tr("Doubao TTS"),
             "features": tr("Doubao TTS features"),
@@ -380,34 +417,35 @@ def render_reference_audio_preview_button(reference_audio, key, tr, preview_stat
 def render_indextts_reference_audio_selector(tr, tts_config, key_prefix):
     """渲染 IndexTTS 系列共用的参考音频选择器。"""
     saved_reference_audio = tts_config.get("reference_audio", "")
-    reference_audio_source_options = {
+    reference_audio_source_labels = {
-        tr("Select from Resource Directory"): "resource",
+        "resource": "Select from Resource Directory",
-        tr("Upload Reference Audio"): "upload",
+        "upload": "Upload Reference Audio",
     }
-    reference_audio_source_labels = list(reference_audio_source_options.keys())
     saved_reference_audio_source = tts_config.get("reference_audio_source", "resource")
-    if saved_reference_audio_source not in reference_audio_source_options.values():
+    if saved_reference_audio_source not in reference_audio_source_labels:
         saved_reference_audio_source = "resource"
-    default_reference_audio_source_label = next(
+    reference_audio_source_key = f"{key_prefix}_reference_audio_source_selection"
-        label
+    default_reference_audio_source = _normalize_source_pills_value(
-        for label, source_value in reference_audio_source_options.items()
+        st.session_state.get(reference_audio_source_key, saved_reference_audio_source),
-        if source_value == saved_reference_audio_source
+        reference_audio_source_labels,
+        saved_reference_audio_source,
+        tr,
     )
+    st.session_state[reference_audio_source_key] = default_reference_audio_source
 
     st.markdown(f"**{tr('Reference Audio Path')}**")
-    reference_audio_source_label = st.pills(
+    reference_audio_source = st.pills(
         tr("Reference Audio Source"),
-        options=reference_audio_source_labels,
+        options=list(reference_audio_source_labels.keys()),
         selection_mode="single",
-        default=default_reference_audio_source_label,
+        key=reference_audio_source_key,
-        key=f"{key_prefix}_reference_audio_source_selection",
+        format_func=lambda source: tr(reference_audio_source_labels[source]),
         help=tr("Reference Audio Source Help"),
         label_visibility="collapsed",
         width="stretch",
     )
-    if not reference_audio_source_label:
+    if not reference_audio_source:
-        reference_audio_source_label = default_reference_audio_source_label
+        reference_audio_source = default_reference_audio_source
-    reference_audio_source = reference_audio_source_options[reference_audio_source_label]
 
     reference_audio = saved_reference_audio
     preview_state_key = f"{key_prefix}_reference_audio_preview_path"
@@ -511,6 +549,9 @@ def render_audio_panel(tr):
     # 背景音乐独立成框，放在音频设置下方
     render_bgm_panel(tr)
 
+    # AI 音效独立成框（可选功能，默认关闭）
+    render_sonilo_sfx_panel(tr)
+
 
 def render_bgm_panel(tr):
     """渲染背景音乐设置面板"""
@@ -518,6 +559,12 @@ def render_bgm_panel(tr):
         render_bgm_settings(tr)
 
 
+def render_sonilo_sfx_panel(tr):
+    """渲染 Sonilo AI 音效设置面板（可选功能，默认关闭）"""
+    with st.container(border=True):
+        render_sonilo_sfx_settings(tr)
+
+
 def render_tts_settings(tr):
     """渲染TTS(文本转语音)设置"""
 
@@ -575,10 +622,16 @@ def render_tts_settings(tr):
         render_qwen3_tts_settings(tr)
     elif selected_engine == config.INDEXTTS_ENGINE:
         render_indextts_tts_settings(tr)
+    elif selected_engine == config.INDEXTTS_MACOS_ENGINE:
+        render_indextts_macos_tts_settings(tr)
     elif selected_engine == config.INDEXTTS2_ENGINE:
         render_indextts2_tts_settings(tr)
     elif selected_engine == config.OMNIVOICE_ENGINE:
         render_omnivoice_tts_settings(tr)
+    elif selected_engine == config.VOXCPM_ENGINE:
+        render_voxcpm_tts_settings(tr)
+    elif selected_engine == config.VOXCPM2_ENGINE:
+        render_voxcpm2_tts_settings(tr)
     elif selected_engine == "doubaotts":
         render_doubaotts_settings(tr)
 
@@ -1109,11 +1162,115 @@ def render_indextts_tts_settings(tr):
         config.ui["voice_name"] = f"{config.INDEXTTS_VOICE_PREFIX}{reference_audio}"
 
 
-def render_indextts2_tts_settings(tr):
+def render_indextts_macos_tts_settings(tr):
-    """渲染 IndexTTS-2 TTS 设置"""
+    """渲染 IndexTTS-1.5 macOS MLX Pack 设置。"""
+    tts_config = config.indextts_macos
+
+    def bounded_value(key, default, min_value, max_value):
+        try:
+            value = float(tts_config.get(key, default))
+        except (TypeError, ValueError):
+            value = default
+        return max(min_value, min(max_value, value))
+
     api_url = st.text_input(
         tr("API URL"),
-        value=config.indextts2.get("api_url", "http://192.168.3.6:7863/tts"),
+        value=tts_config.get("api_url", "http://127.0.0.1:7866"),
+        help=tr("IndexTTS macOS API URL Help"),
+    )
+    reference_audio_source, reference_audio = render_indextts_reference_audio_selector(
+        tr,
+        tts_config,
+        "indextts_macos",
+    )
+
+    speed = st.slider(
+        tr("IndexTTS2 Speed"),
+        min_value=0.5,
+        max_value=2.0,
+        value=bounded_value("speed", 1.0, 0.5, 2.0),
+        step=0.05,
+        help=tr("IndexTTS2 Speed Help"),
+    )
+    seed = st.text_input(
+        tr("IndexTTS2 Seed"),
+        value=str(tts_config.get("seed", "") or ""),
+        help=tr("IndexTTS2 Seed Help"),
+        placeholder=tr("IndexTTS2 Seed Placeholder"),
+    )
+
+    with st.expander(tr("Advanced Parameters"), expanded=False):
+        col1, col2 = st.columns(2)
+        with col1:
+            temperature = st.slider(
+                tr("Sampling Temperature"), 0.0, 2.0,
+                bounded_value("temperature", 1.0, 0.0, 2.0), 0.05,
+            )
+            top_p = st.slider(
+                "Top P", 0.05, 1.0,
+                bounded_value("top_p", 0.8, 0.05, 1.0), 0.05,
+            )
+            top_k = st.slider(
+                "Top K", 0, 200,
+                int(bounded_value("top_k", 30, 0, 200)), 1,
+            )
+            max_text_tokens_per_segment = st.slider(
+                tr("Max Text Tokens Per Segment"), 20, 600,
+                int(bounded_value("max_text_tokens_per_segment", 120, 20, 600)), 10,
+            )
+        with col2:
+            repetition_penalty = st.slider(
+                tr("Repetition Penalty"), 1.0, 20.0,
+                bounded_value("repetition_penalty", 10.0, 1.0, 20.0), 0.1,
+            )
+            max_mel_tokens = st.slider(
+                tr("Max Mel Tokens"), 64, 1600,
+                int(bounded_value("max_mel_tokens", 800, 64, 1600)), 1,
+            )
+            interval_silence = st.slider(
+                tr("Interval Silence"), 0, 2000,
+                int(bounded_value("interval_silence", 200, 0, 2000)), 50,
+            )
+            segment_overlap_ms = st.slider(
+                tr("Segment Overlap"), 0, 500,
+                int(bounded_value("segment_overlap_ms", 50, 0, 500)), 10,
+            )
+
+    with st.expander(tr("IndexTTS macOS Usage Instructions Title"), expanded=False):
+        st.markdown(tr("IndexTTS macOS Usage Instructions"))
+
+    tts_config["api_url"] = api_url
+    tts_config["reference_audio_source"] = reference_audio_source
+    tts_config["reference_audio"] = reference_audio
+    tts_config["speed"] = speed
+    tts_config["seed"] = seed.strip()
+    tts_config["temperature"] = temperature
+    tts_config["top_p"] = top_p
+    tts_config["top_k"] = top_k
+    tts_config["max_text_tokens_per_segment"] = max_text_tokens_per_segment
+    tts_config["repetition_penalty"] = repetition_penalty
+    tts_config["max_mel_tokens"] = max_mel_tokens
+    tts_config["interval_silence"] = interval_silence
+    tts_config["segment_overlap_ms"] = segment_overlap_ms
+    if reference_audio:
+        config.ui["voice_name"] = f"{config.INDEXTTS_MACOS_VOICE_PREFIX}{reference_audio}"
+    st.session_state["voice_rate"] = 1.0
+    st.session_state["voice_pitch"] = 1.0
+
+
+def render_indextts2_tts_settings(tr):
+    """渲染 IndexTTS-2 MLX Pack TTS 设置"""
+
+    def bounded_value(key, default, min_value, max_value):
+        try:
+            value = float(config.indextts2.get(key, default))
+        except (TypeError, ValueError):
+            value = default
+        return max(min_value, min(max_value, value))
+
+    api_url = st.text_input(
+        tr("API URL"),
+        value=config.indextts2.get("api_url", "http://127.0.0.1:7860"),
         help=tr("IndexTTS2 API URL Help")
     )
 
@@ -1122,108 +1279,43 @@ def render_indextts2_tts_settings(tr):
         config.indextts2,
         "indextts2",
     )
-
+    initial_emotion = config.get_indextts2_pack_emotion(config.indextts2)
-    emotion_mode_options = [
+    legacy_emotion_audio = (
-        ("speaker", tr("Emotion Mode Speaker")),
+        config.indextts2.get("emotion_mode") == "audio"
-        ("audio", tr("Emotion Mode Audio")),
+        and bool(config.indextts2.get("emotion_audio"))
-        ("vector", tr("Emotion Mode Vector")),
+    )
-        ("text", tr("Emotion Mode Text")),
-    ]
-    saved_emotion_mode = config.indextts2.get("emotion_mode", "speaker")
-    emotion_mode_values = [item[0] for item in emotion_mode_options]
-    if saved_emotion_mode not in emotion_mode_values:
-        saved_emotion_mode = "speaker"
 
     with st.expander(tr("IndexTTS2 Emotion Parameters"), expanded=False):
-        emotion_mode = emotion_mode_options[st.selectbox(
+        emotion = st.text_input(
-            tr("Emotion Mode"),
+            tr("IndexTTS2 Emotion"),
-            options=range(len(emotion_mode_options)),
+            value=initial_emotion,
-            index=emotion_mode_values.index(saved_emotion_mode),
+            help=tr("IndexTTS2 Emotion Help"),
-            format_func=lambda x: emotion_mode_options[x][1],
+            placeholder=tr("IndexTTS2 Emotion Placeholder"),
-            help=tr("Emotion Mode Help"),
+        )
-        )][0]
+        if legacy_emotion_audio and not emotion.strip():
-
+            st.warning(tr("IndexTTS2 Emotion Audio Unsupported"))
-        emotion_alpha = st.slider(
+        emo_alpha = st.slider(
             tr("Emotion Alpha"),
             min_value=0.0,
             max_value=1.0,
-            value=float(config.indextts2.get("emotion_alpha", 0.65)),
+            value=bounded_value("emo_alpha", config.indextts2.get("emotion_alpha", 0.6), 0.0, 1.0),
             step=0.05,
             help=tr("Emotion Alpha Help"),
         )
-
+        speed = st.slider(
-        emotion_audio = config.indextts2.get("emotion_audio", "")
+            tr("IndexTTS2 Speed"),
-        emotion_text = config.indextts2.get("emotion_text", "")
+            min_value=0.5,
-        if emotion_mode == "audio":
+            max_value=2.0,
-            emotion_audio_col, emotion_preview_col = st.columns([5, 1])
+            value=bounded_value("speed", 1.0, 0.5, 2.0),
-            with emotion_audio_col:
-                emotion_audio = st.text_input(
-                    tr("Emotion Reference Audio Path"),
-                    value=emotion_audio,
-                    help=tr("Emotion Reference Audio Path Help"),
-                )
-            with emotion_preview_col:
-                render_reference_audio_preview_button(
-                    emotion_audio,
-                    "indextts2_emotion_audio_preview",
-                    tr,
-                    preview_state_key="indextts2_emotion_audio_preview_path",
-                )
-            preview_audio_path = st.session_state.get("indextts2_emotion_audio_preview_path", "")
-            if preview_audio_path == emotion_audio and os.path.isfile(preview_audio_path):
-                with open(preview_audio_path, "rb") as audio_file:
-                    st.audio(audio_file.read(), format=get_audio_mime_type(preview_audio_path))
-        elif emotion_mode == "text":
-            emotion_text = st.text_input(
-                tr("Emotion Text"),
-                value=emotion_text,
-                help=tr("Emotion Text Help"),
-                placeholder=tr("Emotion Text Placeholder"),
-            )
-
-        use_random = st.checkbox(
-            tr("Use Random Emotion"),
-            value=bool(config.indextts2.get("use_random", False)),
-            help=tr("Use Random Emotion Help"),
-        )
-
-        emotion_vector_defaults = {
-            "vec_happy": 0.0,
-            "vec_angry": 0.0,
-            "vec_sad": 0.0,
-            "vec_afraid": 0.0,
-            "vec_disgusted": 0.0,
-            "vec_melancholic": 0.0,
-            "vec_surprised": 0.0,
-            "vec_calm": 0.8,
-        }
-        emotion_vector_labels = {
-            "vec_happy": tr("Emotion Happy"),
-            "vec_angry": tr("Emotion Angry"),
-            "vec_sad": tr("Emotion Sad"),
-            "vec_afraid": tr("Emotion Afraid"),
-            "vec_disgusted": tr("Emotion Disgusted"),
-            "vec_melancholic": tr("Emotion Melancholic"),
-            "vec_surprised": tr("Emotion Surprised"),
-            "vec_calm": tr("Emotion Calm"),
-        }
-        emotion_vector_values = {}
-        if emotion_mode == "vector":
-            vec_cols = st.columns(2)
-            for index, (field, default_value) in enumerate(emotion_vector_defaults.items()):
-                with vec_cols[index % 2]:
-                    emotion_vector_values[field] = st.slider(
-                        emotion_vector_labels[field],
-                        min_value=0.0,
-                        max_value=1.0,
-                        value=float(config.indextts2.get(field, default_value)),
             step=0.05,
+            help=tr("IndexTTS2 Speed Help"),
+        )
+        seed = st.text_input(
+            tr("IndexTTS2 Seed"),
+            value=str(config.indextts2.get("seed", "") or ""),
+            help=tr("IndexTTS2 Seed Help"),
+            placeholder=tr("IndexTTS2 Seed Placeholder"),
         )
-        else:
-            emotion_vector_values = {
-                field: float(config.indextts2.get(field, default_value))
-                for field, default_value in emotion_vector_defaults.items()
-            }
 
     with st.expander(tr("Advanced Parameters"), expanded=False):
         col1, col2 = st.columns(2)
@@ -1231,65 +1323,92 @@ def render_indextts2_tts_settings(tr):
         with col1:
             temperature = st.slider(
                 tr("Sampling Temperature"),
-                min_value=0.1,
+                min_value=0.05,
                 max_value=2.0,
-                value=float(config.indextts2.get("temperature", 0.8)),
+                value=bounded_value("temperature", 0.8, 0.05, 2.0),
-                step=0.1,
+                step=0.05,
                 help=tr("Sampling Temperature Help")
             )
 
             top_p = st.slider(
                 "Top P",
-                min_value=0.0,
+                min_value=0.05,
                 max_value=1.0,
-                value=float(config.indextts2.get("top_p", 0.8)),
+                value=bounded_value("top_p", 0.8, 0.05, 1.0),
                 step=0.05,
                 help=tr("Top P Help")
             )
 
             top_k = st.slider(
                 "Top K",
-                min_value=0,
+                min_value=1,
-                max_value=100,
+                max_value=200,
-                value=int(config.indextts2.get("top_k", 30)),
+                value=int(bounded_value("top_k", 30, 1, 200)),
-                step=5,
+                step=1,
-                help=tr("Top K Help")
+                help=tr("IndexTTS2 Top K Help")
             )
 
             max_text_tokens_per_segment = st.slider(
                 tr("Max Text Tokens Per Segment"),
                 min_value=20,
                 max_value=600,
-                value=int(config.indextts2.get("max_text_tokens_per_segment", 120)),
+                value=int(bounded_value("max_text_tokens_per_segment", 120, 20, 600)),
                 step=10,
                 help=tr("Max Text Tokens Per Segment Help")
             )
 
+            interval_silence = st.slider(
+                tr("Interval Silence"),
+                min_value=0,
+                max_value=5000,
+                value=int(bounded_value("interval_silence", 200, 0, 5000)),
+                step=50,
+                help=tr("Interval Silence Help"),
+            )
+
+            segment_overlap_ms = st.slider(
+                tr("Segment Overlap"),
+                min_value=0,
+                max_value=1000,
+                value=int(bounded_value("segment_overlap_ms", 50, 0, 1000)),
+                step=10,
+                help=tr("Segment Overlap Help"),
+            )
+
         with col2:
-            num_beams = st.slider(
+            diffusion_steps = st.slider(
-                tr("Num Beams"),
+                tr("Diffusion Steps"),
                 min_value=1,
-                max_value=10,
+                max_value=100,
-                value=int(config.indextts2.get("num_beams", 3)),
+                value=int(bounded_value("diffusion_steps", 25, 1, 100)),
                 step=1,
-                help=tr("Num Beams Help")
+                help=tr("Diffusion Steps Help")
+            )
+
+            cfg_rate = st.slider(
+                tr("CFG Rate"),
+                min_value=0.0,
+                max_value=2.0,
+                value=bounded_value("cfg_rate", 0.7, 0.0, 2.0),
+                step=0.05,
+                help=tr("CFG Rate Help"),
             )
 
             repetition_penalty = st.slider(
                 tr("Repetition Penalty"),
-                min_value=0.1,
+                min_value=1.0,
-                max_value=20.0,
+                max_value=30.0,
-                value=float(config.indextts2.get("repetition_penalty", 10.0)),
+                value=bounded_value("repetition_penalty", 10.0, 1.0, 30.0),
                 step=0.1,
                 help=tr("Repetition Penalty Help")
             )
 
             max_mel_tokens = st.slider(
                 tr("Max Mel Tokens"),
-                min_value=50,
+                min_value=64,
                 max_value=1815,
-                value=int(config.indextts2.get("max_mel_tokens", 1500)),
+                value=int(bounded_value("max_mel_tokens", 1500, 64, 1815)),
-                step=10,
+                step=1,
                 help=tr("Max Mel Tokens Help")
             )
 
@@ -1299,20 +1418,32 @@ def render_indextts2_tts_settings(tr):
     config.indextts2["api_url"] = api_url
     config.indextts2["reference_audio_source"] = reference_audio_source
     config.indextts2["reference_audio"] = reference_audio
-    config.indextts2["emotion_mode"] = emotion_mode
+    config.indextts2["emotion"] = emotion
-    config.indextts2["emotion_audio"] = emotion_audio
+    config.indextts2["emo_alpha"] = emo_alpha
-    config.indextts2["emotion_alpha"] = emotion_alpha
+    config.indextts2["speed"] = speed
-    config.indextts2["emotion_text"] = emotion_text
+    config.indextts2["seed"] = seed.strip()
-    config.indextts2["use_random"] = use_random
     config.indextts2["max_text_tokens_per_segment"] = max_text_tokens_per_segment
-    for field, value in emotion_vector_values.items():
+    config.indextts2["interval_silence"] = interval_silence
-        config.indextts2[field] = value
+    config.indextts2["segment_overlap_ms"] = segment_overlap_ms
     config.indextts2["temperature"] = temperature
     config.indextts2["top_p"] = top_p
     config.indextts2["top_k"] = top_k
-    config.indextts2["num_beams"] = num_beams
     config.indextts2["repetition_penalty"] = repetition_penalty
     config.indextts2["max_mel_tokens"] = max_mel_tokens
+    config.indextts2["diffusion_steps"] = diffusion_steps
+    config.indextts2["cfg_rate"] = cfg_rate
+
+    legacy_fields = (
+        "emotion_mode", "emotion_audio", "emotion_alpha", "emotion_text", "use_random",
+        "num_beams", "vec_happy", "vec_angry", "vec_sad", "vec_afraid",
+        "vec_disgusted", "vec_melancholic", "vec_surprised", "vec_calm",
+    )
+    if legacy_emotion_audio and not emotion.strip():
+        legacy_fields = tuple(
+            field for field in legacy_fields if field not in {"emotion_mode", "emotion_audio"}
+        )
+    for field in legacy_fields:
+        config.indextts2.pop(field, None)
 
     if reference_audio:
         config.ui["voice_name"] = f"{config.INDEXTTS2_VOICE_PREFIX}{reference_audio}"
@@ -1462,6 +1593,109 @@ def render_omnivoice_tts_settings(tr):
     st.session_state["voice_pitch"] = 1.0
 
 
+def render_voxcpm_tts_settings(tr):
+    """渲染 VoxCPM-0.5B-Pack 设置。"""
+    pack_config = config.voxcpm_05b
+    api_url = st.text_input(
+        tr("API URL"),
+        value=pack_config.get("api_url", "http://127.0.0.1:7864"),
+        help=tr("VoxCPM API URL Help"),
+    )
+    use_reference = st.checkbox(
+        tr("VoxCPM Use Reference Audio"),
+        value=bool(pack_config.get("reference_audio", "")),
+        help=tr("VoxCPM Use Reference Audio Help"),
+    )
+    source = pack_config.get("reference_audio_source", "resource")
+    reference_audio = pack_config.get("reference_audio", "")
+    prompt_text = pack_config.get("prompt_text", "")
+    if use_reference:
+        source, reference_audio = render_indextts_reference_audio_selector(tr, pack_config, "voxcpm_05b")
+        prompt_text = st.text_area(
+            tr("VoxCPM Prompt Text"), value=prompt_text,
+            help=tr("VoxCPM Prompt Text Help"), height=90,
+        )
+    else:
+        reference_audio = ""
+
+    with st.expander(tr("Advanced Parameters"), expanded=False):
+        cfg_value = st.slider("CFG Value", 1.0, 3.0, float(pack_config.get("cfg_value", 2.0)), 0.1)
+        inference_timesteps = st.slider("Inference Timesteps", 1, 50, int(pack_config.get("inference_timesteps", 10)), 1)
+        max_length = st.number_input("Max Length", 128, 8192, int(pack_config.get("max_length", 4096)), 128)
+        normalize = st.checkbox(tr("VoxCPM Normalize"), value=bool(pack_config.get("normalize", True)))
+        denoise = st.checkbox(tr("VoxCPM Denoise"), value=bool(pack_config.get("denoise", False)))
+
+    with st.expander(tr("VoxCPM Usage Instructions Title"), expanded=False):
+        st.markdown(tr("VoxCPM Usage Instructions"))
+
+    pack_config.update({
+        "api_url": api_url, "reference_audio_source": source,
+        "reference_audio": reference_audio, "prompt_text": prompt_text,
+        "cfg_value": cfg_value, "inference_timesteps": inference_timesteps,
+        "max_length": max_length, "normalize": normalize, "denoise": denoise,
+    })
+    config.ui["voice_name"] = f"{config.VOXCPM_VOICE_PREFIX}{reference_audio or 'default'}"
+    st.session_state["voice_rate"] = 1.0
+    st.session_state["voice_pitch"] = 1.0
+
+
+def render_voxcpm2_tts_settings(tr):
+    """渲染 VoxCPM-2B-Pack 设置。"""
+    pack_config = config.voxcpm_2b
+    api_url = st.text_input(
+        tr("API URL"), value=pack_config.get("api_url", "http://127.0.0.1:7863"),
+        help=tr("VoxCPM2 API URL Help"),
+    )
+    mode_options = [("design", tr("VoxCPM2 Mode Design")), ("clone", tr("VoxCPM2 Mode Clone"))]
+    mode_values = [item[0] for item in mode_options]
+    saved_mode = pack_config.get("mode", "design")
+    if saved_mode not in mode_values:
+        saved_mode = "design"
+    mode = mode_options[st.selectbox(
+        tr("VoxCPM2 Generation Mode"), options=range(len(mode_options)),
+        index=mode_values.index(saved_mode), format_func=lambda index: mode_options[index][1],
+        help=tr("VoxCPM2 Generation Mode Help"),
+    )][0]
+    control = st.text_area(
+        tr("VoxCPM2 Voice Control"), value=pack_config.get("control", ""),
+        help=tr("VoxCPM2 Voice Control Help"), height=80,
+    )
+    source = pack_config.get("reference_audio_source", "resource")
+    reference_audio = pack_config.get("reference_audio", "")
+    prompt_text = pack_config.get("prompt_text", "")
+    if mode == "clone":
+        source, reference_audio = render_indextts_reference_audio_selector(tr, pack_config, "voxcpm_2b")
+        prompt_text = st.text_area(
+            tr("VoxCPM Prompt Text"), value=prompt_text,
+            help=tr("VoxCPM Prompt Text Help"), height=90,
+        )
+    else:
+        reference_audio = ""
+
+    with st.expander(tr("Advanced Parameters"), expanded=False):
+        cfg_value = st.slider("CFG Value", 1.0, 3.0, float(pack_config.get("cfg_value", 2.0)), 0.1, key="voxcpm2_cfg")
+        inference_timesteps = st.slider("Inference Timesteps", 1, 50, int(pack_config.get("inference_timesteps", 10)), 1, key="voxcpm2_steps")
+        normalize = st.checkbox(tr("VoxCPM Normalize"), value=bool(pack_config.get("normalize", True)), key="voxcpm2_normalize")
+        denoise = st.checkbox(tr("VoxCPM Denoise"), value=bool(pack_config.get("denoise", False)), key="voxcpm2_denoise")
+        output_48k = st.checkbox(tr("VoxCPM2 Output 48k"), value=bool(pack_config.get("output_48k", True)))
+        context_aware = st.checkbox(tr("VoxCPM2 Context Aware"), value=bool(pack_config.get("context_aware", True)))
+        streaming = st.checkbox(tr("VoxCPM2 Streaming"), value=bool(pack_config.get("streaming", False)))
+
+    with st.expander(tr("VoxCPM2 Usage Instructions Title"), expanded=False):
+        st.markdown(tr("VoxCPM2 Usage Instructions"))
+    pack_config.update({
+        "api_url": api_url, "mode": mode, "control": control,
+        "reference_audio_source": source, "reference_audio": reference_audio,
+        "prompt_text": prompt_text, "cfg_value": cfg_value,
+        "inference_timesteps": inference_timesteps, "normalize": normalize,
+        "denoise": denoise, "output_48k": output_48k,
+        "context_aware": context_aware, "streaming": streaming,
+    })
+    config.ui["voice_name"] = f"{config.VOXCPM2_VOICE_PREFIX}{reference_audio if mode == 'clone' else mode}"
+    st.session_state["voice_rate"] = 1.0
+    st.session_state["voice_pitch"] = 1.0
+
+
 def render_doubaotts_settings(tr):
     """渲染豆包语音 TTS 设置"""
     api_key = st.text_input(
@@ -1753,6 +1987,12 @@ def render_voice_preview_new(tr, selected_engine):
                 voice_name = f"{config.INDEXTTS_VOICE_PREFIX}{reference_audio}"
             voice_rate = 1.0  # IndexTTS-1.5 不支持速度调节
             voice_pitch = 1.0  # IndexTTS-1.5 不支持音调调节
+        elif selected_engine == config.INDEXTTS_MACOS_ENGINE:
+            reference_audio = config.indextts_macos.get("reference_audio", "")
+            if reference_audio:
+                voice_name = f"{config.INDEXTTS_MACOS_VOICE_PREFIX}{reference_audio}"
+            voice_rate = 1.0  # 语速由 macOS Pack 配置传递
+            voice_pitch = 1.0
         elif selected_engine == config.INDEXTTS2_ENGINE:
             reference_audio = config.indextts2.get("reference_audio", "")
             if reference_audio:
@@ -1768,6 +2008,17 @@ def render_voice_preview_new(tr, selected_engine):
                 voice_name = f"{config.OMNIVOICE_VOICE_PREFIX}{mode}"
             voice_rate = config.omnivoice.get("speed", 1.0)
             voice_pitch = 1.0
+        elif selected_engine == config.VOXCPM_ENGINE:
+            reference_audio = config.voxcpm_05b.get("reference_audio", "")
+            voice_name = f"{config.VOXCPM_VOICE_PREFIX}{reference_audio or 'default'}"
+            voice_rate = 1.0
+            voice_pitch = 1.0
+        elif selected_engine == config.VOXCPM2_ENGINE:
+            mode = config.voxcpm_2b.get("mode", "design")
+            reference_audio = config.voxcpm_2b.get("reference_audio", "")
+            voice_name = f"{config.VOXCPM2_VOICE_PREFIX}{reference_audio if mode == 'clone' else mode}"
+            voice_rate = 1.0
+            voice_pitch = 1.0
         elif selected_engine == "doubaotts":
             voice_type = config.ui.get("doubaotts_voice_type", "BV700_streaming")
             voice_name = voice_type
@@ -1782,8 +2033,11 @@ def render_voice_preview_new(tr, selected_engine):
             temp_dir = utils.storage_dir("temp", create=True)
             audio_format = "audio/wav" if selected_engine in (
                 config.INDEXTTS_ENGINE,
+                config.INDEXTTS_MACOS_ENGINE,
                 config.INDEXTTS2_ENGINE,
                 config.OMNIVOICE_ENGINE,
+                config.VOXCPM_ENGINE,
+                config.VOXCPM2_ENGINE,
             ) else "audio/mp3"
             audio_extension = ".wav" if audio_format == "audio/wav" else ".mp3"
             audio_file = os.path.join(temp_dir, f"tmp-voice-{str(uuid4())}{audio_extension}")
@@ -1924,42 +2178,133 @@ def render_voice_preview(tr, voice_name):
                 st.error(tr("Voice synthesis failed"))
 
 
+def render_sonilo_bgm_settings(tr):
+    """渲染 Sonilo AI 配乐设置（可选功能，默认关闭）"""
+    # 避免在本模块顶层引入 basic_settings 的重依赖链，按需导入。
+    from webui.components.basic_settings import update_app_config_if_changed
+
+    st.info(tr("Sonilo BGM Notice"))
+
+    sonilo_api_key = st.text_input(
+        tr("Sonilo API Key"),
+        value=config.app.get("sonilo_api_key", ""),
+        type="password",
+        help=tr("Sonilo API Key Help"),
+        key="sonilo_api_key_input",
+    )
+    sonilo_bgm_prompt = st.text_input(
+        tr("Sonilo BGM Prompt"),
+        value=config.app.get("sonilo_bgm_prompt", ""),
+        help=tr("Sonilo BGM Prompt Help"),
+        key="sonilo_bgm_prompt_input",
+    )
+
+    api_key_changed = update_app_config_if_changed(
+        "sonilo_api_key", str(sonilo_api_key or "").strip()
+    )
+    prompt_changed = update_app_config_if_changed(
+        "sonilo_bgm_prompt", str(sonilo_bgm_prompt or "").strip()
+    )
+    if api_key_changed or prompt_changed:
+        try:
+            config.save_config()
+            st.success(tr("Sonilo config saved"))
+        except Exception as e:
+            st.error(f"{tr('Failed to save config')}: {str(e)}")
+            logger.error(f"保存 Sonilo 配置失败: {str(e)}")
+
+    if not sonilo.is_enabled():
+        st.warning(tr("Sonilo API Key Required"))
+
+
+def render_sonilo_sfx_settings(tr):
+    """渲染 Sonilo AI 音效设置（可选功能，默认关闭）"""
+    # 避免在本模块顶层引入 basic_settings 的重依赖链，按需导入。
+    from webui.components.basic_settings import update_app_config_if_changed
+
+    sfx_enabled = st.checkbox(
+        tr("Sonilo AI Sound Effects"),
+        value=bool(st.session_state.get("sonilo_sfx_enabled", False)),
+        help=tr("Sonilo SFX Help"),
+        key="sonilo_sfx_enabled_checkbox",
+    )
+    st.session_state["sonilo_sfx_enabled"] = bool(sfx_enabled)
+    if not sfx_enabled:
+        return
+
+    st.info(tr("Sonilo SFX Notice"))
+
+    sonilo_api_key = st.text_input(
+        tr("Sonilo API Key"),
+        value=config.app.get("sonilo_api_key", ""),
+        type="password",
+        help=tr("Sonilo API Key Help"),
+        key="sonilo_sfx_api_key_input",
+    )
+    sonilo_sfx_prompt = st.text_input(
+        tr("Sonilo SFX Prompt"),
+        value=config.app.get("sonilo_sfx_prompt", ""),
+        help=tr("Sonilo SFX Prompt Help"),
+        key="sonilo_sfx_prompt_input",
+    )
+
+    api_key_changed = update_app_config_if_changed(
+        "sonilo_api_key", str(sonilo_api_key or "").strip()
+    )
+    prompt_changed = update_app_config_if_changed(
+        "sonilo_sfx_prompt", str(sonilo_sfx_prompt or "").strip()
+    )
+    if api_key_changed or prompt_changed:
+        try:
+            config.save_config()
+            st.success(tr("Sonilo config saved"))
+        except Exception as e:
+            st.error(f"{tr('Failed to save config')}: {str(e)}")
+            logger.error(f"保存 Sonilo 配置失败: {str(e)}")
+
+    if not sonilo.is_enabled():
+        st.warning(tr("Sonilo SFX API Key Required"))
+
+
 def render_bgm_settings(tr):
     """渲染背景音乐设置"""
     saved_bgm_file = st.session_state.get('bgm_file', '')
     saved_bgm_source = st.session_state.get('bgm_source', 'resource')
     if st.session_state.get('bgm_type') == "":
         saved_bgm_source = "none"
+    elif st.session_state.get('bgm_type') == "sonilo":
+        saved_bgm_source = "sonilo"
 
-    bgm_source_options = {
+    bgm_source_labels = {
-        tr("Select from Resource Directory"): "resource",
+        "resource": "Select from Resource Directory",
-        tr("Upload Background Music"): "upload",
+        "upload": "Upload Background Music",
-        tr("No Background Music"): "none",
+        "sonilo": "Sonilo AI Background Music",
+        "none": "No Background Music",
     }
-    if saved_bgm_source not in bgm_source_options.values():
+    if saved_bgm_source not in bgm_source_labels:
         saved_bgm_source = "resource"
 
-    default_bgm_source_label = next(
+    default_bgm_source = _normalize_source_pills_value(
-        label
+        st.session_state.get("bgm_source_selection", saved_bgm_source),
-        for label, source_value in bgm_source_options.items()
+        bgm_source_labels,
-        if source_value == saved_bgm_source
+        saved_bgm_source,
+        tr,
     )
+    st.session_state["bgm_source_selection"] = default_bgm_source
 
     st.markdown(f"**{tr('Background Music')}**")
-    bgm_source_label = st.pills(
+    bgm_source = st.pills(
         tr("Background Music Source"),
-        options=list(bgm_source_options.keys()),
+        options=list(bgm_source_labels.keys()),
         selection_mode="single",
-        default=default_bgm_source_label,
         key="bgm_source_selection",
+        format_func=lambda source: tr(bgm_source_labels[source]),
         help=tr("Background Music Source Help"),
         label_visibility="collapsed",
         width="stretch",
     )
-    if not bgm_source_label:
+    if not bgm_source:
-        bgm_source_label = default_bgm_source_label
+        bgm_source = default_bgm_source
-
-    bgm_source = bgm_source_options[bgm_source_label]
     bgm_file = ""
     bgm_name = ""
 
@@ -2016,11 +2361,17 @@ def render_bgm_settings(tr):
                 tr,
             )
 
+    if bgm_source == "sonilo":
+        render_sonilo_bgm_settings(tr)
+
     preview_bgm_path = st.session_state.get("bgm_preview_path", "")
     if preview_bgm_path == bgm_file and os.path.isfile(preview_bgm_path):
         with open(preview_bgm_path, "rb") as audio_file:
             st.audio(audio_file.read(), format=get_audio_mime_type(preview_bgm_path))
 
+    if bgm_source == "sonilo":
+        bgm_type = "sonilo"
+    else:
         bgm_type = "" if bgm_source == "none" or not bgm_file else "custom"
     st.session_state['bgm_source'] = bgm_source
     st.session_state['bgm_type'] = bgm_type
@@ -2050,5 +2401,6 @@ def get_audio_params():
         'bgm_type': st.session_state.get('bgm_type', 'random'),
         'bgm_file': st.session_state.get('bgm_file', ''),
         'bgm_volume': st.session_state.get('bgm_volume', AudioVolumeDefaults.BGM_VOLUME),
+        'sonilo_sfx_enabled': bool(st.session_state.get('sonilo_sfx_enabled', False)),
         'tts_engine': st.session_state.get('tts_engine', config.INDEXTTS_ENGINE),
     }

webui/components/basic_settings.py

@@ -9,12 +9,17 @@ from app.config.defaults import (
     DEFAULT_OPENAI_COMPATIBLE_BASE_URL,
     DEFAULT_OPENAI_COMPATIBLE_PROVIDER,
     DEFAULT_TEXT_LLM_PROVIDER,
+    DEFAULT_TEXT_OPENAI_FAST_MODEL_NAME,
     DEFAULT_TEXT_OPENAI_MODEL_NAME,
     DEFAULT_VISION_LLM_PROVIDER,
     DEFAULT_VISION_OPENAI_MODEL_NAME,
     get_openai_compatible_ui_values,
     normalize_openai_compatible_model_name as normalize_openai_compatible_model_id,
 )
+from app.utils.openai_base_url_security import (
+    openai_compatible_base_url_warning,
+    validate_openai_compatible_base_url,
+)
 from app.utils import utils
 from loguru import logger
 from app.services.llm.unified_service import UnifiedLLMService
@@ -73,9 +78,20 @@ def validate_base_url(base_url: str, provider: str) -> tuple[bool, str]:
     if not (base_url.startswith('http://') or base_url.startswith('https://')):
         return False, f"{provider} Base URL必须以http://或https://开头"
 
+    try:
+        validate_openai_compatible_base_url(base_url)
+    except ValueError as exc:
+        return False, f"{provider} Base URL格式无效: {exc}"
+
     return True, ""
 
 
+def show_base_url_security_warning(base_url: str) -> None:
+    warning = openai_compatible_base_url_warning(base_url)
+    if warning:
+        st.warning(warning)
+
+
 def validate_model_name(model_name: str, provider: str) -> tuple[bool, str]:
     """验证模型名称"""
     if not model_name or not model_name.strip():
@@ -420,6 +436,7 @@ def test_vision_model_connection(api_key, base_url, model_name, provider, tr):
     elif provider.lower() == 'gemini(openai)':
         # OpenAI兼容的Gemini代理测试
         try:
+            base_url = validate_openai_compatible_base_url(base_url)
             headers = {
                 "Authorization": f"Bearer {api_key}",
                 "Content-Type": "application/json"
@@ -444,6 +461,7 @@ def test_vision_model_connection(api_key, base_url, model_name, provider, tr):
     else:
         from openai import OpenAI
         try:
+            base_url = validate_openai_compatible_base_url(base_url)
             client = OpenAI(
                 api_key=api_key,
                 base_url=base_url,
@@ -493,9 +511,10 @@ def test_openai_compatible_vision_model(api_key: str, base_url: str, model_name:
         from PIL import Image
 
         logger.debug(
-            f"OpenAI 兼容视觉模型连通性测试: model={model_name}, api_key={api_key[:10]}..., base_url={base_url}"
+            f"OpenAI 兼容视觉模型连通性测试: model={model_name}, base_url={base_url}"
         )
 
+        base_url = validate_openai_compatible_base_url(base_url)
         client = OpenAI(
             api_key=api_key,
             base_url=base_url or None,
@@ -548,9 +567,10 @@ def test_openai_compatible_text_model(api_key: str, base_url: str, model_name: s
         from openai import OpenAI
 
         logger.debug(
-            f"OpenAI 兼容文本模型连通性测试: model={model_name}, api_key={api_key[:10]}..., base_url={base_url}"
+            f"OpenAI 兼容文本模型连通性测试: model={model_name}, base_url={base_url}"
         )
 
+        base_url = validate_openai_compatible_base_url(base_url)
         client = OpenAI(
             api_key=api_key,
             base_url=base_url or None,
@@ -653,6 +673,7 @@ def render_vision_llm_settings(tr):
     if vision_base_required and not st_vision_base_url:
         info_example = vision_placeholder or "https://your-openai-compatible-endpoint/v1"
         st.info(tr("Please fill OpenAI compatible gateway").format(example=info_example))
+    show_base_url_security_warning(st_vision_base_url)
 
     vision_generation_params = render_llm_generation_settings(tr, "vision")
 
@@ -856,6 +877,10 @@ def render_text_llm_settings(tr):
 
     # 获取已保存的配置
     full_text_model_name = config.app.get("text_openai_model_name") or DEFAULT_TEXT_OPENAI_MODEL_NAME
+    full_fast_model_name = (
+        config.app.get("text_openai_fast_model_name")
+        or DEFAULT_TEXT_OPENAI_FAST_MODEL_NAME
+    )
     text_api_key = config.app.get("text_openai_api_key", "")
     text_base_url = config.app.get("text_openai_base_url", DEFAULT_OPENAI_COMPATIBLE_BASE_URL)
 
@@ -865,10 +890,14 @@ def render_text_llm_settings(tr):
         DEFAULT_TEXT_OPENAI_MODEL_NAME,
         provider=DEFAULT_TEXT_LLM_PROVIDER,
     )
+    current_fast_model = normalize_openai_compatible_model_id(
+        full_fast_model_name,
+        provider=DEFAULT_TEXT_LLM_PROVIDER,
+    )
     selected_provider = DEFAULT_TEXT_LLM_PROVIDER
 
     # 渲染配置输入框
-    col1, col2 = st.columns([1, 2])
+    col1, col2, col3 = st.columns([1, 2, 2])
     with col1:
         render_openai_compatible_protocol_field(
             tr,
@@ -877,11 +906,13 @@ def render_text_llm_settings(tr):
         )
     
     with col2:
-        model_name_input = st.text_input(
+        reasoning_model_name_input = st.text_input(
-            tr("Text Model Name"),
+            tr("High Reasoning Model Name"),
             value=current_model,
             help=(
-                tr("Model Name Input Help")
+                tr("High Reasoning Model Help")
+                + "\n\n"
+                + tr("Model Name Input Help")
                 + "\n\n"
                 + "• Pro/zai-org/GLM-5\n"
                 + "• deepseek/deepseek-chat\n"
@@ -892,8 +923,24 @@ def render_text_llm_settings(tr):
             key="text_model_input"
         )
 
+    with col3:
+        fast_model_name_input = st.text_input(
+            tr("High Efficiency Model Name"),
+            value=current_fast_model,
+            help=(
+                tr("High Efficiency Model Help")
+                + "\n\n"
+                + "• Qwen/Qwen3.5-32B\n"
+                + "• gpt-4o-mini\n"
+                + "• gemini-2.5-flash\n"
+                + "• deepseek/deepseek-chat"
+            ),
+            key="text_fast_model_input",
+        )
+
     # 组合完整的模型名称
-    st_text_model_name = normalize_openai_compatible_model_name(model_name_input)
+    st_text_model_name = normalize_openai_compatible_model_name(reasoning_model_name_input)
+    st_text_fast_model_name = normalize_openai_compatible_model_name(fast_model_name_input)
 
     st_text_api_key = st.text_input(
         tr("Text API Key"),
@@ -923,6 +970,7 @@ def render_text_llm_settings(tr):
     if text_base_required and not st_text_base_url:
         info_example = text_placeholder or "https://your-openai-compatible-endpoint/v1"
         st.info(tr("Please fill OpenAI compatible gateway").format(example=info_example))
+    show_base_url_security_warning(st_text_base_url)
 
     text_generation_params = render_llm_generation_settings(tr, "text")
 
@@ -931,7 +979,7 @@ def render_text_llm_settings(tr):
         test_errors = []
         if not st_text_api_key:
             test_errors.append(tr("Please enter API key"))
-        if not model_name_input:
+        if not reasoning_model_name_input:
             test_errors.append(tr("Please enter model name"))
 
         if test_errors:
@@ -940,17 +988,25 @@ def render_text_llm_settings(tr):
         else:
             with st.spinner(tr("Testing connection...")):
                 try:
+                    test_targets = [
+                        (tr("High Reasoning Model Name"), st_text_model_name),
+                    ]
+                    if st_text_fast_model_name:
+                        test_targets.append((
+                            tr("High Efficiency Model Name"),
+                            st_text_fast_model_name,
+                        ))
+                    for label, target_model in test_targets:
                         success, message = test_openai_compatible_text_model(
                             api_key=st_text_api_key,
                             base_url=st_text_base_url,
-                        model_name=st_text_model_name,
+                            model_name=target_model,
-                        tr=tr
+                            tr=tr,
                         )
-
                         if success:
-                        st.success(message)
+                            st.success(f"{label}: {message}")
                         else:
-                        st.error(message)
+                            st.error(f"{label}: {message}")
                 except Exception as e:
                     st.error(f"{tr('Connection test error')}: {str(e)}")
                     logger.error(f"OpenAI 兼容 文案生成模型连接测试失败: {str(e)}")
@@ -971,6 +1027,25 @@ def render_text_llm_settings(tr):
         else:
             text_validation_errors.append(error_msg)
 
+    if st_text_fast_model_name:
+        is_valid, error_msg = validate_openai_compatible_model_name(
+            st_text_fast_model_name,
+            "高效率文案生成",
+        )
+        if is_valid:
+            text_config_changed |= update_app_config_if_changed(
+                "text_openai_fast_model_name",
+                st_text_fast_model_name,
+            )
+            st.session_state["text_openai_fast_model_name"] = st_text_fast_model_name
+        else:
+            text_validation_errors.append(error_msg)
+    else:
+        text_config_changed |= update_app_config_if_changed(
+            "text_openai_fast_model_name",
+            "",
+        )
+
     # 验证 API 密钥
     if st_text_api_key:
         is_valid, error_msg = validate_api_key(st_text_api_key, "文案生成")
@@ -1006,7 +1081,7 @@ def render_text_llm_settings(tr):
             config.save_config()
             # 清除缓存，确保下次使用新配置
             UnifiedLLMService.clear_cache()
-            if st_text_api_key or st_text_base_url or st_text_model_name:
+            if st_text_api_key or st_text_base_url or st_text_model_name or st_text_fast_model_name:
                 st.success(tr("Text model config saved"))
         except Exception as e:
             st.error(f"{tr('Failed to save config')}: {str(e)}")

webui/components/script_settings.py

@@ -97,6 +97,9 @@ FILM_TV_TYPE_VALUES = {
     "horror_thriller": "恐怖/惊悚",
 }
 SHORT_DRAMA_ORIGINAL_SOUND_RATIO_OPTIONS = list(range(0, 100, 10))
+DEFAULT_NARRATION_WORD_COUNT = 500
+MIN_NARRATION_WORD_COUNT = 100
+MAX_NARRATION_WORD_COUNT = 5000
 SUMMARY_MODE_CONFIGS = {
     MODE_FILM_SUMMARY: {
         "mode_label_key": "Film TV Narration",
@@ -1196,6 +1199,8 @@ def render_fun_asr_transcription(tr):
             )
             backend = backend_options[backend_label]
 
+            st.markdown(tr("Subtitle transcription package downloads"))
+
             if backend == "upload":
                 render_subtitle_upload(tr)
             elif backend == "local":
@@ -1572,6 +1577,7 @@ def render_script_buttons(tr, params):
         type_option_key = _summary_state_key(summary_config, "type_option")
         custom_type_key = _summary_state_key(summary_config, "custom_type")
         original_sound_ratio_key = _summary_state_key(summary_config, "original_sound_ratio")
+        narration_word_count_key = _summary_state_key(summary_config, "narration_word_count")
         language_option_key = _summary_state_key(summary_config, "narration_language_option")
         custom_language_key = _summary_state_key(summary_config, "custom_narration_language")
         narration_copy_key = _summary_state_key(summary_config, "narration_copy")
@@ -1590,7 +1596,7 @@ def render_script_buttons(tr, params):
         config_col_widths = [1.15]
         if show_custom_type:
             config_col_widths.append(1.15)
-        config_col_widths.extend([0.9, 1.15])
+        config_col_widths.extend([0.9, 0.9, 1.15])
         if show_custom_language:
             config_col_widths.append(1.15)
 
@@ -1621,6 +1627,16 @@ def render_script_buttons(tr, params):
                 key=original_sound_ratio_key,
             )
         config_col_index += 1
+        with config_cols[config_col_index]:
+            st.number_input(
+                tr("文案字数"),
+                min_value=MIN_NARRATION_WORD_COUNT,
+                max_value=MAX_NARRATION_WORD_COUNT,
+                value=DEFAULT_NARRATION_WORD_COUNT,
+                step=50,
+                key=narration_word_count_key,
+            )
+        config_col_index += 1
         with config_cols[config_col_index]:
             st.selectbox(
                 tr("解说语言"),
@@ -1661,6 +1677,7 @@ def render_script_buttons(tr, params):
         type_option_key = _summary_state_key(summary_config, "type_option")
         custom_type_key = _summary_state_key(summary_config, "custom_type")
         original_sound_ratio_key = _summary_state_key(summary_config, "original_sound_ratio")
+        narration_word_count_key = _summary_state_key(summary_config, "narration_word_count")
         language_option_key = _summary_state_key(summary_config, "narration_language_option")
         custom_language_key = _summary_state_key(summary_config, "custom_narration_language")
         narration_copy_key = _summary_state_key(summary_config, "narration_copy")
@@ -1672,6 +1689,9 @@ def render_script_buttons(tr, params):
         narration_language = _resolve_summary_narration_language(summary_config)
         drama_genre = _resolve_summary_type(summary_config)
         original_sound_ratio = int(st.session_state.get(original_sound_ratio_key, 30))
+        narration_word_count = int(
+            st.session_state.get(narration_word_count_key, DEFAULT_NARRATION_WORD_COUNT)
+        )
         if (
             st.session_state.get(type_option_key) == "custom"
             and not str(st.session_state.get(custom_type_key, '') or '').strip()
@@ -1718,6 +1738,7 @@ def render_script_buttons(tr, params):
                     video_paths=_selected_video_paths(),
                     narration_language=narration_language,
                     drama_genre=drama_genre,
+                    narration_word_count=narration_word_count,
                     prompt_category=summary_config["prompt_category"],
                     search_keywords=summary_config["search_keywords"],
                     empty_title_message_key=summary_config["empty_title_message_key"],

webui/components/subtitle_settings.py

@@ -47,6 +47,13 @@ SUBTITLE_PREVIEW_FALLBACK_SIZES = {
     "landscape": (1920, 1080),
 }
 
+SUBTITLE_PREVIEW_ORIENTATIONS = ("portrait", "landscape")
+
+SUBTITLE_PREVIEW_ORIENTATION_LABELS = {
+    "portrait": "Portrait Safe Area",
+    "landscape": "Landscape Safe Area",
+}
+
 
 def render_subtitle_panel(tr):
     """渲染字幕设置面板"""
@@ -130,6 +137,25 @@ def _get_current_preview_video_path():
     return ""
 
 
+def _normalize_subtitle_preview_orientation(value, tr=None):
+    if value in SUBTITLE_PREVIEW_ORIENTATIONS:
+        return value
+
+    labels = {
+        label: orientation
+        for orientation, label in SUBTITLE_PREVIEW_ORIENTATION_LABELS.items()
+    }
+    if tr:
+        labels.update(
+            {
+                tr(label): orientation
+                for orientation, label in SUBTITLE_PREVIEW_ORIENTATION_LABELS.items()
+            }
+        )
+
+    return labels.get(str(value), "portrait")
+
+
 def _save_subtitle_mask_preview_video(uploaded_file):
     if uploaded_file is None:
         return ""
@@ -753,14 +779,19 @@ def _render_subtitle_preview_image(tr):
     stroke_color = st.session_state.get("stroke_color", config.ui.get("stroke_color", "#000000"))
     stroke_width = float(st.session_state.get("stroke_width", config.ui.get("stroke_width", 1.5)) or 0)
 
+    orientation_default = _normalize_subtitle_preview_orientation(
+        st.session_state.get("subtitle_preview_orientation", "portrait"),
+        tr,
+    )
+    st.session_state["subtitle_preview_orientation"] = orientation_default
+
     orientation = st.pills(
         tr("Subtitle Preview Orientation"),
-        options=["portrait", "landscape"],
+        options=SUBTITLE_PREVIEW_ORIENTATIONS,
-        default=st.session_state.get("subtitle_preview_orientation", "portrait"),
+        format_func=lambda value: tr(SUBTITLE_PREVIEW_ORIENTATION_LABELS[value]),
-        format_func=lambda value: tr("Portrait Safe Area") if value == "portrait" else tr("Landscape Safe Area"),
         key="subtitle_preview_orientation",
         width="stretch",
-    ) or "portrait"
+    ) or orientation_default
     _render_subtitle_position_controls(tr, orientation)
 
     preview_text = tr("Subtitle Preview Sample Text")

webui/components/system_settings.py

@@ -4,8 +4,54 @@ import shutil
 from loguru import logger
 
 from app.config import config
+from app.services.llm.unified_service import UnifiedLLMService
 from app.utils import ffmpeg_detector, ffmpeg_utils
-from app.utils.utils import storage_dir
+from app.utils.utils import clear_keyframes_cache, storage_dir
+
+
+APPLICATION_CACHE_SESSION_KEYS = (
+    "fonts_cache",
+    "video_files_cache",
+    "songs_cache",
+    "ffmpeg_engine_report",
+)
+
+
+def _clear_streamlit_caches():
+    st.cache_data.clear()
+    cache_resource = getattr(st, "cache_resource", None)
+    if cache_resource is not None:
+        cache_resource.clear()
+
+
+def clear_application_cache(
+    session_state=None,
+    clear_streamlit_cache=None,
+    clear_llm_cache=None,
+    clear_keyframes_cache=None,
+    reset_ffmpeg_detection=None,
+):
+    """Clear runtime caches that can keep stale UI/model/media state."""
+    state = st.session_state if session_state is None else session_state
+    for key in APPLICATION_CACHE_SESSION_KEYS:
+        state.pop(key, None)
+
+    operations = (
+        ("streamlit", clear_streamlit_cache or _clear_streamlit_caches),
+        ("llm", clear_llm_cache or UnifiedLLMService.clear_cache),
+        ("keyframes", clear_keyframes_cache or globals()["clear_keyframes_cache"]),
+        ("ffmpeg", reset_ffmpeg_detection or ffmpeg_utils.reset_hwaccel_detection),
+    )
+
+    errors = []
+    for name, operation in operations:
+        try:
+            operation()
+        except Exception as exc:
+            errors.append(f"{name}: {exc}")
+            logger.error(f"Failed to clear {name} cache: {exc}")
+
+    return errors
 
 
 def clear_directory(dir_path, tr):
@@ -188,7 +234,7 @@ def render_ffmpeg_engine_settings(tr):
 def render_system_panel(tr):
     """渲染系统设置面板"""
     with st.expander(tr("System settings"), expanded=False):
-        col1, col2, col3 = st.columns(3)
+        col1, col2, col3, col4 = st.columns(4)
                 
         with col1:
             if st.button(tr("Clear frames"), use_container_width=True):
@@ -202,4 +248,12 @@ def render_system_panel(tr):
             if st.button(tr("Clear tasks"), use_container_width=True):
                 clear_directory(os.path.join(storage_dir(), "tasks"), tr)
 
+        with col4:
+            if st.button(tr("Clear Cache"), use_container_width=True):
+                errors = clear_application_cache()
+                if errors:
+                    st.error(f"{tr('Failed to clear cache')}: {'; '.join(errors)}")
+                else:
+                    st.success(tr("Cache cleared"))
+
         render_ffmpeg_engine_settings(tr)

webui/components/test_audio_settings_unittest.py

@@ -0,0 +1,63 @@
+import unittest
+
+from webui.components.audio_settings import (
+    _normalize_source_pills_value,
+    get_tts_engine_options,
+)
+
+
+def zh_tr(key):
+    return {
+        "Select from Resource Directory": "从资源目录选择",
+        "Upload Reference Audio": "上传参考音频",
+        "Upload Background Music": "上传背景音乐",
+    }.get(key, key)
+
+
+class AudioSettingsSourcePillsTests(unittest.TestCase):
+    def test_tts_engine_options_include_indextts_15_macos_as_local_engine(self):
+        options = get_tts_engine_options(lambda key: {
+            "Local Deployment": "本地部署",
+            "Cloud Service": "云服务",
+        }.get(key, key))
+
+        self.assertEqual(
+            "IndexTTS-1.5-macOS [本地部署]",
+            options["indextts_macos"],
+        )
+
+    def test_normalize_source_pills_value_keeps_canonical_value(self):
+        options = {
+            "resource": "Select from Resource Directory",
+            "upload": "Upload Reference Audio",
+        }
+
+        self.assertEqual("upload", _normalize_source_pills_value("upload", options, "resource", zh_tr))
+
+    def test_normalize_source_pills_value_migrates_current_translated_label(self):
+        options = {
+            "resource": "Select from Resource Directory",
+            "upload": "Upload Reference Audio",
+        }
+
+        self.assertEqual("resource", _normalize_source_pills_value("从资源目录选择", options, "upload", zh_tr))
+
+    def test_normalize_source_pills_value_migrates_untranslated_label_key(self):
+        options = {
+            "resource": "Select from Resource Directory",
+            "upload": "Upload Background Music",
+        }
+
+        self.assertEqual("upload", _normalize_source_pills_value("Upload Background Music", options, "resource", zh_tr))
+
+    def test_normalize_source_pills_value_falls_back_to_default(self):
+        options = {
+            "resource": "Select from Resource Directory",
+            "upload": "Upload Reference Audio",
+        }
+
+        self.assertEqual("resource", _normalize_source_pills_value("invalid", options, "resource", zh_tr))
+
+
+if __name__ == "__main__":
+    unittest.main()

webui/components/test_subtitle_settings_unittest.py

@@ -0,0 +1,21 @@
+import unittest
+
+from webui.components.subtitle_settings import _normalize_subtitle_preview_orientation
+
+
+class SubtitleSettingsPreviewOrientationTests(unittest.TestCase):
+    def test_normalize_subtitle_preview_orientation_accepts_canonical_values(self):
+        self.assertEqual("portrait", _normalize_subtitle_preview_orientation("portrait"))
+        self.assertEqual("landscape", _normalize_subtitle_preview_orientation("landscape"))
+
+    def test_normalize_subtitle_preview_orientation_migrates_legacy_labels(self):
+        self.assertEqual("portrait", _normalize_subtitle_preview_orientation("Portrait Safe Area"))
+        self.assertEqual("landscape", _normalize_subtitle_preview_orientation("Landscape Safe Area"))
+
+    def test_normalize_subtitle_preview_orientation_falls_back_to_portrait(self):
+        self.assertEqual("portrait", _normalize_subtitle_preview_orientation(None))
+        self.assertEqual("portrait", _normalize_subtitle_preview_orientation("unexpected"))
+
+
+if __name__ == "__main__":
+    unittest.main()

webui/components/test_system_settings_unittest.py

@@ -0,0 +1,46 @@
+import unittest
+
+from webui.components.system_settings import clear_application_cache
+
+
+class SystemSettingsCacheTests(unittest.TestCase):
+    def test_clear_application_cache_clears_runtime_caches(self):
+        session_state = {
+            "fonts_cache": ["SimHei"],
+            "video_files_cache": ["a.mp4"],
+            "songs_cache": ["bgm.mp3"],
+            "ffmpeg_engine_report": {"ffmpeg_available": True},
+            "unrelated": "keep",
+        }
+        calls = []
+
+        errors = clear_application_cache(
+            session_state=session_state,
+            clear_streamlit_cache=lambda: calls.append("streamlit"),
+            clear_llm_cache=lambda: calls.append("llm"),
+            clear_keyframes_cache=lambda: calls.append("keyframes"),
+            reset_ffmpeg_detection=lambda: calls.append("ffmpeg"),
+        )
+
+        self.assertEqual([], errors)
+        self.assertEqual(["streamlit", "llm", "keyframes", "ffmpeg"], calls)
+        self.assertEqual({"unrelated": "keep"}, session_state)
+
+    def test_clear_application_cache_reports_clear_failures(self):
+        def fail():
+            raise RuntimeError("boom")
+
+        errors = clear_application_cache(
+            session_state={},
+            clear_streamlit_cache=fail,
+            clear_llm_cache=lambda: None,
+            clear_keyframes_cache=lambda: None,
+            reset_ffmpeg_detection=lambda: None,
+        )
+
+        self.assertEqual(1, len(errors))
+        self.assertIn("boom", errors[0])
+
+
+if __name__ == "__main__":
+    unittest.main()

webui/i18n/en.json

@@ -54,7 +54,21 @@
     "Custom Background Music": "Custom Background Music",
     "Custom Background Music File": "Please enter the file path of the custom background music",
     "Background Music Source": "Background Music Source",
-    "Background Music Source Help": "Choose background music from the resource directory, upload a new file, or disable background music.",
+    "Background Music Source Help": "Choose background music from the resource directory, upload a new file, let Sonilo generate music from the visuals, or disable background music.",
+    "Sonilo AI Background Music": "AI-Generated Background Music (Sonilo)",
+    "Sonilo BGM Notice": "When enabled, the assembled video (without background music) is uploaded to the Sonilo API to generate background music that follows the visuals and editing pace; the narration keeps its existing volume settings and stays clearly audible. Generated music is licensed for commercial use (terms apply). Videos longer than 6 minutes are not supported; if generation fails, the task falls back to random background music.",
+    "Sonilo API Key": "Sonilo API Key",
+    "Sonilo API Key Help": "Get an API key at https://sonilo.com. Only used when Sonilo background music or sound effects are enabled.",
+    "Sonilo API Key Required": "Please enter a Sonilo API Key first, otherwise the task will fall back to random background music.",
+    "Sonilo BGM Prompt": "Music Style Hint (Optional)",
+    "Sonilo BGM Prompt Help": "Optional: describe the desired music style, e.g. \"calm piano\" or \"tense suspense\". Leave empty to generate purely from the visuals.",
+    "Sonilo config saved": "Sonilo configuration saved",
+    "Sonilo AI Sound Effects": "AI Sound Effects (Sonilo)",
+    "Sonilo SFX Help": "Automatically generate sound effects that match the visuals of the assembled video (optional, disabled by default).",
+    "Sonilo SFX Notice": "When enabled, the assembled video is uploaded to the Sonilo API to generate sound effects based on the visuals; the effects are mixed underneath the existing audio track, and the narration keeps its existing volume settings and stays clearly audible. Generated sound effects are royalty-free. Videos longer than 3 minutes are not supported; if generation fails, the sound-effects step is skipped and the video is produced as usual.",
+    "Sonilo SFX Prompt": "Sound Effects Hint (Optional)",
+    "Sonilo SFX Prompt Help": "Optional: describe the desired sound effects, e.g. \"rain with distant thunder\" or \"metal clanking\". Leave empty to generate purely from the visuals.",
+    "Sonilo SFX API Key Required": "Please enter a Sonilo API Key first, otherwise the sound-effects step will be skipped.",
     "Upload Background Music": "Upload Background Music",
     "Background Music Path Help": "Choose the background music used for video synthesis.",
     "No Background Music Resources Found": "No background music resources found. Please upload a background music file.",
@@ -197,6 +211,10 @@
     "Text API Key": "Text API Key",
     "Text Base URL": "Text Base URL",
     "Text Model Name": "Text Model Name",
+    "High Reasoning Model Name": "High-Reasoning Model Name",
+    "High Efficiency Model Name": "High-Efficiency Model Name",
+    "High Reasoning Model Help": "Used for plot analysis, copy generation, and script generation and matching.",
+    "High Efficiency Model Help": "Used for subtitle translation and calibration; falls back to the high-reasoning model when empty.",
     "Top P": "Top P",
     "Top K": "Top K",
     "Max Output Tokens": "Max Output Tokens",
@@ -333,6 +351,7 @@
     "影视类型": "Film/TV Type",
     "自定义影视类型": "Custom Film/TV Type",
     "原片占比": "Original Footage Ratio",
+    "文案字数": "Copy Length",
     "例如：豪门虐恋": "For example: billionaire angst romance",
     "例如：悬疑犯罪": "For example: suspense crime",
     "请输入自定义短剧类型": "Please enter a custom short drama type",
@@ -373,13 +392,19 @@
     "Tencent Cloud TTS use case": "Personal and enterprise users who need stable Chinese speech synthesis",
     "Tongyi Qwen3 TTS features": "Alibaba Cloud Tongyi Qwen speech synthesis with high-quality voices and multiple voice options.",
     "High-quality Chinese speech synthesis use case": "Users who need high-quality Chinese speech synthesis",
-    "IndexTTS features": "A locally or privately deployed IndexTTS-1.5 voice-cloning engine. Choose a resource audio file or upload a reference audio file, then synthesize narration in that voice.",
+    "IndexTTS features": "A locally or privately deployed IndexTTS-1.5 voice-cloning engine for Windows. Choose or upload reference audio to synthesize narration in that voice.",
-    "IndexTTS use case": "Best for fixed narrator voices, character dubbing, or generating multiple videos with the same voice. Start the IndexTTS-1.5 API service before use. Deployment package: https://pan.quark.cn/s/0767c9bcefd5",
+    "IndexTTS use case": "Best for fixed narrator voices, character dubbing, and batch generation on Windows. Start the IndexTTS-1.5 API service before use. [Download the deployment package](https://cutagent.online/resources/indextts15-windows).",
-    "IndexTTS download link": "Download link: https://pan.quark.cn/s/0767c9bcefd5",
+    "IndexTTS download link": "Download packages:\n\n- **macOS**: [Download](https://cutagent.online/resources/indextts15-mlx-macos)\n- **Windows**: [Download](https://cutagent.online/resources/indextts15-windows)",
-    "IndexTTS2 features": "A locally or privately deployed IndexTTS-2 voice-cloning engine with emotion control and fuller generation parameters.",
+    "IndexTTS macOS features": "A local IndexTTS-1.5 MLX voice-cloning engine for Apple Silicon that uploads reference audio to synthesize narration.",
-    "IndexTTS2 use case": "Best for fixed voices, emotional narration, and local speech synthesis workflows that need finer sampling controls. Start the IndexTTS-2 API service before use.",
+    "IndexTTS macOS use case": "Best for local fixed narrator voices and character dubbing on Apple Silicon Macs. Start IndexTTS-MLX-1.5-Pack before use. [Download the deployment package](https://cutagent.online/resources/indextts15-mlx-macos).",
+    "IndexTTS2 features": "A locally deployed IndexTTS-2 MLX Pack voice-cloning engine with emotion control and advanced generation parameters.",
+    "IndexTTS2 use case": "Best for fixed voices, emotional narration, and local speech synthesis workflows that need finer sampling controls. Start the IndexTTS-2 MLX Pack service before use. Deployment packages:\n\n- **macOS**: [Download](https://cutagent.online/resources/indextts2-full-macos)\n- **Windows**: Coming soon",
     "OmniVoice features": "A locally or privately deployed OmniVoice-Pack multilingual TTS engine with automatic voice generation, voice design, and reference-audio cloning.",
-    "OmniVoice use case": "Best for local controllable multilingual narration, voice design, or reference-audio cloning. Start the OmniVoice-Pack API service before use.",
+    "OmniVoice use case": "Best for local controllable multilingual narration, voice design, or reference-audio cloning. Start the OmniVoice-Pack API service before use. Deployment packages:\n\n- **macOS**: [Download](https://cutagent.online/resources/omnivoice-macos)\n- **Windows**: [Download](https://cutagent.online/resources/omnivoice-windows)",
+    "VoxCPM features": "A locally deployed VoxCPM-0.5B speech engine supporting its default voice and zero-shot cloning from reference audio.",
+    "VoxCPM use case": "Best for private local Chinese narration and reusable voices on Apple Silicon Macs. Start VoxCPM-0.5B-Pack before use; [download the deployment package](https://cutagent.online/resources/voxcpm-05b-macos).",
+    "VoxCPM2 features": "A locally deployed high-quality VoxCPM-2B engine with voice-description design, reference-audio cloning, 48k output, and context awareness.",
+    "VoxCPM2 use case": "Best for higher-quality local narration, describable voices, style control, and cloned voices on Apple Silicon Macs. Start VoxCPM-2B-Pack before use; [download the deployment package](https://cutagent.online/resources/voxcpm-2b-macos).",
     "Doubao TTS features": "Volcengine Doubao speech synthesis with multiple voices and emotions, plus fast access in mainland China.",
     "Local Deployment": "Local Deployment",
     "Cloud Service": "Cloud Service",
@@ -472,6 +497,7 @@
     "Characters": "characters",
     "Ali Bailian Fun-ASR Subtitle Transcription": "Subtitle Processing",
     "Subtitle Processing Method": "Subtitle Processing Method",
+    "Subtitle transcription package downloads": "**Subtitle transcription package downloads**\n\n- **Fun-ASR-Nano**: [macOS](https://cutagent.online/resources/fun-asr-nano-macos) · [Windows](https://cutagent.online/resources/fun-asr-nano-windows)\n- **FunASR v1.1.0**: [macOS](https://cutagent.online/resources/funasr-v110-macos) · [Windows](https://cutagent.online/resources/funasr-v110-windows)\n- **FireRedASR2-AED**: [macOS](https://cutagent.online/resources/fireredasr2-aed-macos) · [Windows](https://cutagent.online/resources/fireredasr2-aed-windows)",
     "Fun-ASR Backend": "Fun-ASR Backend",
     "Local FunASR-Pack API": "FunASR (Local)",
     "Local FireRedASR API": "FireRedASR2 (Local)",
@@ -564,8 +590,30 @@
     "Select Qwen3 TTS Voice": "Select a Qwen3 TTS voice",
     "API URL": "API URL",
     "IndexTTS API URL Help": "IndexTTS-1.5 API service URL",
-    "IndexTTS2 API URL Help": "IndexTTS-2 API service URL. You can enter the service root or the full /tts endpoint.",
+    "IndexTTS macOS API URL Help": "IndexTTS-MLX-1.5-Pack service URL. Enter the service root or the full /v1/audio/speech/upload endpoint.",
+    "IndexTTS2 API URL Help": "IndexTTS-2 MLX Pack service URL. Enter the service root or the full /v1/audio/speech/upload endpoint.",
     "OmniVoice API URL Help": "OmniVoice-Pack API service URL. You can enter the service root or the full /tts endpoint.",
+    "VoxCPM API URL Help": "VoxCPM-0.5B-Pack service URL. Enter the service root, /tts, or /v1/audio/speech endpoint.",
+    "VoxCPM Use Reference Audio": "Clone from Reference Audio",
+    "VoxCPM Use Reference Audio Help": "Uploads prompt_audio through /tts when enabled; otherwise uses the model's default voice.",
+    "VoxCPM Prompt Text": "Reference Audio Text",
+    "VoxCPM Prompt Text Help": "Optional transcript of the speech in the reference audio.",
+    "VoxCPM Normalize": "Normalize Text",
+    "VoxCPM Denoise": "Denoise Reference Audio",
+    "VoxCPM Usage Instructions Title": "VoxCPM-0.5B Usage Instructions",
+    "VoxCPM Usage Instructions": "1. Start VoxCPM-0.5B-Pack (double-click start.command on macOS).\n2. The default service URL is http://127.0.0.1:7864.\n3. Use the default voice without reference audio, or enable reference audio to clone a voice.\n4. The first request may take longer while the model loads.",
+    "VoxCPM2 API URL Help": "VoxCPM-2B-Pack service URL. Enter the service root, /tts, /tts/batch, or /v1/audio/speech endpoint.",
+    "VoxCPM2 Generation Mode": "Generation Mode",
+    "VoxCPM2 Generation Mode Help": "Voice design generates a voice from a text description; cloning uploads reference_audio.",
+    "VoxCPM2 Mode Design": "Voice Design",
+    "VoxCPM2 Mode Clone": "Reference Audio Clone",
+    "VoxCPM2 Voice Control": "Voice Description / Style Control",
+    "VoxCPM2 Voice Control Help": "Describe voice, emotion, pace, and expression, for example: warm, natural, slightly fast young female voice.",
+    "VoxCPM2 Output 48k": "Output 48kHz Audio",
+    "VoxCPM2 Context Aware": "Enable Context Awareness",
+    "VoxCPM2 Streaming": "Enable Streaming Inference",
+    "VoxCPM2 Usage Instructions Title": "VoxCPM-2B Usage Instructions",
+    "VoxCPM2 Usage Instructions": "1. Start VoxCPM-2B-Pack (double-click start.command on macOS).\n2. The default service URL is http://127.0.0.1:7863.\n3. Describe the desired voice in design mode, or choose reference audio in clone mode.\n4. Initial model loading and 2B generation may take longer.",
     "OmniVoice Language Code": "Synthesis Language",
     "OmniVoice Language Code Help": "The language parameter sent to OmniVoice-Pack, such as zh or en.",
     "OmniVoice Generation Mode": "Generation Mode",
@@ -618,7 +666,18 @@
     "Enable Sampling Help": "Enable sampling for more natural speech.",
     "IndexTTS Usage Instructions Title": "IndexTTS-1.5 Usage Instructions",
     "IndexTTS Usage Instructions": "**Zero-shot voice cloning**\n\n1. **Prepare reference audio**: upload or specify a clear audio file (3-10 seconds recommended)\n2. **Set API URL**: make sure the IndexTTS-1.5 service is running\n3. **Start synthesis**: the system will use the reference voice to synthesize new speech\n\n**Notes**:\n- Reference audio quality directly affects synthesis quality\n- Use clean audio without background noise when possible\n- Keep text length within a reasonable range\n- The first synthesis may take longer",
+    "IndexTTS macOS Usage Instructions Title": "IndexTTS-1.5-macOS Usage Instructions",
+    "IndexTTS macOS Usage Instructions": "**Local voice cloning on Apple Silicon**\n\n1. Double-click `start.command` in the Pack to start the service\n2. Keep the default API URL `http://127.0.0.1:7866`, or enter the full upload endpoint\n3. Select clean reference audio and start synthesis\n\nThe first request usually takes longer while the MLX model loads. This engine requires an Apple Silicon Mac.",
     "IndexTTS2 Emotion Parameters": "Emotion Parameters",
+    "IndexTTS2 Emotion": "Emotion Override",
+    "IndexTTS2 Emotion Help": "Leave blank to preserve the reference audio emotion. Use a label such as happy or a weighted mix such as happy:0.7,calm:0.3.",
+    "IndexTTS2 Emotion Placeholder": "e.g. happy:0.7,calm:0.3",
+    "IndexTTS2 Emotion Audio Unsupported": "The IndexTTS-2 MLX Pack does not support a separate emotion reference audio. The speaker reference audio emotion will be used.",
+    "IndexTTS2 Speed": "Speech Speed",
+    "IndexTTS2 Speed Help": "Speech speed sent to the IndexTTS-2 MLX Pack (0.5x–2.0x).",
+    "IndexTTS2 Seed": "Seed",
+    "IndexTTS2 Seed Help": "Optional integer seed for reproducible generation. Leave blank for random sampling.",
+    "IndexTTS2 Seed Placeholder": "Random",
     "Emotion Mode": "Emotion Mode",
     "Emotion Mode Help": "Choose the emotion control source for IndexTTS-2.",
     "Emotion Mode Speaker": "Same as speaker reference",
@@ -642,12 +701,21 @@
     "Emotion Melancholic": "Melancholic",
     "Emotion Surprised": "Surprised",
     "Emotion Calm": "Calm",
+    "Diffusion Steps": "Diffusion Steps",
+    "Diffusion Steps Help": "Number of diffusion steps. Higher values can improve quality but take longer.",
+    "CFG Rate": "CFG Rate",
+    "CFG Rate Help": "Classifier-free guidance strength for the diffusion stage.",
+    "Interval Silence": "Inter-segment Silence (ms)",
+    "Interval Silence Help": "Silence inserted between text segments by the Pack.",
+    "Segment Overlap": "Segment Overlap (ms)",
+    "Segment Overlap Help": "Crossfade overlap between generated text segments.",
+    "IndexTTS2 Top K Help": "Top-k sampling value for IndexTTS-2 MLX Pack. It must be at least 1.",
     "Max Text Tokens Per Segment": "Max Text Tokens Per Segment",
     "Max Text Tokens Per Segment Help": "Maximum text tokens per segment for IndexTTS-2 inference.",
     "Max Mel Tokens": "Max Mel Tokens",
     "Max Mel Tokens Help": "Controls the maximum mel tokens generated in one request. Higher values can produce longer audio.",
     "IndexTTS2 Usage Instructions Title": "IndexTTS-2 Usage Instructions",
-    "IndexTTS2 Usage Instructions": "**IndexTTS-2 voice cloning**\n\n1. **Choose a voice**: reuse IndexTTS-1.5 resource audio or upload a reference audio file\n2. **Set API URL**: for example http://192.168.3.6:7863/tts, or enter the service root\n3. **Tune emotion**: speaker is the default; switch to audio, vector, or text when needed\n4. **Tune generation**: temperature, top_p, top_k, num_beams, repetition_penalty, and max_mel_tokens are sent directly to the IndexTTS-2 API\n\n**Notes**:\n- Reference audio quality directly affects cloning quality\n- The first request may load the model and take longer\n- CPU deployments are much slower than GPU deployments",
+    "IndexTTS2 Usage Instructions": "**IndexTTS-2 MLX Pack voice cloning**\n\n1. **Choose a voice**: reuse IndexTTS-1.5 resource audio or upload a reference audio file\n2. **Set API URL**: the default Pack service is http://127.0.0.1:7860; NarratoAI calls /v1/audio/speech/upload and uploads the reference audio\n3. **Tune emotion**: leave it blank to preserve the reference audio emotion, or enter a label/mix such as happy:0.7,calm:0.3\n4. **Tune generation**: speed, temperature, top_p, top_k, repetition_penalty, diffusion_steps, cfg_rate, and max_mel_tokens are sent to the Pack\n\n**Notes**:\n- Reference audio quality directly affects cloning quality\n- The first request may load the model and take longer\n- The Pack binds to localhost by default",
     "OmniVoice Usage Instructions Title": "OmniVoice Usage Instructions",
     "OmniVoice Usage Instructions": "**OmniVoice-Pack speech synthesis**\n\n1. **Automatic voice**: set the API URL and language, then synthesize directly.\n2. **Voice design**: fill instruct with the desired gender, pitch, accent, or style.\n3. **Reference-audio clone**: upload or choose reference audio and fill its matching transcript.\n\n**Notes**:\n- The default service URL is http://127.0.0.1:7866/tts\n- Reference-audio cloning requires reference text when the service has no ASR model loaded\n- OmniVoice returns WAV audio, and NarratoAI estimates subtitle segment timing from the audio duration",
     "Volcengine Access Key Help": "Volcengine Access Key",

webui/i18n/zh.json

@@ -42,7 +42,21 @@
     "Custom Background Music": "自定义背景音乐",
     "Custom Background Music File": "请输入自定义背景音乐的文件路径",
     "Background Music Source": "背景音乐来源",
-    "Background Music Source Help": "选择资源目录中的背景音乐、上传新的背景音乐，或关闭背景音乐",
+    "Background Music Source Help": "选择资源目录中的背景音乐、上传新的背景音乐、使用 Sonilo 根据画面生成配乐，或关闭背景音乐",
+    "Sonilo AI Background Music": "AI 生成配乐（Sonilo）",
+    "Sonilo BGM Notice": "启用后，合成完成的视频（未加背景音乐）将上传至 Sonilo API，根据画面内容与剪辑节奏生成配乐；解说配音仍按现有音量设置保持清晰。生成的音乐已获授权、可商用（以条款为准）。视频时长上限 6 分钟；生成失败时自动回退到随机背景音乐，不影响成片。",
+    "Sonilo API Key": "Sonilo API Key",
+    "Sonilo API Key Help": "获取地址：https://sonilo.com，仅在启用 Sonilo 配乐或音效时使用",
+    "Sonilo API Key Required": "请先填写 Sonilo API Key，否则生成时将回退到随机背景音乐",
+    "Sonilo BGM Prompt": "配乐风格提示（可选）",
+    "Sonilo BGM Prompt Help": "可选：描述期望的配乐风格，例如“舒缓钢琴”“紧张悬疑”，留空则完全根据画面生成",
+    "Sonilo config saved": "Sonilo 配置已保存",
+    "Sonilo AI Sound Effects": "AI 音效（Sonilo）",
+    "Sonilo SFX Help": "为成片自动生成贴合画面的音效（可选功能，默认关闭）",
+    "Sonilo SFX Notice": "启用后，合成完成的视频将上传至 Sonilo API，根据画面内容生成音效，并混在现有音轨之下；解说配音仍按现有音量设置保持清晰。生成的音效为免版税素材。视频时长上限 3 分钟；生成失败时自动跳过音效，不影响成片。",
+    "Sonilo SFX Prompt": "音效风格提示（可选）",
+    "Sonilo SFX Prompt Help": "可选：描述期望的音效，例如“雨声和远处雷声”“金属碰撞”，留空则完全根据画面生成",
+    "Sonilo SFX API Key Required": "请先填写 Sonilo API Key，否则生成时将跳过音效",
     "Upload Background Music": "上传背景音乐",
     "Background Music Path Help": "选择用于视频合成的背景音乐",
     "No Background Music Resources Found": "未找到资源目录中的背景音乐，请上传背景音乐文件",
@@ -186,6 +200,10 @@
     "Text API Key": "文案生成 API 密钥",
     "Text Base URL": "文案生成接口地址",
     "Text Model Name": "文案生成模型名称",
+    "High Reasoning Model Name": "高推理模型名称",
+    "High Efficiency Model Name": "高效率模型名称",
+    "High Reasoning Model Help": "用于剧情分析、文案生成、脚本生成与匹配等复杂任务。",
+    "High Efficiency Model Help": "用于字幕翻译、字幕校准等批量任务；留空时自动使用高推理模型。",
     "Top P": "Top P",
     "Top K": "Top K",
     "Max Output Tokens": "最大输出 Token",
@@ -311,13 +329,19 @@
     "Tencent Cloud TTS use case": "个人和企业用户，需要稳定的中文语音合成",
     "Tongyi Qwen3 TTS features": "阿里云通义千问语音合成，音质优秀，支持多种音色",
     "High-quality Chinese speech synthesis use case": "需要高质量中文语音合成的用户",
-    "IndexTTS features": "本地/私有部署的 IndexTTS-1.5 语音克隆引擎。选择资源目录音频或上传参考音频后，可按该音色合成旁白。",
+    "IndexTTS features": "Windows 本地/私有部署的 IndexTTS-1.5 语音克隆引擎。选择资源目录音频或上传参考音频后，可按该音色合成旁白。",
-    "IndexTTS use case": "适合需要固定旁白音色、角色配音或批量生成同一音色视频的场景。使用前请先启动 IndexTTS-1.5 API 服务；部署包下载：https://pan.quark.cn/s/0767c9bcefd5",
+    "IndexTTS use case": "适合在 Windows 上生成固定旁白音色、角色配音或批量生成同一音色视频。使用前请先启动 IndexTTS-1.5 API 服务；[下载部署包](https://cutagent.online/resources/indextts15-windows)。",
-    "IndexTTS download link": "下载地址：https://pan.quark.cn/s/0767c9bcefd5",
+    "IndexTTS download link": "下载地址：\n\n- **macOS**：[下载地址](https://cutagent.online/resources/indextts15-mlx-macos)\n- **Windows**：[下载地址](https://cutagent.online/resources/indextts15-windows)",
-    "IndexTTS2 features": "本地/私有部署的 IndexTTS-2 语音克隆引擎，支持情感控制和更完整的生成参数。",
+    "IndexTTS macOS features": "面向 Apple Silicon 的 IndexTTS-1.5 MLX 本地语音克隆引擎，通过上传参考音频合成旁白。",
-    "IndexTTS2 use case": "适合需要固定音色、情绪化旁白或更细致采样控制的本地语音合成场景。使用前请先启动 IndexTTS-2 API 服务。",
+    "IndexTTS macOS use case": "适合在 Apple Silicon Mac 上本地生成固定旁白音色和角色配音。使用前请启动 IndexTTS-MLX-1.5-Pack；[下载部署包](https://cutagent.online/resources/indextts15-mlx-macos)。",
+    "IndexTTS2 features": "本地部署的 IndexTTS-2 MLX Pack 语音克隆引擎，支持情感控制和更完整的生成参数。",
+    "IndexTTS2 use case": "适合需要固定音色、情绪化旁白或更细致采样控制的本地语音合成场景。使用前请先启动 IndexTTS-2 MLX Pack 服务；部署包下载：\n\n- **macOS**：[下载地址](https://cutagent.online/resources/indextts2-full-macos)\n- **Windows**：待更新",
     "OmniVoice features": "本地/私有部署的 OmniVoice-Pack 多语种语音合成引擎，支持自动音色、指令音色和参考音频克隆。",
-    "OmniVoice use case": "适合需要本地可控、多语言旁白、音色设计或参考音频克隆的场景。使用前请先启动 OmniVoice-Pack API 服务。",
+    "OmniVoice use case": "适合需要本地可控、多语言旁白、音色设计或参考音频克隆的场景。使用前请先启动 OmniVoice-Pack API 服务；部署包下载：\n\n- **macOS**：[下载地址](https://cutagent.online/resources/omnivoice-macos)\n- **Windows**：[下载地址](https://cutagent.online/resources/omnivoice-windows)",
+    "VoxCPM features": "本地部署的 VoxCPM-0.5B 语音合成引擎，支持默认音色和参考音频零样本音色克隆。",
+    "VoxCPM use case": "适合 Apple Silicon Mac 上的本地中文旁白、固定音色与隐私敏感型语音合成。使用前请启动 VoxCPM-0.5B-Pack；[下载部署包](https://cutagent.online/resources/voxcpm-05b-macos)。",
+    "VoxCPM2 features": "本地部署的 VoxCPM-2B 高质量语音引擎，支持音色描述设计、参考音频克隆、48k 输出和上下文感知。",
+    "VoxCPM2 use case": "适合 Apple Silicon Mac 上需要更高质量、可描述音色、情绪风格控制或固定克隆音色的本地旁白。使用前请启动 VoxCPM-2B-Pack；[下载部署包](https://cutagent.online/resources/voxcpm-2b-macos)。",
     "Doubao TTS features": "火山引擎豆包语音合成，支持多种音色和情感，国内访问速度快",
     "Local Deployment": "本地部署",
     "Cloud Service": "云端服务",
@@ -411,6 +435,7 @@
     "Characters": "字符",
     "Ali Bailian Fun-ASR Subtitle Transcription": "字幕处理",
     "Subtitle Processing Method": "字幕处理方式",
+    "Subtitle transcription package downloads": "**字幕转录整合包下载**\n\n- **Fun-ASR-Nano**：[macOS](https://cutagent.online/resources/fun-asr-nano-macos) · [Windows](https://cutagent.online/resources/fun-asr-nano-windows)\n- **FunASR v1.1.0**：[macOS](https://cutagent.online/resources/funasr-v110-macos) · [Windows](https://cutagent.online/resources/funasr-v110-windows)\n- **FireRedASR2-AED**：[macOS](https://cutagent.online/resources/fireredasr2-aed-macos) · [Windows](https://cutagent.online/resources/fireredasr2-aed-windows)",
     "Fun-ASR Backend": "Fun-ASR 后端",
     "Local FunASR-Pack API": "FunASR(本地部署)",
     "Local FireRedASR API": "FireRedASR2(本地部署)",
@@ -503,8 +528,30 @@
     "Select Qwen3 TTS Voice": "选择 Qwen3 TTS 音色",
     "API URL": "API 地址",
     "IndexTTS API URL Help": "IndexTTS-1.5 API 服务地址",
-    "IndexTTS2 API URL Help": "IndexTTS-2 API 服务地址，可填写服务根地址或完整 /tts 地址",
+    "IndexTTS macOS API URL Help": "IndexTTS-MLX-1.5-Pack 服务地址，可填写服务根地址或完整 /v1/audio/speech/upload 地址",
+    "IndexTTS2 API URL Help": "IndexTTS-2 MLX Pack 服务地址，可填写服务根地址或完整 /v1/audio/speech/upload 地址",
     "OmniVoice API URL Help": "OmniVoice-Pack API 服务地址，可填写服务根地址或完整 /tts 地址",
+    "VoxCPM API URL Help": "VoxCPM-0.5B-Pack 服务地址，可填写服务根地址、/tts 或 /v1/audio/speech 地址。",
+    "VoxCPM Use Reference Audio": "使用参考音频克隆音色",
+    "VoxCPM Use Reference Audio Help": "启用后通过 /tts 上传 prompt_audio；关闭时使用模型默认音色。",
+    "VoxCPM Prompt Text": "参考音频文本",
+    "VoxCPM Prompt Text Help": "可选，填写参考音频中实际朗读的文字。",
+    "VoxCPM Normalize": "文本规范化",
+    "VoxCPM Denoise": "参考音频降噪",
+    "VoxCPM Usage Instructions Title": "VoxCPM-0.5B 使用说明",
+    "VoxCPM Usage Instructions": "1. 启动 VoxCPM-0.5B-Pack（macOS 双击 start.command）。\n2. 默认服务地址为 http://127.0.0.1:7864。\n3. 不选择参考音频时使用默认音色；启用参考音频后可克隆音色。\n4. 首次合成需要加载模型，可能耗时较长。",
+    "VoxCPM2 API URL Help": "VoxCPM-2B-Pack 服务地址，可填写服务根地址、/tts、/tts/batch 或 /v1/audio/speech 地址。",
+    "VoxCPM2 Generation Mode": "生成模式",
+    "VoxCPM2 Generation Mode Help": "音色设计使用文字描述生成声音；参考音频克隆会上传 reference_audio。",
+    "VoxCPM2 Mode Design": "音色设计",
+    "VoxCPM2 Mode Clone": "参考音频克隆",
+    "VoxCPM2 Voice Control": "音色描述 / 风格控制",
+    "VoxCPM2 Voice Control Help": "描述音色、情绪、语速和表达，例如：温暖、自然、稍快的年轻女声。",
+    "VoxCPM2 Output 48k": "输出 48kHz 音频",
+    "VoxCPM2 Context Aware": "启用上下文感知",
+    "VoxCPM2 Streaming": "启用流式推理",
+    "VoxCPM2 Usage Instructions Title": "VoxCPM-2B 使用说明",
+    "VoxCPM2 Usage Instructions": "1. 启动 VoxCPM-2B-Pack（macOS 双击 start.command）。\n2. 默认服务地址为 http://127.0.0.1:7863。\n3. 音色设计模式填写声音与风格描述；克隆模式选择参考音频，可补充其文本。\n4. 2B 模型首次加载和生成可能耗时较长。",
     "OmniVoice Language Code": "合成语言",
     "OmniVoice Language Code Help": "传给 OmniVoice-Pack 的 language 参数，例如 zh、en。",
     "OmniVoice Generation Mode": "生成模式",
@@ -557,7 +604,18 @@
     "Enable Sampling Help": "启用采样可以获得更自然的语音",
     "IndexTTS Usage Instructions Title": "IndexTTS-1.5 使用说明",
     "IndexTTS Usage Instructions": "**零样本语音克隆**\n\n1. **准备参考音频**：上传或指定一段清晰的音频文件（建议 3-10 秒）\n2. **设置 API 地址**：确保 IndexTTS-1.5 服务正常运行\n3. **开始合成**：系统会自动使用参考音频的音色合成新语音\n\n**注意事项**：\n- 参考音频质量直接影响合成效果\n- 建议使用无背景噪音的清晰音频\n- 文本长度建议控制在合理范围内\n- 首次合成可能需要较长时间",
+    "IndexTTS macOS Usage Instructions Title": "IndexTTS-1.5-macOS 使用说明",
+    "IndexTTS macOS Usage Instructions": "**Apple Silicon 本地语音克隆**\n\n1. 双击 Pack 中的 `start.command` 启动服务\n2. 保持默认 API 地址 `http://127.0.0.1:7866`，或填写完整上传接口\n3. 选择清晰的参考音频后开始合成\n\n首次请求需要加载 MLX 模型，耗时通常更长。该引擎仅适用于 Apple Silicon Mac。",
     "IndexTTS2 Emotion Parameters": "情感参数",
+    "IndexTTS2 Emotion": "情感覆盖",
+    "IndexTTS2 Emotion Help": "留空时保留参考音频的情感；可填写单个情感，如 happy，或权重混合，如 happy:0.7,calm:0.3。",
+    "IndexTTS2 Emotion Placeholder": "例如：happy:0.7,calm:0.3",
+    "IndexTTS2 Emotion Audio Unsupported": "IndexTTS-2 MLX Pack 不支持单独的情感参考音频，将使用音色参考音频的情感。",
+    "IndexTTS2 Speed": "语速",
+    "IndexTTS2 Speed Help": "传给 IndexTTS-2 MLX Pack 的语速（0.5x–2.0x）。",
+    "IndexTTS2 Seed": "随机种子",
+    "IndexTTS2 Seed Help": "可选整数，用于复现生成结果；留空则随机采样。",
+    "IndexTTS2 Seed Placeholder": "随机",
     "Emotion Mode": "情感控制方式",
     "Emotion Mode Help": "选择 IndexTTS-2 的情感控制来源",
     "Emotion Mode Speaker": "与音色参考相同",
@@ -581,12 +639,21 @@
     "Emotion Melancholic": "忧郁",
     "Emotion Surprised": "惊讶",
     "Emotion Calm": "平静",
+    "Diffusion Steps": "扩散步数",
+    "Diffusion Steps Help": "扩散生成的步数；值越大可能提升质量，但生成更慢。",
+    "CFG Rate": "CFG 引导强度",
+    "CFG Rate Help": "扩散阶段的 classifier-free guidance 强度。",
+    "Interval Silence": "分段静音（毫秒）",
+    "Interval Silence Help": "Pack 在文本分段之间插入的静音时长。",
+    "Segment Overlap": "分段重叠（毫秒）",
+    "Segment Overlap Help": "生成的文本片段之间用于交叉淡化的重叠时长。",
+    "IndexTTS2 Top K Help": "IndexTTS-2 MLX Pack 的 top-k 采样值，必须不小于 1。",
     "Max Text Tokens Per Segment": "单段最大文本 Token",
     "Max Text Tokens Per Segment Help": "IndexTTS-2 分段推理的最大文本 token 数",
     "Max Mel Tokens": "最大 Mel Tokens",
     "Max Mel Tokens Help": "控制单次生成的最大 mel token 数，值越大可生成更长音频",
     "IndexTTS2 Usage Instructions Title": "IndexTTS-2 使用说明",
-    "IndexTTS2 Usage Instructions": "**IndexTTS-2 语音克隆**\n\n1. **选择音色**：复用 IndexTTS-1.5 的资源音频或上传参考音频\n2. **设置 API 地址**：例如 http://192.168.3.6:7863/tts，也可以填写服务根地址\n3. **调整情感参数**：默认使用 speaker，可按需切换到 audio、vector 或 text\n4. **调整生成参数**：temperature、top_p、top_k、num_beams、repetition_penalty 和 max_mel_tokens 会直接传给 IndexTTS-2 接口\n\n**注意事项**：\n- 参考音频质量会直接影响克隆效果\n- 首次请求可能需要加载模型，耗时更长\n- CPU 部署生成速度会明显慢于 GPU",
+    "IndexTTS2 Usage Instructions": "**IndexTTS-2 MLX Pack 语音克隆**\n\n1. **选择音色**：复用 IndexTTS-1.5 的资源音频或上传参考音频\n2. **设置 API 地址**：默认 Pack 服务为 http://127.0.0.1:7860；NarratoAI 会调用 /v1/audio/speech/upload 并上传参考音频\n3. **调整情感参数**：留空时保留参考音频情感；也可输入 happy:0.7,calm:0.3 这类情感或权重混合\n4. **调整生成参数**：speed、temperature、top_p、top_k、repetition_penalty、diffusion_steps、cfg_rate 和 max_mel_tokens 会传给 Pack\n\n**注意事项**：\n- 参考音频质量会直接影响克隆效果\n- 首次请求可能需要加载模型，耗时更长\n- Pack 默认仅监听本机地址",
     "OmniVoice Usage Instructions Title": "OmniVoice 使用说明",
     "OmniVoice Usage Instructions": "**OmniVoice-Pack 语音合成**\n\n1. **自动音色**：只需要设置 API 地址和语言，可直接合成。\n2. **指令音色**：填写 instruct 描述想要的性别、音高、口音或风格。\n3. **参考音频克隆**：上传或选择参考音频，并填写该音频对应文本。\n\n**注意事项**：\n- 当前默认服务地址为 http://127.0.0.1:7866/tts\n- 参考音频克隆在服务未加载 ASR 模型时必须填写参考文本\n- OmniVoice 返回 WAV 音频，系统会按音频时长估算字幕段落",
     "Volcengine Access Key Help": "火山引擎 Access Key",
@@ -646,6 +713,7 @@
     "影视类型": "影视类型",
     "自定义影视类型": "自定义影视类型",
     "原片占比": "原片占比",
+    "文案字数": "文案字数",
     "例如：豪门虐恋": "例如：豪门虐恋",
     "例如：悬疑犯罪": "例如：悬疑犯罪",
     "请输入自定义短剧类型": "请输入自定义短剧类型",

webui/tools/generate_script_short.py

@@ -14,9 +14,25 @@ from webui.tools.generate_short_summary import (
     _build_combined_subtitle_content,
     _normalize_paths,
     analyze_short_drama_plot,
+    parse_and_fix_json,
 )
 
 
+def _parse_generated_script_payload(script):
+    if isinstance(script, list):
+        return script
+
+    if isinstance(script, str):
+        parsed = parse_and_fix_json(script)
+        if isinstance(parsed, list):
+            return parsed
+        if isinstance(parsed, dict) and isinstance(parsed.get("items"), list):
+            return parsed["items"]
+        raise ValueError("Generated script JSON must be a list or contain an items list")
+
+    raise ValueError("Generated script payload must be a list or JSON string")
+
+
 def generate_script_short(
     tr,
     params,
@@ -175,10 +191,7 @@ def generate_script_short(
             script = result.get("script")
             logger.info(f"脚本生成完成 {json.dumps(script, ensure_ascii=False, indent=4)}")
 
-            if isinstance(script, list):
+            st.session_state['video_clip_json'] = _parse_generated_script_payload(script)
-                st.session_state['video_clip_json'] = script
-            elif isinstance(script, str):
-                st.session_state['video_clip_json'] = json.loads(script)
 
             update_progress(80, tr("Script generation completed"))
 

webui/tools/generate_short_summary.py

@@ -176,8 +176,8 @@ def parse_and_fix_json(json_string):
         # 5. 修复单引号
         fixed_json = re.sub(r"'([^']*)':", r'"\1":', fixed_json)
 
-        # 6. 修复没有引号的属性名
+        # 6. 修复没有引号的属性名，仅匹配对象边界后的 key，避免误伤时间戳等字符串值
-        fixed_json = re.sub(r'(\w+)(\s*):', r'"\1"\2:', fixed_json)
+        fixed_json = re.sub(r'([{\[,]\s*)([A-Za-z_][A-Za-z0-9_]*)(\s*:)', r'\1"\2"\3', fixed_json)
 
         # 7. 修复重复的引号
         fixed_json = re.sub(r'""([^"]*?)""', r'"\1"', fixed_json)
@@ -363,6 +363,7 @@ def generate_short_drama_narration_copy(
     search_keywords: str = SHORT_DRAMA_SEARCH_KEYWORDS,
     empty_title_message_key: str = "Please enter short drama name before web search",
     web_search_context_description: str = "短剧名称、人物关系、剧情背景和公开剧情梗概",
+    narration_word_count: int = 500,
 ):
     """生成可由用户审核修改的短剧解说正文，不绑定时间戳。"""
     subtitle_paths = _normalize_paths(subtitle_path)
@@ -422,6 +423,7 @@ def generate_short_drama_narration_copy(
             temperature=temperature,
             narration_language=narration_language,
             drama_genre=drama_genre,
+            narration_word_count=narration_word_count,
         )
     except Exception as e:
         logger.warning(f"使用新LLM服务生成文案失败，回退到旧实现: {str(e)}")
@@ -436,6 +438,7 @@ def generate_short_drama_narration_copy(
             provider=text_provider,
             narration_language=narration_language,
             drama_genre=drama_genre,
+            narration_word_count=narration_word_count,
             prompt_category=prompt_category,
         )
 

webui/tools/test_generate_script_short_unittest.py

@@ -0,0 +1,38 @@
+import unittest
+
+from webui.tools.generate_script_short import _parse_generated_script_payload
+
+
+class GenerateScriptShortPayloadTests(unittest.TestCase):
+    def test_parse_generated_script_payload_keeps_list_payload(self):
+        payload = [{"_id": 1, "timestamp": "00:00:01,000-00:00:02,000"}]
+
+        self.assertEqual(payload, _parse_generated_script_payload(payload))
+
+    def test_parse_generated_script_payload_accepts_items_wrapper(self):
+        payload = '{"items": [{"_id": 1, "timestamp": "00:00:01,000-00:00:02,000"}]}'
+
+        parsed = _parse_generated_script_payload(payload)
+
+        self.assertEqual(1, parsed[0]["_id"])
+
+    def test_parse_generated_script_payload_repairs_common_llm_json_formatting(self):
+        payload = """```json
+{
+  "items": [
+    {"_id": 1, "timestamp": "00:00:01,000-00:00:02,000",},
+  ],
+}
+```"""
+
+        parsed = _parse_generated_script_payload(payload)
+
+        self.assertEqual(1, parsed[0]["_id"])
+
+    def test_parse_generated_script_payload_rejects_invalid_shape(self):
+        with self.assertRaises(ValueError):
+            _parse_generated_script_payload('{"unexpected": []}')
+
+
+if __name__ == "__main__":
+    unittest.main()

webui/tools/test_generate_short_summary_unittest.py

@@ -22,6 +22,19 @@ class GenerateShortSummaryJsonTests(unittest.TestCase):
 
         self.assertEqual(1, parsed["items"][0]["_id"])
 
+    def test_repair_does_not_corrupt_timestamp_values(self):
+        parsed = parse_and_fix_json(
+            """```json
+{
+  items: [
+    {_id: 1, timestamp: "00:00:01,000-00:00:02,000",},
+  ],
+}
+```"""
+        )
+
+        self.assertEqual("00:00:01,000-00:00:02,000", parsed["items"][0]["timestamp"])
+
 
 if __name__ == "__main__":
     unittest.main()