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

AutoGLM_GUI/config_manager.py

@@ -58,6 +58,23 @@ class ConfigModel(BaseModel):
     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
+
+    # Agent 执行配置
+    default_max_steps: int = 100  # 单次任务最大执行步数
+
+    @field_validator("default_max_steps")
+    @classmethod
+    def validate_default_max_steps(cls, v: int) -> int:
+        """验证 default_max_steps 范围."""
+        if v <= 0:
+            raise ValueError("default_max_steps must be positive")
+        if v > 1000:
+            raise ValueError("default_max_steps must be <= 1000")
+        return v
+
     @field_validator("base_url")
     @classmethod
     def validate_base_url(cls, v: str) -> str:
@@ -98,6 +115,11 @@ class ConfigLayer:
     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
 
     source: ConfigSource = ConfigSource.DEFAULT
 
@@ -129,6 +151,9 @@ class ConfigLayer:
                 "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,
             }.items()
             if v is not None
         }
@@ -188,6 +213,9 @@ class UnifiedConfigManager:
             base_url="",
             model_name="autoglm-phone-9b",
             api_key="EMPTY",
+            agent_type="glm",
+            agent_config_params=None,
+            default_max_steps=100,
             source=ConfigSource.DEFAULT,
         )
 
@@ -300,6 +328,11 @@ class UnifiedConfigManager:
                 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"),
                 source=ConfigSource.FILE,
             )
             self._effective_config = None  # 清除缓存
