autoglm-gui 1.4.1__py3-none-any.whl → 1.5.0__py3-none-any.whl

AutoGLM_GUI/config_manager.py

@@ -52,12 +52,6 @@ class ConfigModel(BaseModel):
     model_name: str = "autoglm-phone-9b"
     api_key: str = "EMPTY"
 
-    # 双模型配置
-    dual_model_enabled: bool = False
-    decision_base_url: str = ""
-    decision_model_name: str = ""
-    decision_api_key: str = ""
-
     # Agent 类型配置
     agent_type: str = "glm"  # Agent type (e.g., "glm", "mai")
     agent_config_params: dict | None = None  # Agent-specific configuration
@@ -65,6 +59,11 @@ class ConfigModel(BaseModel):
     # Agent 执行配置
     default_max_steps: int = 100  # 单次任务最大执行步数
 
+    # 决策模型配置（用于分层代理）
+    decision_base_url: str | None = None
+    decision_model_name: str | None = None
+    decision_api_key: str | None = None
+
     @field_validator("default_max_steps")
     @classmethod
     def validate_default_max_steps(cls, v: int) -> int:
@@ -93,11 +92,23 @@ class ConfigModel(BaseModel):
 
     @field_validator("decision_base_url")
     @classmethod
-    def validate_decision_base_url(cls, v: str) -> str:
+    def validate_decision_base_url(cls, v: str | None) -> str | None:
         """验证 decision_base_url 格式."""
-        if v and not v.startswith(("http://", "https://")):
-            raise ValueError("decision_base_url must start with http:// or https://")
-        return v.rstrip("/")  # 去除尾部斜杠
+        if v is not None:
+            if not v.startswith(("http://", "https://")):
+                raise ValueError(
+                    "decision_base_url must start with http:// or https://"
+                )
+            return v.rstrip("/")
+        return v
+
+    @field_validator("decision_model_name")
+    @classmethod
+    def validate_decision_model_name(cls, v: str | None) -> str | None:
+        """验证 decision_model_name 非空."""
+        if v is not None and (not v or not v.strip()):
+            raise ValueError("decision_model_name cannot be empty string")
+        return v.strip() if v else v
 
 
 # ==================== 配置层数据类 ====================
@@ -110,16 +121,15 @@ class ConfigLayer:
     base_url: Optional[str] = None
     model_name: Optional[str] = None
     api_key: Optional[str] = None
-    # 双模型配置
-    dual_model_enabled: Optional[bool] = None
-    decision_base_url: Optional[str] = None
-    decision_model_name: Optional[str] = None
-    decision_api_key: Optional[str] = None
     # Agent 类型配置
     agent_type: Optional[str] = None
     agent_config_params: Optional[dict] = None
     # Agent 执行配置
     default_max_steps: Optional[int] = None
+    # 决策模型配置
+    decision_base_url: Optional[str] = None
+    decision_model_name: Optional[str] = None
+    decision_api_key: Optional[str] = None
 
     source: ConfigSource = ConfigSource.DEFAULT
 
@@ -147,13 +157,12 @@ class ConfigLayer:
                 "base_url": self.base_url,
                 "model_name": self.model_name,
                 "api_key": self.api_key,
-                "dual_model_enabled": self.dual_model_enabled,
-                "decision_base_url": self.decision_base_url,
-                "decision_model_name": self.decision_model_name,
-                "decision_api_key": self.decision_api_key,
                 "agent_type": self.agent_type,
                 "agent_config_params": self.agent_config_params,
                 "default_max_steps": self.default_max_steps,
+                "decision_base_url": self.decision_base_url,
+                "decision_model_name": self.decision_model_name,
+                "decision_api_key": self.decision_api_key,
             }.items()
             if v is not None
         }
@@ -216,6 +225,9 @@ class UnifiedConfigManager:
             agent_type="glm",
             agent_config_params=None,
             default_max_steps=100,
+            decision_base_url=None,
+            decision_model_name=None,
+            decision_api_key=None,
             source=ConfigSource.DEFAULT,
         )
 
@@ -262,15 +274,26 @@ class UnifiedConfigManager:
         - AUTOGLM_BASE_URL
         - AUTOGLM_MODEL_NAME
         - AUTOGLM_API_KEY
