pyproject.toml

@@ -12,7 +12,7 @@ dependencies = [
     "google-genai>=1.39.1",
     "jieba>=0.42.1",
     "json-repair>=0.47.6",
-    "maim-message>=0.6.2",
+    "maim-message",
     "matplotlib>=3.10.3",
     "msgpack>=1.1.2",
     "numpy>=2.2.6",

src/chat/message_receive/uni_message_sender.py

@@ -189,7 +189,6 @@ async def _send_message(message: MessageSending, show_log=True) -> bool:
 
                 # 如果未开启 API Server，直接跳过 Fallback
                 if not global_config.maim_message.enable_api_server:
-                    logger.debug(f"[API Server Fallback] API Server未开启，跳过fallback")
                     if legacy_exception:
                         raise legacy_exception
                     return False
@@ -197,59 +196,36 @@ async def _send_message(message: MessageSending, show_log=True) -> bool:
                 global_api = get_global_api()
                 extra_server = getattr(global_api, "extra_server", None)
 
-                if not extra_server:
+                if extra_server and extra_server.is_running():
-                    logger.warning(f"[API Server Fallback] extra_server不存在")
+                    # Fallback: 使用极其简单的 Platform -> API Key 映射
-                    if legacy_exception:
+                    # 只有收到过该平台的消息，我们才知道该平台的 API Key，才能回传消息
-                        raise legacy_exception
+                    platform_map = getattr(global_api, "platform_map", {})
-                    return False
+                    target_api_key = platform_map.get(platform)
-                
-                if not extra_server.is_running():
-                    logger.warning(f"[API Server Fallback] extra_server未运行")
-                    if legacy_exception:
-                        raise legacy_exception
-                    return False
 
-                # Fallback: 使用极其简单的 Platform -> API Key 映射
+                    if target_api_key:
-                # 只有收到过该平台的消息，我们才知道该平台的 API Key，才能回传消息
+                        # 构造 APIMessageBase
-                platform_map = getattr(global_api, "platform_map", {})
+                        from maim_message.message import APIMessageBase, MessageDim
-                logger.debug(f"[API Server Fallback] platform_map: {platform_map}, 目标平台: '{platform}'")
-                target_api_key = platform_map.get(platform)
 
-                if not target_api_key:
+                        msg_dim = MessageDim(api_key=target_api_key, platform=platform)
-                    logger.warning(f"[API Server Fallback] 未找到平台'{platform}'的API Key映射")
-                    if legacy_exception:
-                        raise legacy_exception
-                    return False
 
-                # 使用 MessageConverter 转换 Legacy MessageBase 到 APIMessageBase
+                        api_message = APIMessageBase(
-                # 发送场景：MaiMBot 发送回复消息给外部用户
+                            message_info=message.message_info,
-                # group_info/user_info 是消息接收者信息，放入 receiver_info
+                            message_segment=message.message_segment,
-                from maim_message import MessageConverter
+                            message_dim=msg_dim,
-
-                api_message = MessageConverter.to_api_send(
-                    message=message,
-                    api_key=target_api_key,
-                    platform=platform,
-                )
-
-                # 直接调用 Server 的 send_message 接口，它会自动处理路由
-                logger.debug(f"[API Server Fallback] 正在通过extra_server发送消息...")
-                results = await extra_server.send_message(api_message)
-                logger.debug(f"[API Server Fallback] 发送结果: {results}")
-
-                # 检查是否有任何连接发送成功
-                if any(results.values()):
-                    if show_log:
-                        logger.info(
-                            f"已通过API Server Fallback将消息 '{message_preview}' 发往平台'{platform}' (key: {target_api_key})"
                         )
-                    return True
+
-                else:
+                        # 直接调用 Server 的 send_message 接口，它会自动处理路由
-                    logger.warning(f"[API Server Fallback] 没有连接发送成功, results={results}")
+                        results = await extra_server.send_message(api_message)
-            except Exception as e:
+
-                logger.error(f"[API Server Fallback] 发生异常: {e}")
+                        # 检查是否有任何连接发送成功
-                import traceback
+                        if any(results.values()):
-                logger.debug(traceback.format_exc())
+                            if show_log:
+                                logger.info(
+                                    f"已通过API Server Fallback将消息 '{message_preview}' 发往平台'{platform}' (key: {target_api_key})"
+                                )
+                            return True
+            except Exception:
+                pass
 
             # 如果 Fallback 失败，且存在 legacy 异常，则抛出 legacy 异常
             if legacy_exception:
@@ -258,17 +234,13 @@ async def _send_message(message: MessageSending, show_log=True) -> bool:
 
         try:
             send_result = await get_global_api().send_message(message)
-            if send_result:
+            # if send_result:
-                if show_log:
+            if show_log:
-                    logger.info(f"已将消息  '{message_preview}'  发往平台'{message.message_info.platform}'")
+                logger.info(f"已将消息  '{message_preview}'  发往平台'{message.message_info.platform}'")
-                return True
+            return True
-            else:
+
-                # Legacy API 返回 False (发送失败但未报错)，尝试 Fallback
+            # Legacy API 返回 False (发送失败但未报错)，尝试 Fallback
-                fallback_result = await send_with_new_api()
+            # return await send_with_new_api()
-                if fallback_result and show_log:
-                    # Fallback成功的日志已在send_with_new_api中打印
-                    pass
-                return fallback_result
 
         except Exception as legacy_e:
             # Legacy API 抛出异常，尝试 Fallback

src/common/message/api.py

@@ -18,7 +18,7 @@ def get_global_api() -> MessageServer:  # sourcery skip: extract-method
             version_int = [int(x) for x in maim_message_version.split(".")]
             version_compatible = version_int >= [0, 3, 3]
             # Check for API Server feature (>= 0.6.0)
-            has_api_server_feature = version_int >= [0, 6, 2]
+            has_api_server_feature = version_int >= [0, 6, 0]
         except (importlib.metadata.PackageNotFoundError, ValueError):
             version_compatible = False
             has_api_server_feature = False
@@ -75,7 +75,6 @@ def get_global_api() -> MessageServer:  # sourcery skip: extract-method
                     ssl_enabled=use_wss,
                     ssl_certfile=maim_message_config.api_server_cert_file if use_wss else None,
                     ssl_keyfile=maim_message_config.api_server_key_file if use_wss else None,
-                    custom_logger=api_logger  # 传入自定义logger
                 )
 
                 # 2. Setup Auth Handler
@@ -100,39 +99,32 @@ def get_global_api() -> MessageServer:  # sourcery skip: extract-method
                     global_api.platform_map = {}
 
                 async def bridge_message_handler(message: APIMessageBase, metadata: dict):
-                    # 使用 MessageConverter 转换 APIMessageBase 到 Legacy MessageBase
+                    # Bridge message to the main bot logic
-                    # 接收场景：收到从 Adapter 转发的外部消息
+                    # We convert APIMessageBase to dict to be compatible with legacy handlers
-                    # sender_info 包含消息发送者信息，需要提取到 group_info/user_info
+                    # that MainBot (ChatManager) expects.
-                    from maim_message import MessageConverter
+                    msg_dict = message.to_dict()
                     
-                    legacy_message = MessageConverter.from_api_receive(message)
+                    # Compatibility Layer: Flatten sender_info to top-level user_info/group_info
-                    msg_dict = legacy_message.to_dict()
+                    # Legacy MessageBase expects message_info to have user_info and group_info directly.
-                    
-                    # Compatibility Layer: Ensure format_info exists with defaults
-                    # MaiMBot's check_types() accesses format_info.accept_format without None check
                     if "message_info" in msg_dict:
                         msg_info = msg_dict["message_info"]
-                        
+                        sender_info = msg_info.get("sender_info")
-                        if "format_info" not in msg_info or msg_info["format_info"] is None:
+                        if sender_info:
-                            msg_info["format_info"] = {
+                            # If direct user_info/group_info are missing, populate them from sender_info
-                                "content_format": ["text", "image", "emoji", "voice"],
+                            if "user_info" not in msg_info and (ui := sender_info.get("user_info")):
-                                "accept_format": [
+                                msg_info["user_info"] = ui
-                                    "text", "image", "emoji", "reply", "voice", "command",
+                            
-                                    "voiceurl", "music", "videourl", "file", "imageurl", "forward", "video"
+                            if "group_info" not in msg_info and (gi := sender_info.get("group_info")):
-                                ]
+                                msg_info["group_info"] = gi
-                            }
                                 
-                        # Route Caching Logic: Map platform to API Key (or connection uuid as fallback)
+                        # Route Caching Logic: Simply map platform to API Key
                         # This allows us to send messages back to the correct API client for this platform
                         try:
-                            # Get api_key from metadata, use uuid as fallback if api_key is empty
+                            api_key = metadata.get("api_key")
-                            api_key = metadata.get("api_key") or metadata.get("uuid") or "unknown"
+                            if api_key:
-                            platform = msg_info.get("platform")
+                                platform = msg_info.get("platform")
-                            api_logger.debug(f"Bridge received: api_key='{api_key}', platform='{platform}'")
+                                if platform:
-                            
+                                    global_api.platform_map[platform] = api_key
-                            if platform:
-                                global_api.platform_map[platform] = api_key
-                                api_logger.info(f"Updated platform_map: {platform} -> {api_key}")
                         except Exception as e:
                             api_logger.warning(f"Failed to update platform map: {e}")
 
@@ -144,27 +136,6 @@ def get_global_api() -> MessageServer:  # sourcery skip: extract-method
 
                 server_config.on_message = bridge_message_handler
 
-                # 3.5. Register custom message handlers (bridge to Legacy handlers)
-                # message_id_echo: handles message ID echo from adapters
-                # 兼容新旧两个版本的 maim_message:
-                # - 旧版: handler(payload)
-                # - 新版: handler(payload, metadata)
-                async def custom_message_id_echo_handler(payload: dict, metadata: dict = None):
-                    # Bridge to the Legacy custom handler registered in main.py
-                    try:
-                        # The Legacy handler expects the payload format directly
-                        if hasattr(global_api, '_custom_message_handlers'):
-                            handler = global_api._custom_message_handlers.get("message_id_echo")
-                            if handler:
-                                await handler(payload)
-                                api_logger.debug(f"Processed message_id_echo: {payload}")
-                            else:
-                                api_logger.debug(f"No handler for message_id_echo, payload: {payload}")
-                    except Exception as e:
-                        api_logger.warning(f"Failed to process message_id_echo: {e}")
-
-                server_config.register_custom_handler("message_id_echo", custom_message_id_echo_handler)
-
                 # 4. Initialize Server
                 extra_server = WebSocketServer(config=server_config)
                 
@@ -198,4 +169,3 @@ def get_global_api() -> MessageServer:  # sourcery skip: extract-method
                 get_logger("maim_message").debug(traceback.format_exc())
 
     return global_api
-