Merge pull request #3158 from xinnan-tech/chore/cleanup

chore: 暂时移除近期不可用或不稳定的TTS供应器及相关配置
2026-07-22 07:03:53 +08:00 · 2026-05-08 10:38:53 +08:00
parent e9bf006d9d c693ff1564
commit 7b0f59a747
9 changed files with 41 additions and 416 deletions
@@ -149,6 +149,7 @@ tmp
 .history
 .DS_Store
 main/xiaozhi-server/data
+main/xiaozhi-server/.claude

 main/manager-web/node_modules
 .config.yaml
@@ -0,0 +1,5 @@
+-- 删除provider_code为ttson的供应器
+DELETE FROM `ai_model_provider` WHERE `provider_code` = 'ttson';
+
+-- 删除model_code为ACGNTTS的配置
+DELETE FROM `ai_model_config` WHERE `model_code` = 'ACGNTTS';
@@ -0,0 +1,6 @@
+-- 删除model_code为GizwitsTTS的配置
+DELETE FROM `ai_model_config` WHERE `model_code` = 'GizwitsTTS';
+
+-- 删除关联的TTS音色记录
+DELETE FROM `ai_tts_voice` WHERE `tts_model_id` = 'TTS_GizwitsTTS';
+DELETE FROM `ai_tts_voice` WHERE `tts_model_id` = 'TTS_ACGNTTS';
@@ -0,0 +1,8 @@
+-- 删除provider_code为linkerai的供应商配置
+DELETE FROM `ai_model_provider` WHERE `provider_code` = 'linkerai';
+
+-- 删除model_code为LinkeraiTTS的模型配置
+DELETE FROM `ai_model_config` WHERE `model_code` = 'LinkeraiTTS';
+
+-- 删除LinkeraiTTS关联的TTS音色记录
+DELETE FROM `ai_tts_voice` WHERE `tts_model_id` = 'TTS_LinkeraiTTS';
@@ -641,3 +641,24 @@ databaseChangeLog:
        - sqlFile:
            encoding: utf8
            path: classpath:db/changelog/202604300930.sql
+  - changeSet:
+      id: 202605071037
+      author: fyb
+      changes:
+        - sqlFile:
+            encoding: utf8
+            path: classpath:db/changelog/202605071037.sql
+  - changeSet:
+      id: 202605071120
+      author: fyb
+      changes:
+        - sqlFile:
+            encoding: utf8
+            path: classpath:db/changelog/202605071120.sql
+  - changeSet:
+      id: 202605081008
+      author: fyb
+      changes:
+        - sqlFile:
+            encoding: utf8
+            path: classpath:db/changelog/202605081008.sql
@@ -1,11 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(tree:*)",
-      "Bash(find:*)",
-      "Bash(python3:*)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}
@@ -1053,36 +1053,6 @@ TTS:
    output_dir: tmp/
    access_token: "你的302API密钥"
    # language: "中文"  # 指定输出语种,如:中文、英语、日语、韩语等,请根据所选音色支持的语言进行设置,不填则默认为中文
