chore: release v4.0.8.1

* feat: reset password with recovery key

* perf: formatting and multi language

README.md

@@ -119,9 +119,9 @@ docker compose up -d
 | [Anthropic](https://www.anthropic.com/) | ✅ |  |
 | [xAI](https://x.ai/) | ✅ |  |
 | [智谱AI](https://open.bigmodel.cn/) | ✅ |  |
-| [优云智算](https://www.compshare.cn/) | ✅ | 大模型和 GPU 资源平台 |
+| [优云智算](https://www.compshare.cn/?ytag=GPU_YY-gh_langbot) | ✅ | 大模型和 GPU 资源平台 |
 | [PPIO](https://ppinfra.com/user/register?invited_by=QJKFYD&utm_source=github_langbot) | ✅ | 大模型和 GPU 资源平台 |
-| [302 AI](https://share.302.ai/SuTG99) | ✅ | 大模型聚合平台 |
+| [302.AI](https://share.302.ai/SuTG99) | ✅ | 大模型聚合平台 |
 | [Google Gemini](https://aistudio.google.com/prompts/new_chat) | ✅ | |
 | [Dify](https://dify.ai) | ✅ | LLMOps 平台 |
 | [Ollama](https://ollama.com/) | ✅ | 本地大模型运行平台 |

README_EN.md

@@ -116,10 +116,10 @@ Directly use the released version to run, see the [Manual Deployment](https://do
 | [Anthropic](https://www.anthropic.com/) | ✅ |  |
 | [xAI](https://x.ai/) | ✅ |  |
 | [Zhipu AI](https://open.bigmodel.cn/) | ✅ |  |
-| [CompShare](https://www.compshare.cn/) | ✅ | LLM and GPU resource platform |
+| [CompShare](https://www.compshare.cn/?ytag=GPU_YY-gh_langbot) | ✅ | LLM and GPU resource platform |
 | [Dify](https://dify.ai) | ✅ | LLMOps platform |
 | [PPIO](https://ppinfra.com/user/register?invited_by=QJKFYD&utm_source=github_langbot) | ✅ | LLM and GPU resource platform |
-| [302 AI](https://share.302.ai/SuTG99) | ✅ | LLM gateway(MaaS) |
+| [302.AI](https://share.302.ai/SuTG99) | ✅ | LLM gateway(MaaS) |
 | [Google Gemini](https://aistudio.google.com/prompts/new_chat) | ✅ | |
 | [Ollama](https://ollama.com/) | ✅ | Local LLM running platform |
 | [LMStudio](https://lmstudio.ai/) | ✅ | Local LLM running platform |

README_JP.md

@@ -115,9 +115,9 @@ LangBotはBTPanelにリストされています。BTPanelをインストール
 | [Anthropic](https://www.anthropic.com/) | ✅ |  |
 | [xAI](https://x.ai/) | ✅ |  |
 | [Zhipu AI](https://open.bigmodel.cn/) | ✅ |  |
-| [CompShare](https://www.compshare.cn/) | ✅ | 大模型とGPUリソースプラットフォーム |
+| [CompShare](https://www.compshare.cn/?ytag=GPU_YY-gh_langbot) | ✅ | 大模型とGPUリソースプラットフォーム |
 | [PPIO](https://ppinfra.com/user/register?invited_by=QJKFYD&utm_source=github_langbot) | ✅ | 大模型とGPUリソースプラットフォーム |
-| [302 AI](https://share.302.ai/SuTG99) | ✅ | LLMゲートウェイ(MaaS) |
+| [302.AI](https://share.302.ai/SuTG99) | ✅ | LLMゲートウェイ(MaaS) |
 | [Google Gemini](https://aistudio.google.com/prompts/new_chat) | ✅ | |
 | [Dify](https://dify.ai) | ✅ | LLMOpsプラットフォーム |
 | [Ollama](https://ollama.com/) | ✅ | ローカルLLM実行プラットフォーム |

pkg/api/http/controller/groups/user.py

@@ -1,5 +1,6 @@
 import quart
 import argon2
+import asyncio
 
 from .. import group
 
@@ -40,3 +41,29 @@ class UserRouterGroup(group.RouterGroup):
             token = await self.ap.user_service.generate_jwt_token(user_email)
 
             return self.success(data={'token': token})
+
+        @self.route('/reset-password', methods=['POST'], auth_type=group.AuthType.NONE)
+        async def _() -> str:
+            json_data = await quart.request.json
+
+            user_email = json_data['user']
+            recovery_key = json_data['recovery_key']
+            new_password = json_data['new_password']
+
+            # hard sleep 3s for security
+            await asyncio.sleep(3)
+
+            if not await self.ap.user_service.is_initialized():
+                return self.http_status(400, -1, 'system not initialized')
+
+            user_obj = await self.ap.user_service.get_user_by_email(user_email)
+
+            if user_obj is None:
+                return self.http_status(400, -1, 'user not found')
+
+            if recovery_key != self.ap.instance_config.data['system']['recovery_key']:
+                return self.http_status(403, -1, 'invalid recovery key')
+
+            await self.ap.user_service.reset_password(user_email, new_password)
+
+            return self.success(data={'user': user_email})

pkg/api/http/service/user.py

@@ -73,3 +73,12 @@ class UserService:
         jwt_secret = self.ap.instance_config.data['system']['jwt']['secret']
 
         return jwt.decode(token, jwt_secret, algorithms=['HS256'])['user']
+
+    async def reset_password(self, user_email: str, new_password: str) -> None:
+        ph = argon2.PasswordHasher()
+
+        hashed_password = ph.hash(new_password)
+
+        await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.update(user.User).where(user.User.user == user_email).values(password=hashed_password)
+        )

pkg/core/stages/genkeys.py

@@ -15,3 +15,10 @@ class GenKeysStage(stage.BootingStage):
         if not ap.instance_config.data['system']['jwt']['secret']:
             ap.instance_config.data['system']['jwt']['secret'] = secrets.token_hex(16)
             await ap.instance_config.dump_config()
+
+        if 'recovery_key' not in ap.instance_config.data['system']:
+            ap.instance_config.data['system']['recovery_key'] = ''
+
+        if not ap.instance_config.data['system']['recovery_key']:
+            ap.instance_config.data['system']['recovery_key'] = secrets.token_hex(3).upper()
+            await ap.instance_config.dump_config()

pkg/platform/sources/dingtalk.py

@@ -116,6 +116,15 @@ class DingTalkAdapter(adapter.MessagePlatformAdapter):
 
         self.bot_account_id = self.config['robot_name']
 
+        self.bot = DingTalkClient(
+            client_id=config['client_id'],
+            client_secret=config['client_secret'],
+            robot_name=config['robot_name'],
+            robot_code=config['robot_code'],
+            markdown_card=config['markdown_card'],
+            logger=self.logger,
+        )
+
     async def reply_message(
         self,
         message_source: platform_events.MessageEvent,
@@ -157,15 +166,6 @@ class DingTalkAdapter(adapter.MessagePlatformAdapter):
             self.bot.on_message('GroupMessage')(on_message)
 
     async def run_async(self):
-        config = self.config
-        self.bot = DingTalkClient(
-            client_id=config['client_id'],
-            client_secret=config['client_secret'],
-            robot_name=config['robot_name'],
-            robot_code=config['robot_code'],
-            markdown_card=config['markdown_card'],
-            logger=self.logger,
-        )
         await self.bot.start()
 
     async def kill(self) -> bool:

pkg/platform/sources/discord.py

@@ -9,15 +9,591 @@ import uuid
 import os
 import datetime
 import io
+import asyncio
+from enum import Enum
 
 import aiohttp
 
 from .. import adapter
 from ...core import app
+from ..logger import EventLogger
 from ..types import message as platform_message
 from ..types import events as platform_events
 from ..types import entities as platform_entities
-from ..logger import EventLogger
+
+# 语音功能相关异常定义
+class VoiceConnectionError(Exception):
+    """语音连接基础异常"""
+    def __init__(self, message: str, error_code: str = None, guild_id: int = None):
+        super().__init__(message)
+        self.error_code = error_code
+        self.guild_id = guild_id
+        self.timestamp = datetime.datetime.now()
+
+
+class VoicePermissionError(VoiceConnectionError):
+    """语音权限异常"""
+    def __init__(self, message: str, missing_permissions: list = None, user_id: int = None, channel_id: int = None):
+        super().__init__(message, "PERMISSION_ERROR")
+        self.missing_permissions = missing_permissions or []
+        self.user_id = user_id
+        self.channel_id = channel_id
+
+
+class VoiceNetworkError(VoiceConnectionError):
+    """语音网络异常"""
+    def __init__(self, message: str, retry_count: int = 0):
+        super().__init__(message, "NETWORK_ERROR")
+        self.retry_count = retry_count
+        self.last_attempt = datetime.datetime.now()
+
+
+class VoiceConnectionStatus(Enum):
+    """语音连接状态枚举"""
+    IDLE = "idle"
+    CONNECTING = "connecting"
+    CONNECTED = "connected"
+    PLAYING = "playing"
+    RECONNECTING = "reconnecting"
+    FAILED = "failed"
+
+
+class VoiceConnectionInfo:
+    """
+    语音连接信息类
+    
+    用于存储和管理单个语音连接的详细信息，包括连接状态、时间戳、
+    频道信息等。提供连接信息的标准化数据结构。
+    
+    @author: @ydzat
+    @version: 1.0
+    @since: 2025-07-04
+    """
+    
+    def __init__(self, guild_id: int, channel_id: int, channel_name: str = None):
+        """
+        初始化语音连接信息
+        
+        @author: @ydzat
+        
+        Args:
+            guild_id (int): 服务器ID
+            channel_id (int): 语音频道ID
+            channel_name (str, optional): 语音频道名称
+        """
+        self.guild_id = guild_id
+        self.channel_id = channel_id
+        self.channel_name = channel_name or f"Channel-{channel_id}"
+        self.connected = False
+        self.connection_time: datetime.datetime = None
+        self.last_activity = datetime.datetime.now()
+        self.status = VoiceConnectionStatus.IDLE
+        self.user_count = 0
+        self.latency = 0.0
+        self.connection_health = "unknown"
+        self.voice_client = None
+        
+    def update_status(self, status: VoiceConnectionStatus):
+        """
+        更新连接状态
+        
+        @author: @ydzat
+        
+        Args:
+            status (VoiceConnectionStatus): 新的连接状态
+        """
+        self.status = status
+        self.last_activity = datetime.datetime.now()
+        
+        if status == VoiceConnectionStatus.CONNECTED:
+            self.connected = True
+            if self.connection_time is None:
+                self.connection_time = datetime.datetime.now()
+        elif status in [VoiceConnectionStatus.IDLE, VoiceConnectionStatus.FAILED]:
+            self.connected = False
+            self.connection_time = None
+            self.voice_client = None
+    
+    def to_dict(self) -> dict:
+        """
+        转换为字典格式
+        
+        @author: @ydzat
+        
+        Returns:
+            dict: 连接信息的字典表示
+        """
+        return {
+            "guild_id": self.guild_id,
+            "channel_id": self.channel_id,
+            "channel_name": self.channel_name,
+            "connected": self.connected,
+            "connection_time": self.connection_time.isoformat() if self.connection_time else None,
+            "last_activity": self.last_activity.isoformat(),
+            "status": self.status.value,
+            "user_count": self.user_count,
+            "latency": self.latency,
+            "connection_health": self.connection_health
+        }
+
+
+class VoiceConnectionManager:
+    """
+    语音连接管理器
+    
+    负责管理多个服务器的语音连接，提供连接建立、断开、状态查询等功能。
+    采用单例模式确保全局只有一个连接管理器实例。
+    
+    @author: @ydzat
+    @version: 1.0
+    @since: 2025-07-04
+    """
+    
+    def __init__(self, bot: discord.Client, logger: EventLogger):
+        """
+        初始化语音连接管理器
+        
+        @author: @ydzat
+        
+        Args:
+            bot (discord.Client): Discord 客户端实例
+            logger (EventLogger): 事件日志记录器
+        """
+        self.bot = bot
+        self.logger = logger
+        self.connections: typing.Dict[int, VoiceConnectionInfo] = {}
+        self._connection_lock = asyncio.Lock()
+        self._cleanup_task = None
+        self._monitoring_enabled = True
+        
+    async def join_voice_channel(self, guild_id: int, channel_id: int, 
+                                user_id: int = None) -> discord.VoiceClient:
+        """
+        加入语音频道
+        
+        验证用户权限和频道状态后，建立到指定语音频道的连接。
+        支持连接复用和自动重连机制。
+        
+        @author: @ydzat
+        
+        Args:
+            guild_id (int): 服务器ID
+            channel_id (int): 语音频道ID
+            user_id (int, optional): 请求用户ID，用于权限验证
+            
+        Returns:
+            discord.VoiceClient: 语音客户端实例
+            
+        Raises:
+            VoicePermissionError: 权限不足时抛出
+            VoiceNetworkError: 网络连接失败时抛出
+            VoiceConnectionError: 其他连接错误时抛出
+        """
+        async with self._connection_lock:
+            try:
+                # 获取服务器和频道对象
+                guild = self.bot.get_guild(guild_id)
+                if not guild:
+                    raise VoiceConnectionError(
+                        f"无法找到服务器 {guild_id}",
+                        "GUILD_NOT_FOUND",
+                        guild_id
+                    )
+                
+                channel = guild.get_channel(channel_id)
+                if not channel or not isinstance(channel, discord.VoiceChannel):
+                    raise VoiceConnectionError(
+                        f"无法找到语音频道 {channel_id}",
+                        "CHANNEL_NOT_FOUND",
+                        guild_id
+                    )
+                
+                # 验证用户是否在语音频道中（如果提供了用户ID）
+                if user_id:
+                    await self._validate_user_in_channel(guild, channel, user_id)
+                
+                # 验证机器人权限
+                await self._validate_bot_permissions(channel)
+                
+                # 检查是否已有连接
+                if guild_id in self.connections:
+                    existing_conn = self.connections[guild_id]
+                    if existing_conn.connected and existing_conn.voice_client:
+                        if existing_conn.channel_id == channel_id:
+                            # 已连接到相同频道，返回现有连接
+                            await self.logger.info(f"复用现有语音连接: {guild.name} -> {channel.name}")
+                            return existing_conn.voice_client
+                        else:
+                            # 连接到不同频道，先断开旧连接
+                            await self._disconnect_internal(guild_id)
+                
+                # 建立新连接
+                voice_client = await channel.connect()
+                
+                # 更新连接信息
+                conn_info = VoiceConnectionInfo(guild_id, channel_id, channel.name)
+                conn_info.voice_client = voice_client
+                conn_info.update_status(VoiceConnectionStatus.CONNECTED)
+                conn_info.user_count = len(channel.members)
+                self.connections[guild_id] = conn_info
+                
+                await self.logger.info(f"成功连接到语音频道: {guild.name} -> {channel.name}")
+                return voice_client
+                
+            except discord.ClientException as e:
+                raise VoiceNetworkError(f"Discord 客户端错误: {str(e)}")
+            except discord.opus.OpusNotLoaded as e:
+                raise VoiceConnectionError(f"Opus 编码器未加载: {str(e)}", "OPUS_NOT_LOADED", guild_id)
+            except Exception as e:
+                await self.logger.error(f"连接语音频道时发生未知错误: {str(e)}")
+                raise VoiceConnectionError(f"连接失败: {str(e)}", "UNKNOWN_ERROR", guild_id)
+    
+    async def leave_voice_channel(self, guild_id: int) -> bool:
+        """
+        离开语音频道
+        
+        断开指定服务器的语音连接，清理相关资源和状态信息。
+        确保音频播放停止后再断开连接。
+        
+        @author: @ydzat
+        
+        Args:
+            guild_id (int): 服务器ID
+            
+        Returns:
+            bool: 断开是否成功
+        """
+        async with self._connection_lock:
+            return await self._disconnect_internal(guild_id)
+    
+    async def _disconnect_internal(self, guild_id: int) -> bool:
+        """
+        内部断开连接方法
+        
+        @author: @ydzat
+        
+        Args:
+            guild_id (int): 服务器ID
+            
+        Returns:
+            bool: 断开是否成功
+        """
+        if guild_id not in self.connections:
+            return True
+        
+        conn_info = self.connections[guild_id]
+        
+        try:
+            if conn_info.voice_client and conn_info.voice_client.is_connected():
+                # 停止当前播放
+                if conn_info.voice_client.is_playing():
+                    conn_info.voice_client.stop()
+                
+                # 等待播放完全停止
+                await asyncio.sleep(0.1)
+                
+                # 断开连接
+                await conn_info.voice_client.disconnect()
+                
+            conn_info.update_status(VoiceConnectionStatus.IDLE)
+            del self.connections[guild_id]
+            
+            await self.logger.info(f"已断开语音连接: Guild {guild_id}")
+            return True
+            
+        except Exception as e:
+            await self.logger.error(f"断开语音连接时发生错误: {str(e)}")
+            # 即使出错也要清理连接记录
+            conn_info.update_status(VoiceConnectionStatus.FAILED)
+            if guild_id in self.connections:
+                del self.connections[guild_id]
+            return False
+    
+    async def get_voice_client(self, guild_id: int) -> typing.Optional[discord.VoiceClient]:
+        """
+        获取语音客户端
+        
+        返回指定服务器的语音客户端实例，如果未连接则返回 None。
+        会验证连接的有效性，自动清理无效连接。
+        
+        @author: @ydzat
+        
+        Args:
+            guild_id (int): 服务器ID
+            
+        Returns:
+            Optional[discord.VoiceClient]: 语音客户端实例或 None
+        """
+        if guild_id not in self.connections:
+            return None
+        
+        conn_info = self.connections[guild_id]
+        
+        # 验证连接是否仍然有效
+        if conn_info.voice_client and not conn_info.voice_client.is_connected():
+            # 连接已失效，清理状态
+            await self._disconnect_internal(guild_id)
+            return None
+        
+        return conn_info.voice_client if conn_info.connected else None
+    
+    async def is_connected_to_voice(self, guild_id: int) -> bool:
+        """
+        检查是否连接到语音频道
+        
+        @author: @ydzat
+        
+        Args:
+            guild_id (int): 服务器ID
+            
+        Returns:
+            bool: 是否已连接
+        """
+        if guild_id not in self.connections:
+            return False
+        
+        conn_info = self.connections[guild_id]
+        
+        # 检查实际连接状态
+        if conn_info.voice_client and not conn_info.voice_client.is_connected():
+            # 连接已失效，清理状态
+            await self._disconnect_internal(guild_id)
+            return False
+        
+        return conn_info.connected
+    
+    async def get_connection_status(self, guild_id: int) -> typing.Optional[dict]:
+        """
+        获取连接状态信息
+        
+        @author: @ydzat
+        
+        Args:
+            guild_id (int): 服务器ID
+            
+        Returns:
+            Optional[dict]: 连接状态信息字典或 None
+        """
+        if guild_id not in self.connections:
+            return None
+        
+        conn_info = self.connections[guild_id]
+        
+        # 更新实时信息
+        if conn_info.voice_client and conn_info.voice_client.is_connected():
+            conn_info.latency = conn_info.voice_client.latency * 1000  # 转换为毫秒
+            conn_info.connection_health = "good" if conn_info.latency < 100 else "poor"
+            
+            # 更新频道用户数
+            guild = self.bot.get_guild(guild_id)
+            if guild:
+                channel = guild.get_channel(conn_info.channel_id)
+                if channel and isinstance(channel, discord.VoiceChannel):
+                    conn_info.user_count = len(channel.members)
+        
+        return conn_info.to_dict()
+    
+    async def list_active_connections(self) -> typing.List[dict]:
+        """
+        列出所有活跃连接
+        
+        @author: @ydzat
+        
+        Returns:
+            List[dict]: 活跃连接列表
+        """
+        active_connections = []
+        
+        for guild_id, conn_info in self.connections.items():
+            if conn_info.connected:
+                status = await self.get_connection_status(guild_id)
+                if status:
+                    active_connections.append(status)
+        
+        return active_connections
+    
+    async def get_voice_channel_info(self, guild_id: int, channel_id: int) -> typing.Optional[dict]:
+        """
+        获取语音频道信息
+        
+        @author: @ydzat
+        
+        Args:
+            guild_id (int): 服务器ID
+            channel_id (int): 频道ID
+            
+        Returns:
+            Optional[dict]: 频道信息字典或 None
+        """
+        guild = self.bot.get_guild(guild_id)
+        if not guild:
+            return None
+        
+        channel = guild.get_channel(channel_id)
+        if not channel or not isinstance(channel, discord.VoiceChannel):
+            return None
+        
+        # 获取用户信息
+        users = []
+        for member in channel.members:
+            users.append({
+                "id": member.id,
+                "name": member.display_name,
+                "status": str(member.status),
+                "is_bot": member.bot
+            })
+        
+        # 获取权限信息
+        bot_member = guild.me
+        permissions = channel.permissions_for(bot_member)
+        
+        return {
+            "channel_id": channel_id,
+            "channel_name": channel.name,
+            "guild_id": guild_id,
+            "guild_name": guild.name,
+            "user_limit": channel.user_limit,
+            "current_users": users,
+            "user_count": len(users),
+            "bitrate": channel.bitrate,
+            "permissions": {
+                "connect": permissions.connect,
+                "speak": permissions.speak,
+                "use_voice_activation": permissions.use_voice_activation,
+                "priority_speaker": permissions.priority_speaker
+            }
+        }
+    
+    async def _validate_user_in_channel(self, guild: discord.Guild, 
+                                       channel: discord.VoiceChannel, user_id: int):
+        """
+        验证用户是否在语音频道中
+        
+        @author: @ydzat
+        
+        Args:
+            guild: Discord 服务器对象
+            channel: 语音频道对象
+            user_id: 用户ID
+            
+        Raises:
+            VoicePermissionError: 用户不在频道中时抛出
+        """
+        member = guild.get_member(user_id)
+        if not member:
+            raise VoicePermissionError(
+                f"无法找到用户 {user_id}",
+                ["member_not_found"],
+                user_id,
+                channel.id
+            )
+        
+        if not member.voice or member.voice.channel != channel:
+            raise VoicePermissionError(
+                f"用户 {member.display_name} 不在语音频道 {channel.name} 中",
+                ["user_not_in_channel"],
+                user_id,
+                channel.id
+            )
+    
+    async def _validate_bot_permissions(self, channel: discord.VoiceChannel):
+        """
+        验证机器人权限
+        
+        @author: @ydzat
+        
+        Args:
+            channel: 语音频道对象
+            
+        Raises:
+            VoicePermissionError: 权限不足时抛出
+        """
+        bot_member = channel.guild.me
+        permissions = channel.permissions_for(bot_member)
+        
+        missing_permissions = []
+        
+        if not permissions.connect:
+            missing_permissions.append("connect")
+        if not permissions.speak:
+            missing_permissions.append("speak")
+        
+        if missing_permissions:
+            raise VoicePermissionError(
+                f"机器人在频道 {channel.name} 中缺少权限: {', '.join(missing_permissions)}",
+                missing_permissions,
+                channel_id=channel.id
+            )
+    
+    async def cleanup_inactive_connections(self):
+        """
+        清理无效连接
+        
+        定期检查并清理已断开或无效的语音连接，释放资源。
+        
+        @author: @ydzat
+        """
+        cleanup_guilds = []
+        
+        for guild_id, conn_info in self.connections.items():
+            if not conn_info.voice_client or not conn_info.voice_client.is_connected():
+                cleanup_guilds.append(guild_id)
+        
+        for guild_id in cleanup_guilds:
+            await self._disconnect_internal(guild_id)
+        
+        if cleanup_guilds:
+            await self.logger.info(f"清理了 {len(cleanup_guilds)} 个无效的语音连接")
+    
+    async def start_monitoring(self):
+        """
+        开始连接监控
+        
+        @author: @ydzat
+        """
+        if self._cleanup_task is None and self._monitoring_enabled:
+            self._cleanup_task = asyncio.create_task(self._monitoring_loop())
+    
+    async def stop_monitoring(self):
+        """
+        停止连接监控
+        
+        @author: @ydzat
+        """
+        self._monitoring_enabled = False
+        if self._cleanup_task:
+            self._cleanup_task.cancel()
+            try:
+                await self._cleanup_task
+            except asyncio.CancelledError:
+                pass
+            self._cleanup_task = None
+    
+    async def _monitoring_loop(self):
+        """
+        监控循环
+        
+        @author: @ydzat
+        """
+        try:
+            while self._monitoring_enabled:
+                await asyncio.sleep(60)  # 每分钟检查一次
+                await self.cleanup_inactive_connections()
+        except asyncio.CancelledError:
+            pass
+    
+    async def disconnect_all(self):
+        """
+        断开所有连接
+        
+        @author: @ydzat
+        """
+        async with self._connection_lock:
+            guild_ids = list(self.connections.keys())
+            for guild_id in guild_ids:
+                await self._disconnect_internal(guild_id)
+        
+        await self.stop_monitoring()
 
 
 class DiscordMessageConverter(adapter.MessageConverter):
@@ -238,6 +814,9 @@ class DiscordAdapter(adapter.MessagePlatformAdapter):
         self.logger = logger
 
         self.bot_account_id = self.config['client_id']
+        
+        # 初始化语音连接管理器
+        self.voice_manager: VoiceConnectionManager = None
 
         adapter_self = self
 
@@ -258,6 +837,169 @@ class DiscordAdapter(adapter.MessagePlatformAdapter):
             args['proxy'] = os.getenv('http_proxy')
 
         self.bot = MyClient(intents=intents, **args)
+    
+    # Voice functionality methods
+    async def join_voice_channel(self, guild_id: int, channel_id: int, 
+                                user_id: int = None) -> discord.VoiceClient:
+        """
+        加入语音频道
+        
+        为指定服务器的语音频道建立连接，支持用户权限验证和连接复用。
+        
+        @author: @ydzat
+        @version: 1.0
+        @since: 2025-07-04
+        
+        Args:
+            guild_id (int): Discord 服务器ID
+            channel_id (int): 语音频道ID
+            user_id (int, optional): 请求用户ID，用于权限验证
+            
+        Returns:
+            discord.VoiceClient: 语音客户端实例
+            
+        Raises:
+            VoicePermissionError: 权限不足
+            VoiceNetworkError: 网络连接失败
+            VoiceConnectionError: 其他连接错误
+        """
+        if not self.voice_manager:
+            raise VoiceConnectionError("语音管理器未初始化", "MANAGER_NOT_READY")
+        
+        return await self.voice_manager.join_voice_channel(guild_id, channel_id, user_id)
+    
+    async def leave_voice_channel(self, guild_id: int) -> bool:
+        """
+        离开语音频道
+        
+        断开指定服务器的语音连接，清理相关资源。
+        
+        @author: @ydzat
+        @version: 1.0
+        @since: 2025-07-04
+        
+        Args:
+            guild_id (int): Discord 服务器ID
+            
+        Returns:
+            bool: 是否成功断开连接
+        """
+        if not self.voice_manager:
+            return False
+        
+        return await self.voice_manager.leave_voice_channel(guild_id)
+    
+    async def get_voice_client(self, guild_id: int) -> typing.Optional[discord.VoiceClient]:
+        """
+        获取语音客户端
+        
+        返回指定服务器的语音客户端实例，用于音频播放控制。
+        
+        @author: @ydzat
+        @version: 1.0
+        @since: 2025-07-04
+        
+        Args:
+            guild_id (int): Discord 服务器ID
+            
+        Returns:
+            Optional[discord.VoiceClient]: 语音客户端实例或 None
+        """
+        if not self.voice_manager:
+            return None
+        
+        return await self.voice_manager.get_voice_client(guild_id)
+    
+    async def is_connected_to_voice(self, guild_id: int) -> bool:
+        """
+        检查语音连接状态
+        
+        @author: @ydzat
+        @version: 1.0
+        @since: 2025-07-04
+        
+        Args:
+            guild_id (int): Discord 服务器ID
+            
+        Returns:
+            bool: 是否已连接到语音频道
+        """
+        if not self.voice_manager:
+            return False
+        
+        return await self.voice_manager.is_connected_to_voice(guild_id)
+    
+    async def get_voice_connection_status(self, guild_id: int) -> typing.Optional[dict]:
+        """
+        获取语音连接详细状态
+        
+        返回包含连接时间、延迟、用户数等详细信息的状态字典。
+        
+        @author: @ydzat
+        @version: 1.0
+        @since: 2025-07-04
+        
+        Args:
+            guild_id (int): Discord 服务器ID
+            
+        Returns:
+            Optional[dict]: 连接状态信息或 None
+        """
+        if not self.voice_manager:
+            return None
+        
+        return await self.voice_manager.get_connection_status(guild_id)
+    
+    async def list_active_voice_connections(self) -> typing.List[dict]:
+        """
+        列出所有活跃的语音连接
+        
+        @author: @ydzat
+        @version: 1.0
+        @since: 2025-07-04
+        
+        Returns:
+            List[dict]: 活跃语音连接列表
+        """
+        if not self.voice_manager:
+            return []
+        
+        return await self.voice_manager.list_active_connections()
+    
+    async def get_voice_channel_info(self, guild_id: int, channel_id: int) -> typing.Optional[dict]:
+        """
+        获取语音频道详细信息
+        
+        包括频道名称、用户列表、权限信息等。
+        
+        @author: @ydzat
+        @version: 1.0
+        @since: 2025-07-04
+        
+        Args:
+            guild_id (int): Discord 服务器ID
+            channel_id (int): 语音频道ID
+            
+        Returns:
+            Optional[dict]: 频道信息字典或 None
+        """
+        if not self.voice_manager:
+            return None
+        
+        return await self.voice_manager.get_voice_channel_info(guild_id, channel_id)
+    
+    async def cleanup_voice_connections(self):
+        """
+        清理无效的语音连接
+        
+        手动触发语音连接清理，移除已断开或无效的连接。
+        
+        @author: @ydzat
+        @version: 1.0
+        @since: 2025-07-04
+        """
+        if self.voice_manager:
+            await self.voice_manager.cleanup_inactive_connections()
 
     async def send_message(self, target_type: str, target_id: str, message: platform_message.MessageChain):
         msg_to_send, image_files = await self.message_converter.yiri2target(message)
@@ -324,9 +1066,32 @@ class DiscordAdapter(adapter.MessagePlatformAdapter):
         self.listeners.pop(event_type)
 
     async def run_async(self):
+        """
+        启动 Discord 适配器
+        
+        初始化语音管理器并启动 Discord 客户端连接。
+        
+        @author: @ydzat (修改)
+        """
         async with self.bot:
+            # 初始化语音管理器
+            self.voice_manager = VoiceConnectionManager(self.bot, self.logger)
+            await self.voice_manager.start_monitoring()
+            
+            await self.logger.info("Discord 适配器语音功能已启用")
             await self.bot.start(self.config['token'], reconnect=True)
 
     async def kill(self) -> bool:
+        """
+        关闭 Discord 适配器
+        
+        清理语音连接并关闭 Discord 客户端。
+        
+        @author: @ydzat (修改)
+        """
+        if self.voice_manager:
+            await self.voice_manager.disconnect_all()
+        
         await self.bot.close()
         return True
+

pkg/provider/modelmgr/requesters/302aichatcmpl.yaml

@@ -3,8 +3,8 @@ kind: LLMAPIRequester
 metadata:
   name: 302-ai-chat-completions
   label:
-    en_US: 302 AI
-    zh_Hans: 302 AI
+    en_US: 302.AI
+    zh_Hans: 302.AI
   icon: 302ai.png
 spec:
   config:

pkg/utils/constants.py

@@ -1,4 +1,4 @@
-semantic_version = 'v4.0.8'
+semantic_version = 'v4.0.8.1'
 
 required_database_version = 3
 """标记本版本所需要的数据库结构版本，用于判断数据库迁移"""

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "langbot"
-version = "4.0.7"
+version = "4.0.8.1"
 description = "高稳定、支持扩展、多模态 - 大模型原生即时通信机器人平台"
 readme = "README.md"
 requires-python = ">=3.10.1"
@@ -19,6 +19,7 @@ dependencies = [
     "dashscope>=1.23.2",
     "dingtalk-stream>=0.24.0",
     "discord-py>=2.5.2",
+    "pynacl>=1.5.0",  # Required for Discord voice support
     "gewechat-client>=0.1.5",
     "lark-oapi>=1.4.15",
     "mcp>=1.8.1",
@@ -84,6 +85,8 @@ Repository = "https://github.com/RockChinQ/langbot"
 [dependency-groups]
 dev = [
     "pre-commit>=4.2.0",
+    "pytest>=8.4.1",
+    "pytest-asyncio>=1.0.0",
     "ruff>=0.11.9",
 ]
 

templates/config.yaml

@@ -15,6 +15,7 @@ proxy:
     http: ''
     https: ''
 system:
+    recovery_key: ''
     jwt:
         expire: 604800
         secret: ''

web/package.json

@@ -40,6 +40,7 @@
     "clsx": "^2.1.1",
     "i18next": "^25.1.2",
     "i18next-browser-languagedetector": "^8.1.0",
+    "input-otp": "^1.4.2",
     "lodash": "^4.17.21",
     "lucide-react": "^0.507.0",
     "next": "15.2.4",

web/src/app/infra/http/HttpClient.ts

@@ -492,6 +492,18 @@ class HttpClient {
   public checkUserToken(): Promise<ApiRespUserToken> {
     return this.get('/api/v1/user/check-token');
   }
+
+  public resetPassword(
+    user: string,
+    recoveryKey: string,
+    newPassword: string,
+  ): Promise<{ user: string }> {
+    return this.post('/api/v1/user/reset-password', {
+      user,
+      recovery_key: recoveryKey,
+      new_password: newPassword,
+    });
+  }
 }
 
 const getBaseURL = (): string => {

web/src/app/login/page.tsx

@@ -34,6 +34,7 @@ import langbotIcon from '@/app/assets/langbot-logo.webp';
 import { toast } from 'sonner';
 import { useTranslation } from 'react-i18next';
 import i18n from '@/i18n';
+import Link from 'next/link';
 
 const formSchema = (t: (key: string) => string) =>
   z.object({
@@ -209,7 +210,16 @@ export default function Login() {
                 name="password"
                 render={({ field }) => (
                   <FormItem>
-                    <FormLabel>{t('common.password')}</FormLabel>
+                    <div className="flex justify-between">
+                      <FormLabel>{t('common.password')}</FormLabel>
+                      <Link
+                        href="/reset-password"
+                        className="text-sm text-blue-500"
+                      >
+                        {t('common.forgotPassword')}
+                      </Link>
+                    </div>
+
                     <FormControl>
                       <div className="relative">
                         <Lock className="absolute left-3 top-3 h-4 w-4 text-gray-400" />

web/src/app/reset-password/layout.tsx

@@ -0,0 +1,15 @@
+'use client';
+
+import React from 'react';
+
+export default function ResetPasswordLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <div className="min-h-screen bg-background">
+      <main className="min-h-screen">{children}</main>
+    </div>
+  );
+}

web/src/app/reset-password/page.tsx

@@ -0,0 +1,205 @@
+'use client';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import {
+  Card,
+  CardContent,
+  CardHeader,
+  CardTitle,
+  CardDescription,
+} from '@/components/ui/card';
+import {
+  InputOTP,
+  InputOTPGroup,
+  InputOTPSlot,
+  InputOTPSeparator,
+} from '@/components/ui/input-otp';
+import { useForm } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+import * as z from 'zod';
+import {
+  Form,
+  FormControl,
+  FormField,
+  FormItem,
+  FormLabel,
+  FormMessage,
+  FormDescription,
+} from '@/components/ui/form';
+import { useState } from 'react';
+import { httpClient } from '@/app/infra/http/HttpClient';
+import { useRouter } from 'next/navigation';
+import { Mail, Lock, ArrowLeft } from 'lucide-react';
+import { toast } from 'sonner';
+import { useTranslation } from 'react-i18next';
+import Link from 'next/link';
+
+const REGEXP_ONLY_DIGITS_AND_CHARS = /^[0-9a-zA-Z]+$/;
+
+const formSchema = (t: (key: string) => string) =>
+  z.object({
+    email: z.string().email(t('common.invalidEmail')),
+    recoveryKey: z.string().min(1, t('resetPassword.recoveryKeyRequired')),
+    newPassword: z.string().min(1, t('resetPassword.newPasswordRequired')),
+  });
+
+export default function ResetPassword() {
+  const router = useRouter();
+  const { t } = useTranslation();
+  const [isResetting, setIsResetting] = useState(false);
+
+  const form = useForm<z.infer<ReturnType<typeof formSchema>>>({
+    resolver: zodResolver(formSchema(t)),
+    defaultValues: {
+      email: '',
+      recoveryKey: '',
+      newPassword: '',
+    },
+  });
+
+  function onSubmit(values: z.infer<ReturnType<typeof formSchema>>) {
+    handleResetPassword(values.email, values.recoveryKey, values.newPassword);
+  }
+
+  function handleResetPassword(
+    email: string,
+    recoveryKey: string,
+    newPassword: string,
+  ) {
+    setIsResetting(true);
+    httpClient
+      .resetPassword(email, recoveryKey, newPassword)
+      .then((res) => {
+        console.log('reset password success: ', res);
+        toast.success(t('resetPassword.resetSuccess'));
+        router.push('/login');
+      })
+      .catch((err) => {
+        console.log('reset password error: ', err);
+        toast.error(t('resetPassword.resetFailed'));
+      })
+      .finally(() => {
+        setIsResetting(false);
+      });
+  }
+
+  return (
+    <div className="min-h-screen flex items-center justify-center bg-gray-50">
+      <Card className="w-[375px]">
+        <CardHeader>
+          <div className="flex justify-between items-center mb-6">
+            <Link
+              href="/login"
+              className="flex items-center text-sm text-gray-600 hover:text-gray-900 transition-colors"
+            >
+              <ArrowLeft className="h-4 w-4 mr-1" />
+              {t('resetPassword.backToLogin')}
+            </Link>
+          </div>
+          <CardTitle className="text-2xl text-center">
+            {t('resetPassword.title')}
+          </CardTitle>
+          <CardDescription className="text-center">
+            {t('resetPassword.description')}
+          </CardDescription>
+        </CardHeader>
+        <CardContent>
+          <Form {...form}>
+            <form onSubmit={form.handleSubmit(onSubmit)} className="space-y-6">
+              <FormField
+                control={form.control}
+                name="email"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>{t('common.email')}</FormLabel>
+                    <FormControl>
+                      <div className="relative">
+                        <Mail className="absolute left-3 top-3 h-4 w-4 text-gray-400" />
+                        <Input
+                          placeholder={t('common.enterEmail')}
+                          className="pl-10"
+                          {...field}
+                        />
+                      </div>
+                    </FormControl>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+
+              <FormField
+                control={form.control}
+                name="recoveryKey"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>{t('resetPassword.recoveryKey')}</FormLabel>
+                    <FormDescription>
+                      {t('resetPassword.recoveryKeyDescription')}
+                    </FormDescription>
+                    <FormControl>
+                      <InputOTP
+                        maxLength={6}
+                        value={field.value}
+                        pattern={REGEXP_ONLY_DIGITS_AND_CHARS.source}
+                        onChange={(value) => {
+                          // 将输入的值转换为大写
+                          const upperValue = value.toUpperCase();
+                          field.onChange(upperValue);
+                        }}
+                      >
+                        <InputOTPGroup>
+                          <InputOTPSlot index={0} />
+                          <InputOTPSlot index={1} />
+                          <InputOTPSlot index={2} />
+                        </InputOTPGroup>
+                        <InputOTPSeparator />
+                        <InputOTPGroup>
+                          <InputOTPSlot index={3} />
+                          <InputOTPSlot index={4} />
+                          <InputOTPSlot index={5} />
+                        </InputOTPGroup>
+                      </InputOTP>
+                    </FormControl>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+
+              <FormField
+                control={form.control}
+                name="newPassword"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>{t('resetPassword.newPassword')}</FormLabel>
+                    <FormControl>
+                      <div className="relative">
+                        <Lock className="absolute left-3 top-3 h-4 w-4 text-gray-400" />
+                        <Input
+                          type="password"
+                          placeholder={t('resetPassword.enterNewPassword')}
+                          className="pl-10"
+                          {...field}
+                        />
+                      </div>
+                    </FormControl>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+
+              <Button
+                type="submit"
+                className="w-full mt-4 cursor-pointer"
+                disabled={isResetting}
+              >
+                {isResetting
+                  ? t('resetPassword.resetting')
+                  : t('resetPassword.resetPassword')}
+              </Button>
+            </form>
+          </Form>
+        </CardContent>
+      </Card>
+    </div>
+  );
+}

web/src/components/ui/input-otp.tsx

@@ -0,0 +1,77 @@
+'use client';
+
+import * as React from 'react';
+import { OTPInput, OTPInputContext } from 'input-otp';
+import { MinusIcon } from 'lucide-react';
+
+import { cn } from '@/lib/utils';
+
+function InputOTP({
+  className,
+  containerClassName,
+  ...props
+}: React.ComponentProps<typeof OTPInput> & {
+  containerClassName?: string;
+}) {
+  return (
+    <OTPInput
+      data-slot="input-otp"
+      containerClassName={cn(
+        'flex items-center gap-2 has-disabled:opacity-50',
+        containerClassName,
+      )}
+      className={cn('disabled:cursor-not-allowed', className)}
+      {...props}
+    />
+  );
+}
+
+function InputOTPGroup({ className, ...props }: React.ComponentProps<'div'>) {
+  return (
+    <div
+      data-slot="input-otp-group"
+      className={cn('flex items-center', className)}
+      {...props}
+    />
+  );
+}
+
+function InputOTPSlot({
+  index,
+  className,
+  ...props
+}: React.ComponentProps<'div'> & {
+  index: number;
+}) {
+  const inputOTPContext = React.useContext(OTPInputContext);
+  const { char, hasFakeCaret, isActive } = inputOTPContext?.slots[index] ?? {};
+
+  return (
+    <div
+      data-slot="input-otp-slot"
+      data-active={isActive}
+      className={cn(
+        'data-[active=true]:border-ring data-[active=true]:ring-ring/50 data-[active=true]:aria-invalid:ring-destructive/20 dark:data-[active=true]:aria-invalid:ring-destructive/40 aria-invalid:border-destructive data-[active=true]:aria-invalid:border-destructive dark:bg-input/30 border-input relative flex h-9 w-9 items-center justify-center border-y border-r text-sm shadow-xs transition-all outline-none first:rounded-l-md first:border-l last:rounded-r-md data-[active=true]:z-10 data-[active=true]:ring-[3px]',
+        className,
+      )}
+      {...props}
+    >
+      {char}
+      {hasFakeCaret && (
+        <div className="pointer-events-none absolute inset-0 flex items-center justify-center">
+          <div className="animate-caret-blink bg-foreground h-4 w-px duration-1000" />
+        </div>
+      )}
+    </div>
+  );
+}
+
+function InputOTPSeparator({ ...props }: React.ComponentProps<'div'>) {
+  return (
+    <div data-slot="input-otp-separator" role="separator" {...props}>
+      <MinusIcon />
+    </div>
+  );
+}
+
+export { InputOTP, InputOTPGroup, InputOTPSlot, InputOTPSeparator };

web/src/i18n/locales/en-US.ts

@@ -39,6 +39,7 @@ const enUS = {
     addRound: 'Add Round',
     copySuccess: 'Copy Successfully',
     test: 'Test',
+    forgotPassword: 'Forgot Password?',
   },
   notFound: {
     title: 'Page not found',
@@ -239,6 +240,25 @@ const enUS = {
     initSuccess: 'Initialization successful, please login',
     initFailed: 'Initialization failed: ',
   },
+  resetPassword: {
+    title: 'Reset Password 🔐',
+    description:
+      'Enter your recovery key and new password to reset your account password',
+    recoveryKey: 'Recovery Key',
+    recoveryKeyDescription:
+      'Stored in `system.recovery_key` of config file `data/config.yaml`',
+    newPassword: 'New Password',
+    enterRecoveryKey: 'Enter recovery key',
+    enterNewPassword: 'Enter new password',
+    recoveryKeyRequired: 'Recovery key cannot be empty',
+    newPasswordRequired: 'New password cannot be empty',
+    resetPassword: 'Reset Password',
+    resetting: 'Resetting...',
+    resetSuccess: 'Password reset successfully, please login',
+    resetFailed:
+      'Password reset failed, please check your email and recovery key',
+    backToLogin: 'Back to Login',
+  },
 };
 
 export default enUS;

web/src/i18n/locales/ja-JP.ts

@@ -40,6 +40,7 @@ const jaJP = {
     addRound: 'ラウンドを追加',
     copySuccess: 'コピーに成功しました',
     test: 'テスト',
+    forgotPassword: 'パスワードを忘れた？',
   },
   notFound: {
     title: 'ページが見つかりません',
@@ -240,6 +241,25 @@ const jaJP = {
     initSuccess: '初期化に成功しました。ログインしてください',
     initFailed: '初期化に失敗しました：',
   },
+  resetPassword: {
+    title: 'パスワードをリセット 🔐',
+    description:
+      '復旧キーと新しいパスワードを入力して、アカウントのパスワードをリセットします',
+    recoveryKey: '復旧キー',
+    recoveryKeyDescription:
+      '設定ファイル `data/config.yaml` の `system.recovery_key` に保存されています',
+    newPassword: '新しいパスワード',
+    enterRecoveryKey: '復旧キーを入力',
+    enterNewPassword: '新しいパスワードを入力',
+    recoveryKeyRequired: '復旧キーは必須です',
+    newPasswordRequired: '新しいパスワードは必須です',
+    resetPassword: 'パスワードをリセット',
+    resetting: 'リセット中...',
+    resetSuccess: 'パスワードのリセットに成功しました。ログインしてください',
+    resetFailed:
+      'パスワードのリセットに失敗しました。メールアドレスと復旧キーを確認してください',
+    backToLogin: 'ログインに戻る',
+  },
 };
 
 export default jaJP;

web/src/i18n/locales/zh-Hans.ts

@@ -39,6 +39,7 @@ const zhHans = {
     addRound: '添加回合',
     copySuccess: '复制成功',
     test: '测试',
+    forgotPassword: '忘记密码？',
   },
   notFound: {
     title: '页面不存在',
@@ -233,6 +234,23 @@ const zhHans = {
     initSuccess: '初始化成功 请登录',
     initFailed: '初始化失败：',
   },
+  resetPassword: {
+    title: '重置密码 🔐',
+    description: '输入恢复密钥和新的密码来重置您的账户密码',
+    recoveryKey: '恢复密钥',
+    recoveryKeyDescription:
+      '存储在配置文件`data/config.yaml`的`system.recovery_key`中',
+    newPassword: '新密码',
+    enterRecoveryKey: '输入恢复密钥',
+    enterNewPassword: '输入新密码',
+    recoveryKeyRequired: '恢复密钥不能为空',
+    newPasswordRequired: '新密码不能为空',
+    resetPassword: '重置密码',
+    resetting: '重置中...',
+    resetSuccess: '密码重置成功，请登录',
+    resetFailed: '密码重置失败，请检查邮箱和恢复密钥是否正确',
+    backToLogin: '返回登录',
+  },
 };
 
 export default zhHans;