+        - AUTOGLM_DECISION_BASE_URL
+        - AUTOGLM_DECISION_MODEL_NAME
+        - AUTOGLM_DECISION_API_KEY
         """
         base_url = os.getenv("AUTOGLM_BASE_URL")
         model_name = os.getenv("AUTOGLM_MODEL_NAME")
         api_key = os.getenv("AUTOGLM_API_KEY")
 
+        # 决策模型环境变量
+        decision_base_url = os.getenv("AUTOGLM_DECISION_BASE_URL")
+        decision_model_name = os.getenv("AUTOGLM_DECISION_MODEL_NAME")
+        decision_api_key = os.getenv("AUTOGLM_DECISION_API_KEY")
+
         self._env_layer = ConfigLayer(
             base_url=base_url if base_url else None,
             model_name=model_name if model_name else None,
             api_key=api_key if api_key else None,
+            decision_base_url=decision_base_url if decision_base_url else None,
+            decision_model_name=decision_model_name if decision_model_name else None,
+            decision_api_key=decision_api_key if decision_api_key else None,
             source=ConfigSource.ENV,
         )
         self._effective_config = None  # 清除缓存
@@ -324,15 +347,14 @@ class UnifiedConfigManager:
                 base_url=config_data.get("base_url"),
                 model_name=config_data.get("model_name"),
                 api_key=config_data.get("api_key"),
-                dual_model_enabled=config_data.get("dual_model_enabled"),
-                decision_base_url=config_data.get("decision_base_url"),
-                decision_model_name=config_data.get("decision_model_name"),
-                decision_api_key=config_data.get("decision_api_key"),
                 agent_type=config_data.get(
                     "agent_type", "glm"
                 ),  # 默认 'glm'，兼容旧配置
                 agent_config_params=config_data.get("agent_config_params"),
                 default_max_steps=config_data.get("default_max_steps"),
+                decision_base_url=config_data.get("decision_base_url"),
+                decision_model_name=config_data.get("decision_model_name"),
+                decision_api_key=config_data.get("decision_api_key"),
                 source=ConfigSource.FILE,
             )
             self._effective_config = None  # 清除缓存
@@ -360,13 +382,12 @@ class UnifiedConfigManager:
         base_url: str,
         model_name: str,
         api_key: Optional[str] = None,
-        dual_model_enabled: Optional[bool] = None,
-        decision_base_url: Optional[str] = None,
-        decision_model_name: Optional[str] = None,
-        decision_api_key: Optional[str] = None,
         agent_type: Optional[str] = None,
         agent_config_params: Optional[dict] = None,
         default_max_steps: Optional[int] = None,
+        decision_base_url: Optional[str] = None,
+        decision_model_name: Optional[str] = None,
+        decision_api_key: Optional[str] = None,
         merge_mode: bool = True,
     ) -> bool:
         """
@@ -376,13 +397,12 @@ class UnifiedConfigManager:
             base_url: Base URL
             model_name: 模型名称
             api_key: API key（可选）
-            dual_model_enabled: 是否启用双模型
-            decision_base_url: 决策模型 Base URL
-            decision_model_name: 决策模型名称
-            decision_api_key: 决策模型 API key
             agent_type: Agent 类型（可选，如 "glm", "mai"）
             agent_config_params: Agent 特定配置参数（可选）
             default_max_steps: 默认最大执行步数（可选）
+            decision_base_url: 决策模型 Base URL（可选）
+            decision_model_name: 决策模型名称（可选）
+            decision_api_key: 决策模型 API Key（可选）
             merge_mode: 是否合并现有配置（True: 保留未提供的字段）
 
         Returns:
@@ -400,14 +420,6 @@ class UnifiedConfigManager:
 
             if api_key:
                 new_config["api_key"] = api_key
-            if dual_model_enabled is not None:
-                new_config["dual_model_enabled"] = dual_model_enabled
-            if decision_base_url:
-                new_config["decision_base_url"] = decision_base_url
-            if decision_model_name:
-                new_config["decision_model_name"] = decision_model_name
-            if decision_api_key:
-                new_config["decision_api_key"] = decision_api_key
             if agent_type is not None:
                 new_config["agent_type"] = agent_type
             if agent_config_params is not None:
@@ -415,6 +427,14 @@ class UnifiedConfigManager:
             if default_max_steps is not None:
                 new_config["default_max_steps"] = default_max_steps
 