@@ -331,6 +364,9 @@ class UnifiedConfigManager:
         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,
         merge_mode: bool = True,
     ) -> bool:
         """
@@ -344,6 +380,9 @@ class UnifiedConfigManager:
             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: 默认最大执行步数（可选）
             merge_mode: 是否合并现有配置（True: 保留未提供的字段）
 
         Returns:
@@ -354,7 +393,7 @@ class UnifiedConfigManager:
             self._config_path.parent.mkdir(parents=True, exist_ok=True)
 
             # 准备新配置
-            new_config = {
+            new_config: dict[str, str | bool | int | dict | None] = {
                 "base_url": base_url,
                 "model_name": model_name,
             }
@@ -369,6 +408,12 @@ class UnifiedConfigManager:
                 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:
+                new_config["agent_config_params"] = agent_config_params
+            if default_max_steps is not None:
+                new_config["default_max_steps"] = default_max_steps
 
             # 合并模式：保留现有文件中未提供的字段
             if merge_mode and self._config_path.exists():
@@ -383,6 +428,9 @@ class UnifiedConfigManager:
                         "decision_base_url",
                         "decision_model_name",
                         "decision_api_key",
+                        "agent_type",
+                        "agent_config_params",
+                        "default_max_steps",
                     ]
                     for key in preserve_keys:
                         if key not in new_config and key in existing:
@@ -471,6 +519,9 @@ class UnifiedConfigManager:
             "decision_base_url",
             "decision_model_name",
             "decision_api_key",
+            "agent_type",
+            "agent_config_params",
+            "default_max_steps",
         ]
 
         for key in config_keys:
@@ -637,6 +688,9 @@ class UnifiedConfigManager:
             "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,
         }
 
 

AutoGLM_GUI/device_adapter.py

@@ -0,0 +1,263 @@
+"""Device Protocol Adapter for phone_agent integration.
+
+This module provides an adapter that bridges DeviceProtocol implementations
+to the interface expected by phone_agent's DeviceFactory.
+
+The adapter allows injecting any DeviceProtocol implementation (ADB, Mock, Remote)
+into phone_agent without modifying the third-party code.
+
+Example:
+    >>> from AutoGLM_GUI.device_adapter import inject_device_protocol
+    >>> from AutoGLM_GUI.devices import MockDevice, ADBDevice
+    >>>
+    >>> # For testing: inject mock device
+    >>> mock = MockDevice("mock_001", state_machine)
+    >>> inject_device_protocol(lambda _: mock)
+    >>>
+    >>> # For production: inject ADB device
+    >>> devices = {"phone_1": ADBDevice("emulator-5554")}
+    >>> inject_device_protocol(lambda device_id: devices[device_id])
+"""
+
+from typing import Callable
+
+import phone_agent.device_factory as device_factory_module
+from AutoGLM_GUI.device_protocol import DeviceProtocol, Screenshot
+
+
+class DeviceProtocolAdapter:
+    """
+    Adapter that bridges DeviceProtocol to phone_agent's DeviceFactory interface.
+
+    This adapter wraps a DeviceProtocol getter function and exposes the same
+    interface as phone_agent's DeviceFactory, allowing seamless injection.
+
+    The adapter handles:
+    - Routing device operations to the correct DeviceProtocol instance
+    - Converting between DeviceProtocol and DeviceFactory method signatures
+    - Managing device_id parameters (phone_agent passes device_id to each method)
+    """
+
+    def __init__(
+        self,
+        get_device: Callable[[str | None], DeviceProtocol],
+        default_device_id: str | None = None,
+    ):
+        """
+        Initialize the adapter.
+
+        Args:
+            get_device: Function that returns a DeviceProtocol given a device_id.
+                       If device_id is None, should return a default device.
+            default_device_id: Default device ID to use when None is passed.
+        """
+        self._get_device = get_device
+        self._default_device_id = default_device_id
+        # For compatibility with code that checks device_type
+        self.device_type = "protocol_adapter"
+
+    def _device(self, device_id: str | None) -> DeviceProtocol:
+        """Get device for the given ID."""
+        effective_id = device_id or self._default_device_id
+        return self._get_device(effective_id)
+
+    # === Screenshot ===
+    def get_screenshot(
+        self, device_id: str | None = None, timeout: int = 10
+    ) -> Screenshot:
+        """Get screenshot from device."""
+        return self._device(device_id).get_screenshot(timeout)
+
+    # === Input Operations ===
+    def tap(
+        self, x: int, y: int, device_id: str | None = None, delay: float | None = None
+    ) -> None:
+        """Tap at coordinates."""
+        self._device(device_id).tap(x, y, delay)
+
+    def double_tap(
+        self, x: int, y: int, device_id: str | None = None, delay: float | None = None
+    ) -> None:
+        """Double tap at coordinates."""
+        self._device(device_id).double_tap(x, y, delay)
+
+    def long_press(
+        self,
+        x: int,
+        y: int,
+        duration_ms: int = 3000,
+        device_id: str | None = None,
+        delay: float | None = None,
+    ) -> None:
+        """Long press at coordinates."""
+        self._device(device_id).long_press(x, y, duration_ms, delay)
+
+    def swipe(
+        self,
+        start_x: int,
+        start_y: int,
+        end_x: int,
+        end_y: int,
+        duration_ms: int | None = None,
+        device_id: str | None = None,
+        delay: float | None = None,
+    ) -> None:
+        """Swipe from start to end."""
+        self._device(device_id).swipe(
+            start_x, start_y, end_x, end_y, duration_ms, delay
+        )
+
+    def type_text(self, text: str, device_id: str | None = None) -> None:
+        """Type text."""
+        self._device(device_id).type_text(text)
+
+    def clear_text(self, device_id: str | None = None) -> None:
+        """Clear text."""
+        self._device(device_id).clear_text()
+
+    # === Navigation ===
+    def back(self, device_id: str | None = None, delay: float | None = None) -> None:
+        """Press back button."""
+        self._device(device_id).back(delay)
+
+    def home(self, device_id: str | None = None, delay: float | None = None) -> None:
+        """Press home button."""
+        self._device(device_id).home(delay)
+
+    def launch_app(
+        self, app_name: str, device_id: str | None = None, delay: float | None = None
+    ) -> bool:
+        """Launch an app."""
+        return self._device(device_id).launch_app(app_name, delay)
+
+    # === State Query ===
+    def get_current_app(self, device_id: str | None = None) -> str:
+        """Get current app name."""
+        return self._device(device_id).get_current_app()
+
+    # === Keyboard Management ===
+    def detect_and_set_adb_keyboard(self, device_id: str | None = None) -> str:
+        """Detect and set keyboard."""
+        return self._device(device_id).detect_and_set_adb_keyboard()
+
+    def restore_keyboard(self, ime: str, device_id: str | None = None) -> None:
+        """Restore keyboard."""
+        self._device(device_id).restore_keyboard(ime)
+
+    # === Device Management ===
+    def list_devices(self) -> list[str]:
+        """
+        List connected devices.
+
+        Note: This is a simplified implementation. For full device listing,
+        use ADBDeviceManager.list_devices() directly.
+        """
+        # This is called by some parts of phone_agent
+        # Return the default device if available
+        if self._default_device_id:
+            return [self._default_device_id]
+        return []
+
+    def get_connection_class(self):
+        """Not applicable for protocol adapter."""
+        raise NotImplementedError(
+            "Protocol adapter does not support get_connection_class. "
+            "Use ADBDeviceManager for connection management."
+        )
+
+
+# Store original factory for restoration
+_original_factory = None
+
+
+def inject_device_protocol(
+    get_device: Callable[[str | None], DeviceProtocol],
+    default_device_id: str | None = None,
+) -> DeviceProtocolAdapter:
+    """
+    Inject a DeviceProtocol implementation into phone_agent.
+
+    This replaces phone_agent's global _device_factory with an adapter
+    that routes all device operations through the provided DeviceProtocol.
+
+    Args:
+        get_device: Function that returns a DeviceProtocol given a device_id.
+        default_device_id: Default device ID when None is passed.
+
+    Returns:
+        The adapter instance (for inspection or further configuration).
+
+    Example:
+        >>> # Single mock device
+        >>> mock = MockDevice("mock_001", state_machine)
+        >>> inject_device_protocol(lambda _: mock)
+        >>>
+        >>> # Multiple devices
+        >>> devices = {
+        ...     "phone_1": ADBDevice("emulator-5554"),
+        ...     "phone_2": RemoteDevice("phone_2", "http://remote:8080"),
+        ... }
+        >>> inject_device_protocol(lambda did: devices.get(did, devices["phone_1"]))
+    """
+    # TODO： 不应该依赖这种全部变量
+    global _original_factory
+
+    # Save original factory if not already saved
+    if _original_factory is None:
+        _original_factory = device_factory_module._device_factory
+
+    # Create and inject adapter
+    adapter = DeviceProtocolAdapter(get_device, default_device_id)
+    device_factory_module._device_factory = adapter
+
+    return adapter
+
+
+def restore_device_factory() -> None:
+    """
+    Restore the original device factory.
+
+    Call this after testing to restore normal operation.
+    """
+    global _original_factory
+
+    if _original_factory is not None:
+        device_factory_module._device_factory = _original_factory
+        _original_factory = None
+
+
+class DeviceProtocolContext:
+    """
+    Context manager for temporarily injecting a DeviceProtocol.
+
+    Example:
+        >>> with DeviceProtocolContext(lambda _: mock_device):
+        ...     agent.run("test instruction")
+        >>> # Original factory is automatically restored
+    """
+
+    def __init__(
+        self,
+        get_device: Callable[[str | None], DeviceProtocol],
+        default_device_id: str | None = None,
+    ):
+        """
+        Initialize context.
+
+        Args:
+            get_device: Function that returns a DeviceProtocol given a device_id.
+            default_device_id: Default device ID when None is passed.
+        """
+        self._get_device = get_device
+        self._default_device_id = default_device_id
+        self._original_factory = None
+
+    def __enter__(self) -> DeviceProtocolAdapter:
+        """Enter context and inject adapter."""
+        self._original_factory = device_factory_module._device_factory
+        return inject_device_protocol(self._get_device, self._default_device_id)
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Exit context and restore original factory."""
+        device_factory_module._device_factory = self._original_factory
+        return None