-  GizwitsTTS:
-    type: doubao
-    # 火山引擎作为基座，可以完全使用企业级火山引擎语音合成服务
-    # 前一万名注册的用户，将送5元体验金额
-    # 获取API Key地址：https://agentrouter.gizwitsapi.com/panel/token
-    api_url: https://bytedance.gizwitsapi.com/api/v1/tts
-    authorization: "Bearer "
-    # 湾湾小何音色
-    voice: "zh_female_wanwanxiaohe_moon_bigtts"
-    output_dir: tmp/
-    access_token: "你的机智云API key"
-    # language: "中文"  # 指定输出语种,如:中文、英语、日语、韩语等,请根据所选音色支持的语言进行设置,不填则默认为中文
-  ACGNTTS:
-    #在线网址：https://acgn.ttson.cn/
-    #token购买：www.ttson.cn
-    #开发相关疑问请提交至网站上的qq
-    #角色id获取地址：ctrl+f快速检索角色——网站管理者不允许发布,可询问网站管理者
-    #各参数意义见开发文档：https://www.yuque.com/alexuh/skmti9/wm6taqislegb02gd?singleDoc#
-    type: ttson
-    token: your_token
-    voice_id: 1695
-    speed_factor: 1
-    pitch_factor: 0
-    volume_change_dB: 0
-    to_lang: ZH
-    url: https://u95167-bd74-2aef8085.westx.seetacloud.com:8443/flashsummary/tts?token=
-    format: mp3
-    output_dir: tmp/
-    emotion: 1
-    # language: "中文"  # 指定输出语种,如:中文、英语、日语、韩语等,请根据所选音色支持的语言进行设置,不填则默认为中文
  OpenAITTS:
    # openai官方文本转语音服务，可支持全球大多数语种
    type: openai
@@ -1122,18 +1092,6 @@ TTS:
    format: mp3 # 接口返回的音频格式
    output_dir: tmp/
    # language: "中文"  # 指定输出语种,如:中文、英语、日语、韩语等,请根据所选音色支持的语言进行设置,不填则默认为中文
-  LinkeraiTTS:
-    type: linkerai
-    api_url: https://tts.linkerai.cn/tts
-    audio_format: "pcm"
-    # 默认的access_token供大家测试时免费使用的，此access_token请勿用于商业用途
-    # 如果效果不错，可自行申请token，申请地址：https://linkerai.cn
-    # 各参数意义见开发文档：https://tts.linkerai.cn/docs
-    # 支持声音克隆，可自行上传音频，填入voice参数，voice参数为空时，使用默认声音
-    access_token: "U4YdYXVfpwWnk2t5Gp822zWPCuORyeJL"
-    voice: "OUeAo1mhq6IBExi"
-    output_dir: tmp/
-    # language: "中文"  # 指定输出语种,如:中文、英语、日语、韩语等,请根据所选音色支持的语言进行设置,不填则默认为中文
  PaddleSpeechTTS:
    #百度飞浆 PaddleSpeech 支持本地离线部署 支持模型训练
    #框架地址 https://www.paddlepaddle.org.cn/
