allvoicelabs-mcp 0.0.1__py3-none-any.whl

allvoicelabs_mcp/__init__.py

@@ -0,0 +1 @@
+# AllVoiceLabs MCP 包

allvoicelabs_mcp/server.py

@@ -0,0 +1,276 @@
+import logging
+import os
+import sys
+
+from mcp.server.fastmcp import FastMCP
+from mcp.types import TextContent
+
+from client import AllVoiceLab
+
+
+def main():
+    # 获取环境变量
+    api_key = os.getenv("ALLVOICELABS_API_KEY")
+    api_domain = os.getenv("ALLVOICELABS_API_DOMAIN")
+    
+    if not api_key:
+        print("错误: 未设置ALLVOICELABS_API_KEY环境变量")
+        sys.exit(1)
+    
+    # 创建 AllVoiceLab 实例
+    all_voice_lab = AllVoiceLab(api_key, api_domain)
+    # 创建 MCP 服务器
+    mcp = FastMCP("AllVoiceLabs")
+
+    @mcp.tool(
+        name="get_supported_voice_model",
+        description="""【千音工具】获取可用的语音模型"""
+    )
+    def get_supported_models() -> TextContent:
+        try:
+            resp = all_voice_lab.get_supported_voice_model()
+            models = resp.models
+            if len(models) == 0:
+                return TextContent(
+                    type="text",
+                    text="未找到可用的语音模型"
+                )
+            # 按照设计文档格式化返回结果
+            buffer = []
+            for i, model in enumerate(models):
+                # 如果不是第一个模型，添加分隔符
+                if i > 0:
+                    buffer.append("---------------------\n")
+
+                buffer.append(f"- id: {model.model_id}\n")
+                buffer.append(f"- 名称：{model.name}\n")
+                buffer.append(f"- 描述：{model.description}\n")
+
+            # 添加最后的分隔符
+            buffer.append("---------------------\n")
+
+            # 将列表连接成字符串
+            result = "".join(buffer)
+            return TextContent(
+                type="text",
+                text=result
+            )
+        except Exception as e:
+            logging.error(e)
+            return TextContent(
+                type="text",
+                text=f"获取模型失败，工具暂时不可用"
+            )
+
+
+    @mcp.tool(
+        name="get_all_voices",
+        description="""【千音工具】获取可用的音色"""
+    )
+    def get_all_voices() -> TextContent:
+        try:
+            resp = all_voice_lab.get_all_voices()
+            voices = resp.voices
+            if len(voices) == 0:
+                return TextContent(
+                    type="text",
+                    text="未找到可用的音色"
+                )
+
+            # 按照设计文档格式化返回结果
+            buffer = []
+            for i, voice in enumerate(voices):
+                # 如果不是第一个音色，添加分隔符
+                if i > 0:
+                    buffer.append("---------------------\n")
+
+                buffer.append(f"- id: {voice.voice_id}\n")
+                buffer.append(f"- 名称：{voice.name}\n")
+                buffer.append(f"- 描述：{voice.description}\n")
+
+                # 添加语言和性别信息（如果存在）
+                if "language" in voice.labels:
+                    buffer.append(f"- 语言：{voice.labels['language']}\n")
+                if "gender" in voice.labels:
+                    buffer.append(f"- 性别：{voice.labels['gender']}\n")
+
+            # 添加最后的分隔符
+            buffer.append("---------------------\n")
+
+            # 将列表连接成字符串
+            result = "".join(buffer)
+            return TextContent(
+                type="text",
+                text=result
+            )
+        except Exception as e:
+            logging.error(e)
+            return TextContent(
+                type="text",
+                text=f"获取音色失败，工具暂时不可用"
+            )
+
+
+    @mcp.tool(
+        name="text_to_speech",
+        description="""【千音工具】根据提供的文本合成语音。
+        
+        Args:
+            text: 需要合成语音的目标文本
+            voice_id: 合成语音时使用的音色的音色id，用户没有指定的时候，获取可用的音色并使用第一个
+            model_id: 合成语音时使用的模型id，用户没有指定的时候，获取可用的语音模型并使用第一个
+            speed: 语速, 范围[-5, 5], 默认值1
+            output_dir: 输出目录，默认为用户桌面
+            
+        Returns:
+            TextContent containing file path to the generated audio file.
+        """
+    )
+    def text_to_speech(
+        text: str,
+        voice_id: str,
+        model_id: str,
+        speed: int = 1,
+        output_dir: str = os.path.join(os.path.expanduser("~"), "Desktop")
+    ) -> TextContent:
+        # 校验参数
+        if not text:
+            return TextContent(
+                type="text",
+                text="text参数不能为空"
+            )
+        if not voice_id:
+            return TextContent(
+                type="text",
+                text="voice_id参数不能为空"
+            )
+        if not model_id:
+            return TextContent(
+                type="text",
+                text="model_id参数不能为空"
+            )
+
+        try:
+            file_path = all_voice_lab.text_to_speech(text, voice_id, model_id, output_dir, speed)
+            return TextContent(
+                type="text",
+                text=f"语音生成完成，文件保存在：{file_path}\n"
+            )
+        except Exception as e:
+            logging.error(e)
+            return TextContent(
+                type="text",
+                text=f"合成失败，工具暂时不可用"
+            )
+
+
+    @mcp.tool(
+        name="speech_to_speech",
+        description="""【千音工具】将音频转换为另一个音色。
+        
+        Args:
+            audio_file_path: 音频文件路径
+            voice_id: 合成语音时使用的音色的音色id
+            similarity: 相似度，范围[0, 1]，默认值1
+            remove_background_noise: 是否去除背景噪音，默认值False
+            output_dir: 输出目录，默认为用户桌面
+            
+        Returns:
+            TextContent containing file path to the generated audio file.
+        """
+    )
+    def speech_to_speech(
+        audio_file_path: str,
+        voice_id: str,
+        similarity: float = 1,
+        remove_background_noise: bool = False,
+        output_dir: str = os.path.join(os.path.expanduser("~"), "Desktop")
+    ) -> TextContent:
+        # 校验参数
+        if not audio_file_path:
+            return TextContent(
+                type="text",
+                text="audio_file_path参数不能为空"
+            )
+        if not voice_id:
+            return TextContent(
+                type="text",
+                text="voice_id参数不能为空"
+            )
+
+        # 验证相似度范围
+        if similarity < 0 or similarity > 1:
+            return TextContent(
+                type="text",
+                text="similarity参数必须在0到1之间"
+            )
+
+        try:
+            file_path = all_voice_lab.speech_to_speech(audio_file_path, voice_id, output_dir, similarity,
+                                                     remove_background_noise)
+            return TextContent(
+                type="text",
+                text=f"音频转换完成，文件保存在：{file_path}\n"
+            )
+        except FileNotFoundError as e:
+            logging.error(e)
+            return TextContent(
+                type="text",
+                text=f"音频文件不存在: {audio_file_path}"
+            )
+        except Exception as e:
+            logging.error(e)
+            return TextContent(
+                type="text",
+                text=f"转换失败，工具暂时不可用"
+            )
+
+
+    @mcp.tool(
+        name="audio_isolation",
+        description="""【千音工具】这是一个人声分离功能，消除音频的背景噪音，仅保留人声。
+        
+        Args:
+            audio_file_path: 音频文件路径
+            output_dir: 输出目录，默认为用户桌面
+            
+        Returns:
+            TextContent containing file path to the generated audio file.
+        """
+    )
+    def audio_isolation(
+        audio_file_path: str,
+        output_dir: str = os.path.join(os.path.expanduser("~"), "Desktop")
+    ) -> TextContent:
+        # 校验参数
+        if not audio_file_path:
+            return TextContent(
+                type="text",
+                text="audio_file_path参数不能为空"
+            )
+
+        try:
+            file_path = all_voice_lab.audio_isolation(audio_file_path, output_dir)
+            return TextContent(
+                type="text",
+                text=f"人声分离完成，文件保存在：{file_path}\n"
+            )
+        except FileNotFoundError as e:
+            logging.error(e)
+            return TextContent(
+                type="text",
+                text=f"音频文件不存在: {audio_file_path}"
+            )
+        except Exception as e:
+            logging.error(e)
+            return TextContent(
+                type="text",
+                text=f"人声分离失败，工具暂时不可用"
+            )
+
+    print("Starting AllVoiceLabs MCP server")
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