AutoGLM_GUI/device_protocol.py

@@ -0,0 +1,266 @@
+"""Device Protocol - Abstract interface for device operations.
+
+This module defines the protocol (interface) that all device implementations
+must follow. The actual implementation can be:
+- ADB (local subprocess calls)
+- Accessibility Service
+- Remote HTTP/gRPC calls
+- Mock (for testing)
+
+Example:
+    >>> from AutoGLM_GUI.devices import ADBDevice, MockDevice
+    >>>
+    >>> # Production: use ADB
+    >>> device = ADBDevice("emulator-5554")
+    >>> screenshot = device.get_screenshot()
+    >>> device.tap(100, 200)
+    >>>
+    >>> # Testing: use Mock with state machine
+    >>> mock = MockDevice("mock_001", state_machine)
+    >>> screenshot = mock.get_screenshot()  # Returns state machine's screenshot
+"""
+
+from dataclasses import dataclass
+from typing import Protocol, runtime_checkable
+
+
+@dataclass
+class Screenshot:
+    """Screenshot result from device."""
+
+    base64_data: str
+    width: int
+    height: int
+    is_sensitive: bool = False
+
+
+@dataclass
+class DeviceInfo:
+    """Information about a connected device."""
+
+    device_id: str
+    status: str  # "online" | "offline" | "unauthorized"
+    model: str | None = None
+    platform: str = "android"  # "android" | "ios" | "harmonyos"
+    connection_type: str = "usb"  # "usb" | "wifi" | "remote"
+
+
+@runtime_checkable
+class DeviceProtocol(Protocol):
+    """
+    Device operation protocol - all device implementations must follow this interface.
+
+    This protocol abstracts device operations, allowing the control logic to be
+    independent of the actual device implementation (ADB, Accessibility, Remote, etc.).
+
+    The concrete implementation decides HOW to perform operations:
+    - ADBDevice: Uses `adb shell input tap` commands
+    - AccessibilityDevice: Uses Android Accessibility Service
+    - RemoteDevice: Sends HTTP/gRPC requests to a remote agent
+    - MockDevice: Routes operations through a state machine for testing
+    """
+
+    @property
+    def device_id(self) -> str:
+        """Unique device identifier."""
+        ...
+
+    # === Screenshot ===
+    def get_screenshot(self, timeout: int = 10) -> Screenshot:
+        """
+        Capture current screen.
+
+        Args:
+            timeout: Timeout in seconds for the operation.
+
+        Returns:
+            Screenshot object containing base64 data and dimensions.
+        """
+        ...
+
+    # === Input Operations ===
+    def tap(self, x: int, y: int, delay: float | None = None) -> None:
+        """
+        Tap at specified coordinates.
+
+        Args:
+            x: X coordinate.
+            y: Y coordinate.
+            delay: Optional delay after tap in seconds.
+        """
+        ...
+
+    def double_tap(self, x: int, y: int, delay: float | None = None) -> None:
+        """
+        Double tap at specified coordinates.
+
+        Args:
+            x: X coordinate.
+            y: Y coordinate.
+            delay: Optional delay after double tap in seconds.
+        """
+        ...
+
+    def long_press(
+        self, x: int, y: int, duration_ms: int = 3000, delay: float | None = None
+    ) -> None:
+        """
+        Long press at specified coordinates.
+
+        Args:
+            x: X coordinate.
+            y: Y coordinate.
+            duration_ms: Duration of press in milliseconds.
+            delay: Optional delay after long press in seconds.
+        """
+        ...
+
+    def swipe(
+        self,
+        start_x: int,
+        start_y: int,
+        end_x: int,
+        end_y: int,
+        duration_ms: int | None = None,
+        delay: float | None = None,
+    ) -> None:
+        """
+        Swipe from start to end coordinates.
+
+        Args:
+            start_x: Starting X coordinate.
+            start_y: Starting Y coordinate.
+            end_x: Ending X coordinate.
+            end_y: Ending Y coordinate.
+            duration_ms: Duration of swipe in milliseconds.
+            delay: Optional delay after swipe in seconds.
+        """
+        ...
+
+    def type_text(self, text: str) -> None:
+        """
+        Type text into the currently focused input field.
+
+        Args:
+            text: The text to type.
+        """
+        ...
+
+    def clear_text(self) -> None:
+        """Clear text in the currently focused input field."""
+        ...
+
+    # === Navigation ===
+    def back(self, delay: float | None = None) -> None:
+        """
+        Press the back button.
+
+        Args:
+            delay: Optional delay after pressing back in seconds.
+        """
+        ...
+
+    def home(self, delay: float | None = None) -> None:
+        """
+        Press the home button.
+
+        Args:
+            delay: Optional delay after pressing home in seconds.
+        """
+        ...
+
+    def launch_app(self, app_name: str, delay: float | None = None) -> bool:
+        """
+        Launch an app by name.
+
+        Args:
+            app_name: The app name to launch.
+            delay: Optional delay after launching in seconds.
+
+        Returns:
+            True if app was launched successfully, False otherwise.
+        """
+        ...
+
+    # === State Query ===
+    def get_current_app(self) -> str:
+        """
+        Get the currently focused app name.
+
+        Returns:
+            The app name if recognized, otherwise "System Home".
+        """
+        ...
+
+    # === Keyboard Management ===
+    def detect_and_set_adb_keyboard(self) -> str:
+        """
+        Detect current keyboard and switch to ADB Keyboard if needed.
+
+        Returns:
+            The original keyboard IME identifier for later restoration.
+        """
+        ...
+
+    def restore_keyboard(self, ime: str) -> None:
+        """
+        Restore the original keyboard IME.
+
+        Args:
+            ime: The IME identifier to restore.
+        """
+        ...
+
+
+@runtime_checkable
+class DeviceManagerProtocol(Protocol):
+    """Device manager protocol - manages multiple devices."""
+
+    def list_devices(self) -> list[DeviceInfo]:
+        """
+        List all available devices.
+
+        Returns:
+            List of DeviceInfo objects.
+        """
+        ...
+
+    def get_device(self, device_id: str) -> DeviceProtocol:
+        """
+        Get a device instance by ID.
+
+        Args:
+            device_id: The device ID.
+
+        Returns:
+            DeviceProtocol implementation for the device.
+
+        Raises:
+            KeyError: If device not found.
+        """
+        ...
+
+    def connect(self, address: str, timeout: int = 10) -> tuple[bool, str]:
+        """
+        Connect to a remote device.
+
+        Args:
+            address: Device address (e.g., "192.168.1.100:5555").
+            timeout: Connection timeout in seconds.
+
+        Returns:
+            Tuple of (success, message).
+        """
+        ...
+
+    def disconnect(self, device_id: str) -> tuple[bool, str]:
+        """
+        Disconnect from a device.
+
+        Args:
+            device_id: The device ID to disconnect.
+
+        Returns:
+            Tuple of (success, message).
+        """
+        ...