@@ -1,267 +0,0 @@
-import os
-import time
-import queue
-import aiohttp
-import asyncio
-import requests
-import traceback
-from config.logger import setup_logging
-from core.utils.tts import MarkdownCleaner
-from core.providers.tts.base import TTSProviderBase
-from core.utils import opus_encoder_utils, textUtils
-from core.providers.tts.dto.dto import SentenceType, ContentType, InterfaceType
-
-TAG = __name__
-logger = setup_logging()
-
-
-class TTSProvider(TTSProviderBase):
-    def __init__(self, config, delete_audio_file):
-        super().__init__(config, delete_audio_file)
-        self.interface_type = InterfaceType.SINGLE_STREAM
-        self.access_token = config.get("access_token")
-        self.voice = config.get("voice")
-        self.api_url = config.get("api_url")
-        self.audio_format = "pcm"
-        self.before_stop_play_files = []
-
-        # PCM缓冲区
-        self.pcm_buffer = bytearray()
-
-    def tts_text_priority_thread(self):
-        """流式文本处理线程"""
-        while not self.conn.stop_event.is_set():
-            try:
-                message = self.tts_text_queue.get(timeout=1)
-                if message.sentence_type == SentenceType.FIRST:
-                    # 初始化参数
-                    self.tts_stop_request = False
-                    self.processed_chars = 0
-                    self.tts_text_buff = []
-                    self.before_stop_play_files.clear()
-                elif ContentType.TEXT == message.content_type:
-                    self.tts_text_buff.append(message.content_detail)
-                    segment_text = self._get_segment_text()
-                    if segment_text:
-                        self.to_tts_single_stream(segment_text)
-
-                elif ContentType.FILE == message.content_type:
-                    logger.bind(tag=TAG).info(
-                        f"添加音频文件到待播放列表: {message.content_file}"
-                    )
-                    if message.content_file and os.path.exists(message.content_file):
-                        # 先处理文件音频数据
-                        self._process_audio_file_stream(message.content_file, callback=lambda audio_data: self.handle_audio_file(audio_data, message.content_detail))
-                if message.sentence_type == SentenceType.LAST:
-                    # 处理剩余的文本
-                    self._process_remaining_text_stream(True)
-
-            except queue.Empty:
-                continue
-            except Exception as e:
-                logger.bind(tag=TAG).error(
-                    f"处理TTS文本失败: {str(e)}, 类型: {type(e).__name__}, 堆栈: {traceback.format_exc()}"
-                )
-
-    def _process_remaining_text_stream(self, is_last=False):
-        """处理剩余的文本并生成语音
-
-        Returns:
-            bool: 是否成功处理了文本
-        """
-        full_text = "".join(self.tts_text_buff)
-        remaining_text = full_text[self.processed_chars :]
-        if remaining_text:
-            segment_text = textUtils.get_string_no_punctuation_or_emoji(remaining_text)
-            if segment_text:
-                self.to_tts_single_stream(segment_text, is_last)
-                self.processed_chars += len(full_text)
-            else:
-                self._process_before_stop_play_files()
-        else:
-            self._process_before_stop_play_files()
-
-    def to_tts_single_stream(self, text, is_last=False):
-        try:
-            max_repeat_time = 5
-            original_text = text
-            text = MarkdownCleaner.clean_markdown(text)
-            if self._correct_words_pattern:
-                text = self._correct_words_pattern.sub(lambda m: self.correct_words[m.group(0)], text)
-            try:
-                asyncio.run(self.text_to_speak(text, is_last))
-            except Exception as e:
-                logger.bind(tag=TAG).warning(
-                    f"语音生成失败{5 - max_repeat_time + 1}次: {original_text}，错误: {e}"
-                )
-                max_repeat_time -= 1
-
-            if max_repeat_time > 0:
-                logger.bind(tag=TAG).info(
-                    f"语音生成成功: {original_text}，重试{5 - max_repeat_time}次"
-                )
-            else:
-                logger.bind(tag=TAG).error(
-                    f"语音生成失败: {original_text}，请检查网络或服务是否正常"
-                )
-        except Exception as e:
-            logger.bind(tag=TAG).error(f"Failed to generate TTS file: {e}")
-        finally:
-            return None
-
-    async def text_to_speak(self, text, is_last):
-        """流式处理TTS音频，每句只推送一次音频列表"""
-        await self._tts_request(text, is_last)
-
-    async def close(self):
-        """资源清理"""
-        await super().close()
-        if hasattr(self, "opus_encoder"):
-            self.opus_encoder.close()
-
-    async def _tts_request(self, text: str, is_last: bool) -> None:
-        params = {
-            "tts_text": text,
-            "spk_id": self.voice,
-            "frame_durition": 60,
-            "stream": "true",
-            "target_sr": self.conn.sample_rate,
-            "audio_format": "pcm",
-            "instruct_text": "请生成一段自然流畅的语音",
-        }
-        headers = {
-            "Authorization": f"Bearer {self.access_token}",
-            "Content-Type": "application/json",
-        }
-
-        # 一帧 PCM 所需字节数：60 ms × sample_rate × 1 ch × 2 B
-        frame_bytes = int(
-            self.opus_encoder.sample_rate
-            * self.opus_encoder.channels  # 1
-            * self.opus_encoder.frame_size_ms
-            / 1000
-            * 2
-        )  # 16-bit = 2 bytes
-
-        try:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(
-                    self.api_url, params=params, headers=headers, timeout=10
-                ) as resp:
-
-                    if resp.status != 200:
-                        logger.bind(tag=TAG).error(
-                            f"TTS请求失败: {resp.status}, {await resp.text()}"
-                        )
-                        self.tts_audio_queue.put((SentenceType.LAST, [], None))
-                        return
-
-                    self.pcm_buffer.clear()
-                    self.tts_audio_queue.put((SentenceType.FIRST, [], text))
-
-                    # 兼容 iter_chunked / iter_chunks / iter_any
-                    async for chunk in resp.content.iter_any():
-                        data = chunk[0] if isinstance(chunk, (list, tuple)) else chunk
-                        if not data:
-                            continue
-
-                        # 拼到 buffer
-                        self.pcm_buffer.extend(data)
-
-                        # 够一帧就编码
-                        while len(self.pcm_buffer) >= frame_bytes:
-                            frame = bytes(self.pcm_buffer[:frame_bytes])
-                            del self.pcm_buffer[:frame_bytes]
-
-                            self.opus_encoder.encode_pcm_to_opus_stream(
-                                frame,
-                                end_of_stream=False,
-                                callback=self.handle_opus
-                            )
-
-                    # flush 剩余不足一帧的数据
-                    if self.pcm_buffer:
-                        self.opus_encoder.encode_pcm_to_opus_stream(
-                            bytes(self.pcm_buffer),
-                            end_of_stream=True,
-                            callback=self.handle_opus
-                        )
-                        self.pcm_buffer.clear()
-
-                    # 如果是最后一段，输出音频获取完毕
-                    if is_last:
-                        self._process_before_stop_play_files()
-
-        except Exception as e:
-            logger.bind(tag=TAG).error(f"TTS请求异常: {e}")
-            self.tts_audio_queue.put((SentenceType.LAST, [], None))
-
-    def to_tts(self, text: str) -> list:
-        """非流式TTS处理，用于测试及保存音频文件的场景
-        Args:
-            text: 要转换的文本
-        Returns:
-            list: 返回opus编码后的音频数据列表
-        """
-        start_time = time.time()
-        text = MarkdownCleaner.clean_markdown(text)
-        if self._correct_words_pattern:
-            text = self._correct_words_pattern.sub(lambda m: self.correct_words[m.group(0)], text)
-
-        params = {
-            "tts_text": text,
-            "spk_id": self.voice,
-            "frame_duration": 60,
-            "stream": False,
-            "target_sr": self.conn.sample_rate,
-            "audio_format": self.audio_format,
-            "instruct_text": "请生成一段自然流畅的语音",
-        }
-        headers = {
-            "Authorization": f"Bearer {self.access_token}",
-            "Content-Type": "application/json",
-        }
-
-        try:
-            with requests.get(
-                self.api_url, params=params, headers=headers, timeout=5
-            ) as response:
-                if response.status_code != 200:
-                    logger.bind(tag=TAG).error(
-                        f"TTS请求失败: {response.status_code}, {response.text}"
-                    )
-                    return []
-
-                logger.info(f"TTS请求成功: {text}, 耗时: {time.time() - start_time}秒")
-
-                # 使用opus编码器处理PCM数据
-                opus_datas = []
-                pcm_data = response.content
-
-                # 计算每帧的字节数
-                frame_bytes = int(
-                    self.opus_encoder.sample_rate
-                    * self.opus_encoder.channels
-                    * self.opus_encoder.frame_size_ms
-                    / 1000
-                    * 2
-                )
-
-                # 分帧处理PCM数据
-                for i in range(0, len(pcm_data), frame_bytes):
-                    frame = pcm_data[i : i + frame_bytes]
-                    if len(frame) < frame_bytes:
-                        # 最后一帧可能不足，用0填充
-                        frame = frame + b"\x00" * (frame_bytes - len(frame))
-
-                    self.opus_encoder.encode_pcm_to_opus_stream(
-                        frame,
-                        end_of_stream=(i + frame_bytes >= len(pcm_data)),
-                        callback=lambda opus: opus_datas.append(opus)
-                    )
-
-                return opus_datas
-
-        except Exception as e:
-            logger.bind(tag=TAG).error(f"TTS请求异常: {e}")
-            return []
@@ -1,96 +0,0 @@
-import os
-import uuid
-import json
-import requests
-import shutil
-from datetime import datetime
-from core.providers.tts.base import TTSProviderBase
-from config.logger import setup_logging
-
-TAG = __name__
-logger = setup_logging()
-
-
-class TTSProvider(TTSProviderBase):
-    TTS_PARAM_CONFIG = [
-        ("ttsVolume", "volume_change_dB", -10, 10, 0, int),
-        ("ttsRate", "speed_factor", 0.5, 2, 0, lambda v: round(float(v), 1)),
-        ("ttsPitch", "pitch_factor", -8, 8, 0, lambda v: round(float(v), 1)),
-    ]
-
-    def __init__(self, config, delete_audio_file):
-        super().__init__(config, delete_audio_file)
-        self.url = config.get(
-            "url",
-            "https://u95167-bd74-2aef8085.westx.seetacloud.com:8443/flashsummary/tts?token=",
-        )
-        if config.get("private_voice"):
-            self.voice = int(config.get("private_voice"))
-        else:
-            self.voice = int(config.get("voice_id", 1695))
-        self.token = config.get("token")
-        self.to_lang = config.get("to_lang")
-        self.volume_change_dB = int(config.get("volume_change_dB", 0))
-        self.speed_factor = int(config.get("speed_factor", 1))
-        self.stream = str(config.get("stream", False)).lower() in ("true", "1", "yes")
-        self.output_file = config.get("output_dir")
-        self.pitch_factor = int(config.get("pitch_factor", 0))
-        self.audio_file_type = config.get("format", "mp3")
-        self.emotion = int(config.get("emotion", 1))
-        self.header = {"Content-Type": "application/json"}
-
-        # 应用百分比调整（如果存在），否则使用公有化配置
-        self._apply_percentage_params(config)
-
-    def generate_filename(self, extension=".mp3"):
-        return os.path.join(
-            self.output_file,
-            f"tts-{datetime.now().date()}@{uuid.uuid4().hex}{extension}",
-        )
-
-    async def text_to_speak(self, text, output_file):
-        url = f"{self.url}{self.token}"
-        result = "firefly"
-        payload = json.dumps(
-            {
-                "to_lang": self.to_lang,
-                "text": text,
-                "emotion": self.emotion,
-                "format": self.audio_file_type,
-                "volume_change_dB": self.volume_change_dB,
-                "voice_id": self.voice,
-                "pitch_factor": self.pitch_factor,
-                "speed_factor": self.speed_factor,
-                "token": self.token,
-            }
-        )
-
-        resp = requests.request("POST", url, data=payload)
-        if resp.status_code != 200:
-            logger.bind(tag=TAG).error(f"TTSON 请求失败: {resp.text}")
-            raise Exception(f"{__name__}: TTS请求失败")
-        resp_json = resp.json()
-        try:
-            result = (
-                resp_json["url"]
-                + ":"
-                + str(resp_json["port"])
-                + "/flashsummary/retrieveFileData?stream=True&token="
-                + self.token
-                + "&voice_audio_path="
-                + resp_json["voice_path"]
-            )
-
-            audio_content = requests.get(result)
-            if output_file:
-                with open(output_file, "wb") as f:
-                    f.write(audio_content.content)
-            else:
-                return audio_content.content
-            voice_path = resp_json.get("voice_path")
-            des_path = output_file
-            shutil.move(voice_path, des_path)
-
-        except Exception as e:
-            print("error:", e)
-            raise Exception(f"{__name__}: TTS请求失败")