+            # 决策模型配置
+            if decision_base_url is not None:
+                new_config["decision_base_url"] = decision_base_url
+            if decision_model_name is not None:
+                new_config["decision_model_name"] = decision_model_name
+            if decision_api_key is not None:
+                new_config["decision_api_key"] = decision_api_key
+
             # 合并模式：保留现有文件中未提供的字段
             if merge_mode and self._config_path.exists():
                 try:
@@ -424,13 +444,12 @@ class UnifiedConfigManager:
                     # 保留未提供的字段
                     preserve_keys = [
                         "api_key",
-                        "dual_model_enabled",
-                        "decision_base_url",
-                        "decision_model_name",
-                        "decision_api_key",
                         "agent_type",
                         "agent_config_params",
                         "default_max_steps",
+                        "decision_base_url",
+                        "decision_model_name",
+                        "decision_api_key",
                     ]
                     for key in preserve_keys:
                         if key not in new_config and key in existing:
@@ -515,13 +534,12 @@ class UnifiedConfigManager:
             "base_url",
             "model_name",
             "api_key",
-            "dual_model_enabled",
-            "decision_base_url",
-            "decision_model_name",
-            "decision_api_key",
             "agent_type",
             "agent_config_params",
             "default_max_steps",
+            "decision_base_url",
+            "decision_model_name",
+            "decision_api_key",
         ]
 
         for key in config_keys:
@@ -684,13 +702,12 @@ class UnifiedConfigManager:
             "base_url": config.base_url,
             "model_name": config.model_name,
             "api_key": config.api_key,
-            "dual_model_enabled": config.dual_model_enabled,
-            "decision_base_url": config.decision_base_url,
-            "decision_model_name": config.decision_model_name,
-            "decision_api_key": config.decision_api_key,
             "agent_type": config.agent_type,
             "agent_config_params": config.agent_config_params,
             "default_max_steps": config.default_max_steps,
+            "decision_base_url": config.decision_base_url,
+            "decision_model_name": config.decision_model_name,
+            "decision_api_key": config.decision_api_key,
         }
 
 

AutoGLM_GUI/device_manager.py

@@ -7,11 +7,30 @@ import time
 from collections import defaultdict
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Optional
-
-from phone_agent.adb.connection import ADBConnection, ConnectionType, DeviceInfo
+from typing import TYPE_CHECKING, Optional
 
+from AutoGLM_GUI.adb import ADBConnection, ConnectionType, DeviceInfo
 from AutoGLM_GUI.logger import logger
+from AutoGLM_GUI.types import DeviceConnectionType
+
+if TYPE_CHECKING:
+    from AutoGLM_GUI.device_protocol import DeviceProtocol
+
+
+def convert_connection_type(ct: ConnectionType) -> DeviceConnectionType:
+    """Convert phone_agent ConnectionType to DeviceConnectionType.
+
+    phone_agent.ConnectionType.REMOTE is actually WiFi ADB,
+    so we map it to DeviceConnectionType.WIFI.
+    """
+    if ct == ConnectionType.USB:
+        return DeviceConnectionType.USB
+    elif ct == ConnectionType.WIFI:
+        return DeviceConnectionType.WIFI
+    elif ct == ConnectionType.REMOTE:
+        return DeviceConnectionType.WIFI
+    else:
+        return DeviceConnectionType.USB
 
 
 class DeviceState(str, Enum):
@@ -28,7 +47,7 @@ class DeviceConnection:
     """Single connection method for a device (USB, WiFi, mDNS, etc.)."""
 
     device_id: str  # USB serial OR IP:port
-    connection_type: ConnectionType
+    connection_type: DeviceConnectionType
     status: str  # "device" | "offline" | "unauthorized"
     last_seen: float = field(default_factory=time.time)
 
@@ -36,14 +55,13 @@ class DeviceConnection:
         """Calculate connection priority for sorting.
 
         Priority:
-        1. Connection type (USB > WiFi/Remote > mDNS)
+        1. Connection type (USB > WiFi > Remote)
         2. Status (device > offline > unauthorized)
         """
-        # Type priority (higher is better)
         type_priority = {
-            ConnectionType.USB: 300,
-            ConnectionType.WIFI: 200,
-            ConnectionType.REMOTE: 200,
+            DeviceConnectionType.USB: 300,
+            DeviceConnectionType.WIFI: 200,
+            DeviceConnectionType.REMOTE: 100,
         }
 
         # Status priority