allvoicelabs_mcp-0.0.1.dist-info/METADATA

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: allvoicelabs-mcp
+Version: 0.0.1
+Summary: AllVoiceLabs MCP Server
+Author-email: AllVoiceLabs <support@example.com>
+Keywords: elevenlabs,mcp,text-to-speech,speech-to-text,voice-cloning
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: build>=1.2.2.post1
+Requires-Dist: mcp[cli]>=1.6.0
+Requires-Dist: requests>=2.32.3
+Requires-Dist: setuptools>=45
+Requires-Dist: twine>=6.1.0
+
+# AllVoiceLabs MCP
+
+This is an AllVoiceLabs MCP (Model Control Protocol) service that provides voice synthesis and conversion functionality.
+
+## Quickstart
+
+1. Get your API key from [AllVoiceLab](https://www.allvoicelab.com/).
+2. Install `uv` (Python package manager), install with `curl -LsSf https://astral.sh/uv/install.sh | sh`
+3. Use Cline for example:
+
+```json
+{
+  "mcpServers": {
+    "ElevenLabs": {
+      "command": "uvx",
+      "args": ["allvoicelabs-mcp"],
+      "env": {
+        "ALLVOICELABS_API_KEY": "<insert-your-api-key-here>",
+        "ALLVOICELABS_API_DOMAIN": "<insert-api-domain-here>"
+      }
+    }
+  }
+}
+```

allvoicelabs_mcp-0.0.1.dist-info/RECORD

@@ -0,0 +1,20 @@
+allvoicelabs_mcp/__init__.py,sha256=8-U4es3BzXwCStMWsQkGNSRofDvjXWboOYdlCDBY1b8,22
+allvoicelabs_mcp/server.py,sha256=oob5vEaGbRwTRbyiDKRNuWXN62vMwl-rSdbdWS-9__0,9147
+allvoicelabs_mcp/__pycache__/__init__.cpython-311.pyc,sha256=UuAB8stq2Hhg8yU8EeKhPwxKtjEgjQLiN6UCIHlYRVg,183
+allvoicelabs_mcp/__pycache__/server.cpython-311.pyc,sha256=3ZqCMJ61wWcKGdB4_PwuDheR2koGlEZbsjJV5t4eMHc,11444
+client/__init__.py,sha256=H12-2aUEjckmXWDiMP6TkPH7FJw89wNQtCsIAInfhAo,65
+client/all_voice_lab.py,sha256=iFVjt7HVKclBnNX3to2DO7xM2Fa-uWBP2TWI6LFw5GU,10271
+client/model.py,sha256=WRI1SQSMtuColwmV_YO5E-ChJIEHpy4xWS56_BfAQxA,2798
+client/__pycache__/__init__.cpython-311.pyc,sha256=bdxyQkRPcfVJ2HHfY5iVgpy55-7s8qTvV6XdRIN04-M,261
+client/__pycache__/all_voice_lab.cpython-311.pyc,sha256=cUB76dN0EUwQcFQlVMdDh0440oVOw2rUc99wTa1i3KM,12135
+client/__pycache__/audio_isolation.cpython-311.pyc,sha256=6xJn442ydg9KOtHEC1pPk49NWqDuDV9jABBH-49k3fY,3007
+client/__pycache__/get_all_voices.cpython-311.pyc,sha256=OCPNseNONuZZMnrq-4QR-y-wfsyzYBr3_BBphtbwbD0,5172
+client/__pycache__/get_supported_voice_model.cpython-311.pyc,sha256=ifG4AcYSGMxdc8atkY-uMv-2mgD17inOJJ8R_8VeQ0A,4447
+client/__pycache__/model.cpython-311.pyc,sha256=kcywkYqKMvfHGOC49O9WDDwjf3nUAPITN2z-vGwU0xw,6644
+client/__pycache__/speech_to_speech.cpython-311.pyc,sha256=YeM_RNvpY35PQWAqVGoAh8wtdpbTFbjztNoINPTXS6M,3488
+client/__pycache__/text_to_speech.cpython-311.pyc,sha256=BGNsjwBv9YICI60hoq1-WhkhIdej1WizwJiFVBuct_k,2768
+allvoicelabs_mcp-0.0.1.dist-info/METADATA,sha256=rzsv_QuczE400Ip7tntCR-yNa-Qd_JesNo-QT6bpo6g,1061
+allvoicelabs_mcp-0.0.1.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+allvoicelabs_mcp-0.0.1.dist-info/entry_points.txt,sha256=Bb6tkeBuBROB82Hgl3EHn0SprJOo3sl6xQYoIgwglC8,66
+allvoicelabs_mcp-0.0.1.dist-info/top_level.txt,sha256=Uf_WW0U55B5f-gihggnnoYeVVvQ3pPFOJw4asw6CQME,24
+allvoicelabs_mcp-0.0.1.dist-info/RECORD,,

allvoicelabs_mcp-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (79.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

allvoicelabs_mcp-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+allvoicelabs-mcp = allvoicelabs_mcp.server:main

allvoicelabs_mcp-0.0.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+allvoicelabs_mcp
+client

client/__init__.py

@@ -0,0 +1,3 @@
+from .all_voice_lab import AllVoiceLab
+
+__all__ = ['AllVoiceLab']

client/all_voice_lab.py

@@ -0,0 +1,313 @@
+import json
+import logging
+import random
+import re
+import time
+from pathlib import Path
+from typing import Dict, Optional
+
+import requests
+
+from client.model import GetAllVoicesResponse, GetSupportedVoiceModelResponse
+
+
+class AllVoiceLab:
+    """
+    AllVoiceLab类，封装所有API方法，提供统一的接口
+    """
+
+    def __init__(self, api_key: str, api_domain: str = "https://api-testing.all-voice.cn"):
+        """
+        初始化AllVoiceLab类
+        
+        Args:
+            api_key: API密钥
+            api_domain: API域名，默认为测试环境
+        """
+        self.api_key = api_key
+        self.api_domain = api_domain.rstrip('/')
+
+    def _get_headers(self, content_type: str = "application/json") -> Dict[str, str]:
+        """
+        获取请求头
+        
+        Args:
+            content_type: 内容类型
+            
+        Returns:
+            请求头字典
+        """
+        return {
+            "Content-Type": content_type,
+            "Accept": "application/json",
+            "ai-api-key": self.api_key
+        }
+
+    def get_all_voices(self) -> Optional[GetAllVoicesResponse]:
+        """
+        获取所有音色
+        
+        Returns:
+            音色列表响应对象
+        """
+        # 创建HTTP请求
+        url = f"{self.api_domain}/v1/voices/internal_get_all_voices?status=[2]&legacy_voice_skip_disabled=true"
+
+        # 发送请求
+        response = requests.get(url, headers=self._get_headers(), timeout=30)
+
+        # 检查状态码
+        if response.status_code != 200:
+            logging.error(f"请求失败，状态码: {response.status_code}")
+            raise Exception(f"请求失败，状态码: {response.status_code}")
+
+        # 读取响应内容
+        response_data = response.text
+        logging.info(response_data)
+
+        # 解析JSON响应并直接转换为对象
+        json_data = json.loads(response_data)
+        api_resp = GetAllVoicesResponse.from_dict(json_data)
+
+        # 只要前10个
+        if len(api_resp.voices) > 10:
+            api_resp.voices = api_resp.voices[:10]
+
+        return api_resp
+
+    def get_supported_voice_model(self) -> GetSupportedVoiceModelResponse:
+        """
+        获取支持的语音模型
+        
+        Returns:
+            支持的语音模型响应对象
+        """
+        # 创建HTTP请求
+        url = f"{self.api_domain}/v1/voices/get_supported_model"
+
+        # 直接使用requests库发送请求
+        response = requests.get(url, headers=self._get_headers(), timeout=30)
+
+        # 检查状态码
+        if response.status_code != 200:
+            # 抛出一个异常
+            logging.error(f"请求失败，状态码: {response.status_code}")
+            raise Exception(f"请求失败，状态码: {response.status_code}")
+
+        # 读取响应内容
+        response_data = response.text
+        logging.info(response_data)
+
+        # 解析JSON响应
+        json_data = json.loads(response_data)
+        resp = GetSupportedVoiceModelResponse.from_dict(json_data)
+
+        return resp
+
+    def audio_isolation(self, audio_file_path: str, output_dir: str) -> str:
+        """
+        将音频文件发送到人声分离API，并将结果保存到本地
+        
+        Args:
+            audio_file_path: 音频文件路径
+            output_dir: 输出目录
+        
+        Returns:
+            保存后的文件路径
+        """
+        # 检查文件是否存在
+        audio_path = Path(audio_file_path)
+        if not audio_path.exists():
+            raise FileNotFoundError(f"音频文件不存在: {audio_file_path}")
+
+        # 创建输出目录
+        output_path = Path(output_dir)
+        output_path.mkdir(parents=True, exist_ok=True)
+
+        # 准备HTTP请求
+        url = f"{self.api_domain}/v1/audio-isolation/create"
+
+        # 使用with语句安全地打开文件
+        with open(audio_path, 'rb') as audio_file:
+            # 创建multipart表单数据
+            files = {
+                'audio': (audio_path.name, audio_file)
+            }
+
+            # 设置请求头
+            headers = {
+                'Accept': '*/*',
+                'ai-api-key': self.api_key
+            }
+
+            # 发送请求
+            response = requests.post(url, files=files, headers=headers)
+
+            # 检查响应状态
+            response.raise_for_status()
+
+            # 尝试从响应头中获取文件名
+            filename = None
+            content_disposition = response.headers.get('Content-Disposition')
+            if content_disposition:
+                filename_match = re.search(r'filename="?([^"]+)"?', content_disposition)
+                if filename_match:
+                    filename = filename_match.group(1)
+
+            # 如果没有从响应头获取到文件名，则生成一个唯一文件名
+            if not filename:
+                timestamp = int(time.time())
+                random_suffix = ''.join(random.choices('abcdefghijklmnopqrstuvwxyz0123456789', k=6))
+                filename = f"audio_isolation_{timestamp}_{random_suffix}.mp3"
+
+            # 构建完整文件路径
+            file_path = output_path / filename
+
+            # 将响应内容保存到文件
+            with open(file_path, 'wb') as f:
+                f.write(response.content)
+
+            # 返回文件路径
+            return str(file_path)
+
+    def speech_to_speech(self, audio_file_path: str, voice_id_str: str, output_dir: str, similarity: float = 1,
+                         remove_background_noise: bool = False) -> str:
+        """
+        调用API将音频转换为另一个音色并保存到本地
+        
+        Args:
+            audio_file_path: 音频文件路径
+            voice_id_str: 音色ID
+            output_dir: 输出目录
+            similarity: 相似度，范围[0, 1]
+            remove_background_noise: 是否去除背景噪音
+            
+        Returns:
+            保存的音频文件路径
+        """
+        # 检查文件是否存在
+        audio_path = Path(audio_file_path)
+        if not audio_path.exists():
+            raise FileNotFoundError(f"音频文件不存在: {audio_file_path}")
+
+        # 创建输出目录
+        output_path = Path(output_dir)
+        output_path.mkdir(parents=True, exist_ok=True)
+
+        # 准备请求参数
+        url = f"{self.api_domain}/v1/speech-to-speech/create"
+
+        # 准备请求数据
+        data = {
+            'voice_id': voice_id_str,
+            'similarity': str(similarity),
+            'remove_background_noise': str(remove_background_noise).lower()
+        }
+
+        headers = {
+            'Accept': '*/*',
+            'ai-api-key': self.api_key
+        }
+
+        # 使用with语句安全地打开文件
+        with open(audio_path, 'rb') as audio_file:
+            files = {
+                'audio': (audio_path.name, audio_file)
+            }
+
+            # 发送请求
+            response = requests.post(url, headers=headers, data=data, files=files)
+
+            # 检查响应状态
+            response.raise_for_status()
+
+            # 尝试从响应头中获取文件名
+            filename = None
+            content_disposition = response.headers.get('Content-Disposition')
+            if content_disposition:
+                filename_match = re.search(r'filename="?([^"]+)"?', content_disposition)
+                if filename_match:
+                    filename = filename_match.group(1)
+
+            # 如果没有从响应头获取到文件名，则生成一个唯一文件名
+            if not filename:
+                timestamp = int(time.time())
+                random_suffix = ''.join(random.choices('abcdefghijklmnopqrstuvwxyz0123456789', k=6))
+                filename = f"s2s_{timestamp}_{random_suffix}.mp3"
+
+            # 构建完整文件路径
+            file_path = output_path / filename
+
+            # 将响应内容保存到文件
+            with open(file_path, 'wb') as f:
+                f.write(response.content)
+
+            # 返回文件路径
+            return str(file_path)
+
+    def text_to_speech(self, text: str, voice_id, model_id: str, output_dir: str, speed: float = 1.0) -> str:
+        """
+        调用API将文本转换为语音并保存为文件
+
+        Args:
+            text: 要转换的文本
+            voice_id: 音色ID
+            model_id: 模型ID
+            output_dir: 输出目录
+            speed: 语速
+
+        Returns:
+            保存的音频文件路径
+        """
+        # 构建请求体
+        request_body = {
+            "text": text,
+            "language_code": "auto",
+            "voice_id": int(voice_id),
+            "model_id": model_id,
+            "voice_settings": {
+                "speed": float(speed)
+            }
+        }
+
+        # API端点
+        url = f"{self.api_domain}/v1/text-to-speech/create"
+
+        # 发送请求并获取响应
+        response = requests.post(
+            url=url,
+            json=request_body,
+            headers=self._get_headers(),
+            stream=True  # 使用流式传输处理大文件
+        )
+
+        # 检查响应状态
+        response.raise_for_status()
+
+        # 尝试从响应头中获取文件名
+        filename = None
+        content_disposition = response.headers.get('Content-Disposition')
+        if content_disposition:
+            filename_match = re.search(r'filename="?([^"]+)"?', content_disposition)
+            if filename_match:
+                filename = filename_match.group(1)
+
+        # 如果没有从响应头获取到文件名，则生成一个唯一文件名
+        if not filename:
+            timestamp = int(time.time())
+            random_suffix = ''.join(random.choices('abcdefghijklmnopqrstuvwxyz0123456789', k=6))
+            filename = f"tts_{timestamp}_{random_suffix}.mp3"
+
+        # 构建完整文件路径
+        output_dir = Path(output_dir)
+        output_dir.mkdir(parents=True, exist_ok=True)
+        file_path = output_dir / filename
+
+        # 将响应内容保存到文件
+        with open(file_path, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                if chunk:
+                    f.write(chunk)
+
+        # 返回文件路径
+        return str(file_path)

client/model.py

@@ -0,0 +1,97 @@
+from dataclasses import dataclass, field
+from typing import Dict, List
+
+
+@dataclass
+class Voice:
+    voice_id: str = ""
+    name: str = ""
+    description: str = ""
+    files: List[str] = field(default_factory=list)
+    is_legacy: bool = False
+    is_favor: bool = False
+    labels: Dict[str, str] = field(default_factory=dict)
+    voice_settings: Dict[str, int] = field(default_factory=dict)
+    icon_url: str = ""
+    status: int = 0
+    fail_code: int = 0
+    is_pvc: bool = False
+    is_disabled: bool = False
+    created_time_sec: int = 0
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'Voice':
+        return cls(
+            voice_id=data.get('voice_id', ''),
+            name=data.get('name', ''),
+            description=data.get('description', ''),
+            files=data.get('files', []),
+            is_legacy=data.get('is_legacy', False),
+            is_favor=data.get('is_favor', False),
+            labels=data.get('labels', {}),
+            voice_settings=data.get('voice_settings', {}),
+            icon_url=data.get('icon_url', ''),
+            status=data.get('status', 0),
+            fail_code=data.get('fail_code', 0),
+            is_pvc=data.get('is_pvc', False),
+            is_disabled=data.get('is_disabled', False),
+            created_time_sec=data.get('created_time_sec', 0)
+        )
+
+
+@dataclass
+class GetAllVoicesResponse:
+    voices: List[Voice] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'GetAllVoicesResponse':
+        return cls(
+            voices=[Voice.from_dict(voice_data) for voice_data in data.get('voices', [])]
+        )
+
+
+@dataclass
+class GetSupportedVoiceModelResponse:
+    models: List['VoiceModel']
+
+    @classmethod
+    def from_dict(cls, data):
+        return cls(
+            models=[VoiceModel.from_dict(model) for model in data.get('models', [])]
+        )
+
+
+# 模型结构
+@dataclass
+class VoiceModel:
+    model_id: str
+    name: str
+    can_do_text_to_speech: bool
+    can_do_voice_conversion: bool
+    description: str
+    languages: List['VoiceModelLanguage']
+
+    @classmethod
+    def from_dict(cls, data):
+        return cls(
+            model_id=data.get('model_id', ''),
+            name=data.get('name', ''),
+            can_do_text_to_speech=data.get('can_do_text_to_speech', False),
+            can_do_voice_conversion=data.get('can_do_voice_conversion', False),
+            description=data.get('description', ''),
+            languages=[VoiceModelLanguage.from_dict(lang) for lang in data.get('languages', [])]
+        )
+
+
+# 语言结构
+@dataclass
+class VoiceModelLanguage:
+    language_id: str
+    name: str
+
+    @classmethod
+    def from_dict(cls, data):
+        return cls(
+            language_id=data.get('language_id', ''),
+            name=data.get('name', '')
+        )