@@ -98,7 +116,7 @@ class ManagedDevice:
         return self.primary_connection.status
 
     @property
-    def connection_type(self) -> ConnectionType:
+    def connection_type(self) -> DeviceConnectionType:
         """Type of primary connection."""
         return self.primary_connection.connection_type
 
@@ -153,7 +171,7 @@ def _create_managed_device(
     connections = [
         DeviceConnection(
             device_id=d.device_id,
-            connection_type=d.connection_type,
+            connection_type=convert_connection_type(d.connection_type),
             status=d.status,
             last_seen=time.time(),
         )
@@ -228,6 +246,9 @@ class DeviceManager:
         self._mdns_devices: dict[str, ManagedDevice] = {}  # Key: serial
         self._enable_mdns_discovery: bool = True  # Feature toggle
 
+        self._remote_devices: dict[str, "DeviceProtocol"] = {}
+        self._remote_device_configs: dict[str, dict] = {}
+
     @classmethod
     def get_instance(cls, adb_path: str = "adb") -> DeviceManager:
         """Get singleton instance (thread-safe)."""
@@ -312,9 +333,19 @@ class DeviceManager:
             return None
 
     def force_refresh(self) -> None:
-        """Trigger immediate device list refresh (blocking)."""
+        """Trigger immediate device list refresh (blocking).
+
+        Note: This method may fail if ADB is unavailable. Exceptions are logged
+        but not propagated to support remote-only deployments.
+        """
         logger.info("Force refreshing device list...")
-        self._poll_devices()
+        try:
+            self._poll_devices()
+        except Exception as e:
+            logger.warning(
+                f"Device poll failed during force refresh: {e}. "
+                f"This is expected in remote-only deployments without local ADB."
+            )
 
     # Internal methods
 
@@ -366,16 +397,8 @@ class DeviceManager:
         device_with_serials: list[tuple[DeviceInfo, str]] = []
 
         for device_info in adb_devices:
+            # get_device_serial always returns a value (uses device_id as fallback)
             serial = get_device_serial(device_info.device_id, self._adb_path)
-
-            if not serial:
-                # CRITICAL: Log error and skip this device
-                logger.error(
-                    f"Failed to get serial for device {device_info.device_id}. "
-                    f"Skipping this device. Check ADB access."
-                )
-                continue
-
             device_with_serials.append((device_info, serial))
 
         # Step 2: Group devices by serial
@@ -414,6 +437,12 @@ class DeviceManager:
 
             added_serials = current_serials - previous_serials
             removed_serials = previous_serials - current_serials
+            removed_serials = {
+                s
+                for s in removed_serials
+                if s not in self._devices
+                or self._devices[s].connection_type != DeviceConnectionType.REMOTE
+            }
             existing_serials = current_serials & previous_serials
 
             # Add new devices
@@ -441,7 +470,7 @@ class DeviceManager:
                 new_connections = [
                     DeviceConnection(
                         device_id=d.device_id,
-                        connection_type=d.connection_type,
+                        connection_type=convert_connection_type(d.connection_type),
                         status=d.status,
                         last_seen=time.time(),
                     )
@@ -531,8 +560,8 @@ class DeviceManager:
                                 connections=[
                                     DeviceConnection(
                                         device_id=f"{mdns_dev.ip}:{mdns_dev.port}",
-                                        connection_type=ConnectionType.REMOTE,
-                                        status="available",  # Not connected yet
+                                        connection_type=DeviceConnectionType.WIFI,
+                                        status="available",
                                         last_seen=time.time(),
                                     )
                                 ],
@@ -590,7 +619,7 @@ class DeviceManager:
         Returns:
             Tuple of (success, message, wifi_device_id)
         """
-        from phone_agent.adb.connection import ADBConnection, ConnectionType
+        from AutoGLM_GUI.adb import ADBConnection, ConnectionType
 
         from AutoGLM_GUI.adb_plus import get_wifi_ip
 
@@ -637,7 +666,7 @@ class DeviceManager:
         Returns:
             Tuple of (success, message)
         """
-        from phone_agent.adb.connection import ADBConnection
+        from AutoGLM_GUI.adb import ADBConnection
 
         conn = ADBConnection(adb_path=self._adb_path)
         ok, msg = conn.disconnect(device_id)
@@ -663,7 +692,7 @@ class DeviceManager:
         """
         import re
 
-        from phone_agent.adb.connection import ADBConnection
+        from AutoGLM_GUI.adb import ADBConnection
 
         # IP format validation
         ip_pattern = r"^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$"
@@ -701,7 +730,7 @@ class DeviceManager:
         """
         import re
 
-        from phone_agent.adb.connection import ADBConnection
+        from AutoGLM_GUI.adb import ADBConnection
 
         from AutoGLM_GUI.adb_plus import pair_device
 
@@ -758,3 +787,193 @@ class DeviceManager:
             f"Successfully paired and connected to {connection_address}",
             connection_address,
         )
+
+    def discover_remote_devices(
+        self, base_url: str, timeout: int = 5
+    ) -> tuple[bool, str, list[dict]]:
+        """Discover devices from a remote Device Agent Server.
+
+        Args:
+            base_url: Remote Agent Server address
+            timeout: Connection timeout in seconds
+
+        Returns:
+            Tuple of (success, message, devices_list)
+        """
+        from AutoGLM_GUI.devices.remote_device import RemoteDeviceManager
+
+        base_url = base_url.strip().rstrip("/")
+        if not base_url.startswith(("http://", "https://")):
+            return (False, "base_url must start with http:// or https://", [])
+
+        try:
+            remote_manager = RemoteDeviceManager(base_url, timeout=float(timeout))
+            devices = remote_manager.list_devices()
+
+            devices_list = [
+                {
+                    "device_id": d.device_id,
+                    "model": d.model or "Unknown",
+                    "platform": d.platform,
+                    "status": d.status,
+                }
+                for d in devices
+            ]
+
+            return (True, f"Found {len(devices_list)} device(s)", devices_list)
+        except Exception as e:
+            logger.error(f"Failed to discover remote devices: {e}")
+            return (False, f"Discovery failed: {str(e)}", [])
+
+    def add_remote_device(self, base_url: str, device_id: str) -> tuple[bool, str, str]:
+        """Manually add a remote HTTP proxy device.
+
+        Args:
+            base_url: Remote Agent Server address (e.g., http://server:8001)
+            device_id: Device ID on the remote server
+
+        Returns:
+            Tuple of (success, message, synthetic_serial)
+        """
+        from AutoGLM_GUI.devices.remote_device import RemoteDevice
+
+        base_url = base_url.strip().rstrip("/")
+        if not base_url.startswith(("http://", "https://")):
+            return (False, "base_url must start with http:// or https://", "")
+
+        synthetic_serial = f"remote:{base_url}:{device_id}"
+
+        with self._devices_lock:
+            if synthetic_serial in self._devices:
+                return (False, f"Remote device {device_id} already exists", "")
+
+            try:
+                remote_device = RemoteDevice(device_id, base_url)
+                remote_device.get_screenshot(timeout=5)
+
+                managed = ManagedDevice(
+                    serial=synthetic_serial,
+                    connections=[
+                        DeviceConnection(
+                            device_id=f"{base_url}|{device_id}",
+                            connection_type=DeviceConnectionType.REMOTE,
+                            status="device",
+                            last_seen=time.time(),
+                        )
+                    ],
+                    model=device_id,
+                    state=DeviceState.ONLINE,
+                )
+
+                self._devices[synthetic_serial] = managed
+                self._remote_devices[synthetic_serial] = remote_device
+                self._remote_device_configs[synthetic_serial] = {
+                    "base_url": base_url,
+                    "device_id": device_id,
+                }
+
+                self._device_id_to_serial[managed.primary_device_id] = synthetic_serial
+
+                logger.info(f"Remote device added: {synthetic_serial}")
+                return (True, "Remote device added successfully", synthetic_serial)
+
+            except Exception as e:
+                logger.error(f"Failed to connect to remote device: {e}")
+                return (False, f"Connection failed: {str(e)}", "")
+
+    def remove_remote_device(self, serial: str) -> tuple[bool, str]:
+        """Remove a remote device.
+
+        Args:
+            serial: Synthetic serial of the remote device (remote:...)
+
+        Returns:
+            Tuple of (success, message)
+        """
+        with self._devices_lock:
+            if serial not in self._devices:
+                return (False, "Remote device not found")
+
+            managed = self._devices.get(serial)
+            if not managed or managed.connection_type != DeviceConnectionType.REMOTE:
+                return (False, "Not a remote device")
+
+            managed = self._devices.pop(serial)
+            remote_device = self._remote_devices.pop(serial, None)
+            self._remote_device_configs.pop(serial, None)
+
+            for conn in managed.connections:
+                self._device_id_to_serial.pop(conn.device_id, None)
+
+            if remote_device:
+                try:
+                    remote_device.close()  # type: ignore
+                except Exception as e:
+                    logger.warning(f"Error closing remote device: {e}")
+
+            logger.info(f"Remote device removed: {serial}")
+            return (True, "Remote device removed successfully")
+
+    def get_remote_device_instance(self, serial: str) -> "DeviceProtocol | None":
+        """Get RemoteDevice instance for device adapter injection.
+
+        Args:
+            serial: Synthetic serial of the remote device
+
+        Returns:
+            RemoteDevice instance or None if not found
+        """
+        return self._remote_devices.get(serial)
+
+    def get_serial_by_device_id(self, device_id: str) -> str | None:
+        """Get serial by device_id (reverse lookup).
+
+        Args:
+            device_id: Device ID from connections
+
+        Returns:
+            Serial (synthetic or ADB) or None if not found
+        """
+        return self._device_id_to_serial.get(device_id)
+
+    def get_device_protocol(self, device_id: str) -> "DeviceProtocol":
+        """
+        根据 device_id 获取 DeviceProtocol 实例（统一入口）.
+
+        自动识别设备类型（ADB / Remote）并返回对应的实现。
+
+        Args:
+            device_id: 设备标识符（USB serial / IP:port / remote_xxx）
+
+        Returns:
+            DeviceProtocol 实例（ADBDevice 或 RemoteDevice）
+
+        Raises:
+            ValueError: 设备未找到或不可用
+
+        Example:
+            >>> manager = DeviceManager.get_instance()
+            >>> device = manager.get_device_protocol("192.168.1.100:5555")
+            >>> screenshot = device.get_screenshot()  # 不关心是 ADB 还是 Remote
+        """
+        with self._devices_lock:
+            # 1. 查找设备元数据
+            managed = self.get_device_by_device_id(device_id)
+            if not managed:
+                raise ValueError(f"Device {device_id} not found in DeviceManager")
+
+            # 2. 根据连接类型返回对应实现
+            if managed.connection_type == DeviceConnectionType.REMOTE:
+                # Remote device: 返回 HTTP 客户端
+                remote_device = self.get_remote_device_instance(managed.serial)
+                if not remote_device:
+                    raise ValueError(
+                        f"Remote device instance not found for serial {managed.serial}"
+                    )
+                return remote_device  # type: ignore[return-value]
+
+            else:
+                # ADB device (USB / WiFi): 返回本地 ADB 包装
+                from AutoGLM_GUI.devices.adb_device import ADBDevice
+
+                return ADBDevice(managed.primary_device_id)

AutoGLM_GUI/device_protocol.py

@@ -42,7 +42,7 @@ class DeviceInfo:
     status: str  # "online" | "offline" | "unauthorized"
     model: str | None = None
     platform: str = "android"  # "android" | "ios" | "harmonyos"
-    connection_type: str = "usb"  # "usb" | "wifi" | "remote"
+    connection_type: str = "usb"  # "usb" | "wifi" (ADB WiFi) | "remote" (HTTP Remote)
 
 
 @runtime_checkable

AutoGLM_GUI/devices/adb_device.py

@@ -1,12 +1,7 @@
-"""ADB Device implementation of DeviceProtocol.
-
-This module wraps the existing phone_agent.adb module to provide
-a DeviceProtocol-compliant implementation.
-"""
-
-from phone_agent import adb
-from phone_agent.adb import ADBConnection
+"""ADB Device implementation of DeviceProtocol."""
 
+from AutoGLM_GUI import adb
+from AutoGLM_GUI.adb import ADBConnection
 from AutoGLM_GUI.device_protocol import (
     DeviceInfo,
     DeviceManagerProtocol,
@@ -15,7 +10,7 @@ from AutoGLM_GUI.device_protocol import (
 )
 
 
-class ADBDevice:
+class ADBDevice(DeviceProtocol):
     """
     ADB device implementation using local subprocess calls.
 
@@ -121,7 +116,7 @@ class ADBDevice:
 assert isinstance(ADBDevice("test"), DeviceProtocol)
 
 
-class ADBDeviceManager:
+class ADBDeviceManager(DeviceManagerProtocol):
     """
     ADB device manager implementation.