autoglm-gui 0.1.10__py3-none-any.whl → 0.2.2__py3-none-any.whl

{autoglm_gui-0.1.10.dist-info → autoglm_gui-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autoglm-gui
-Version: 0.1.10
+Version: 0.2.2
 Summary: Web GUI for AutoGLM Phone Agent - AI-powered Android automation
 Project-URL: Homepage, https://github.com/suyiiyii/AutoGLM-GUI
 Project-URL: Repository, https://github.com/suyiiyii/AutoGLM-GUI
@@ -22,7 +22,6 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Requires-Dist: fastapi>=0.124.0
 Requires-Dist: openai>=2.9.0
-Requires-Dist: phone-agent
 Requires-Dist: pillow>=11.3.0
 Requires-Dist: uvicorn[standard]>=0.38.0
 Description-Content-Type: text/markdown
@@ -58,7 +57,7 @@ AutoGLM-GUI 只需要一个 OpenAI 兼容的模型服务。你可以：
 - 使用官方已托管的第三方服务
   - 智谱 BigModel：`--base-url https://open.bigmodel.cn/api/paas/v4`，`--model autoglm-phone`，`--apikey <你的 API Key>`
   - ModelScope：`--base-url https://api-inference.modelscope.cn/v1`，`--model ZhipuAI/AutoGLM-Phone-9B`，`--apikey <你的 API Key>`
-- 或自建服务：参考上游项目的部署文档(`/Users/suyiiyii/Documents/git/Open-AutoGLM/README.md` 或仓库 README) 用 vLLM/SGLang 部署 `zai-org/AutoGLM-Phone-9B`，启动 OpenAI 兼容端口后将 `--base-url` 指向你的服务。
+- 或自建服务：参考上游项目的[部署文档](https://github.com/zai-org/Open-AutoGLM/blob/main/README.md)用 vLLM/SGLang 部署 `zai-org/AutoGLM-Phone-9B`，启动 OpenAI 兼容端口后将 `--base-url` 指向你的服务。
 
 示例：
 

autoglm_gui-0.2.2.dist-info/RECORD

@@ -0,0 +1,34 @@
+AutoGLM_GUI/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+AutoGLM_GUI/__main__.py,sha256=jinPYge6MvGaDZPdTZa4rtc7vUx39WZg_x6NXMjOuSs,4917
+AutoGLM_GUI/scrcpy_stream.py,sha256=A6SPQzCWPg2mqVUeLB5WGNnKitYAC7ozEwoojEbJE5o,19800
+AutoGLM_GUI/server.py,sha256=1UN5SN5vsxhi1tbBPHvojzYoIRqRH2rLbn9ZgCMTFMY,14965
+AutoGLM_GUI/adb_plus/__init__.py,sha256=GVRx9G0QG_TxbEQc1FCx8eA2UCPvZeIC4kC3amoQzYk,180
+AutoGLM_GUI/adb_plus/screenshot.py,sha256=TR0ortVd48LZ_evbBUkdnFmS1Us12hbpvUEwkNlUov8,3245
+AutoGLM_GUI/static/index.html,sha256=wrqe9LW08fslYpYXAy2FMV3aGDV3Z8vvKSK1woDgwiE,395
+AutoGLM_GUI/static/assets/about-uuv-AkSr.js,sha256=XGaj-c2munlVOcJCBXPthoRucW4l6BhVkVF3Op7tvuA,155
+AutoGLM_GUI/static/assets/chat-Bl1mU48-.js,sha256=FgFMNOfR29xKS0QDuEaP8Q3XnfY2AxpvPz9ANRglswo,60776
+AutoGLM_GUI/static/assets/index-B6TfcGH7.js,sha256=JO0sAp0nipAYEL2SfWyAqi72RvE0MVIT2p9cLf5_MEA,228
+AutoGLM_GUI/static/assets/index-BCzw2xc6.css,sha256=Zi8sI_VW-X8ZfqbPj7_lOb_9cN7ujq5TnCc5c2VT29M,18094
+AutoGLM_GUI/static/assets/index-BhEqSAe_.js,sha256=mVUo9OKOTSDNuXRBe4RmMoqzu9a51vnFGh4EBPCz1GM,277184
+phone_agent/__init__.py,sha256=6_AwafPDiJsEVstiMcfj-HbvpuxWTC2di6MVbQzHK6s,287
+phone_agent/agent.py,sha256=mvw_nDupyqjCjS8WekI9v11G6IMAOdK8Tx1vbi80Gdk,8124
+phone_agent/actions/__init__.py,sha256=YiAMeBMVhRfmDOf0hQ_1FEBSV5ApcnHPQ05gHjA_weQ,160
+phone_agent/actions/handler.py,sha256=kIz6SxRwxzoGoFgxMzASM-a-qDZsFE6TcieIMtE-yC4,10744
+phone_agent/adb/__init__.py,sha256=w3CBSGRv-cQPME-Q-Bx2tbL_WJkpb9RqmT2olNK9TZw,950
+phone_agent/adb/connection.py,sha256=f5V4IxREo0CedXAmadqCxYJXTskSISXdpjlHXeR9H28,10083
+phone_agent/adb/device.py,sha256=kSkGM0B3QLyZXlec1QfmmLwy85S1kPRp3Yldq93pxPk,5655
+phone_agent/adb/input.py,sha256=d__mISZd7xDCWZLIcWjfJ4EUrpnVKAWNgKo1q7k7n48,2885
+phone_agent/adb/screenshot.py,sha256=9MFOvoAKV0U3H5zjn8mQyqgLWqQwIStxlr_4itFO-cc,3186
+phone_agent/config/__init__.py,sha256=3rrDQhBQUpgAlJe9bJfpuGA3ugzZsLerq06eMVtJIV0,861
+phone_agent/config/apps.py,sha256=3QCp29T73_jFkAubAY6CRW_vlAT_EY7qJ66FFKqCVQo,8773
+phone_agent/config/i18n.py,sha256=2xs1x05ouGRVILGQSgL3UMzi6wu6iqYy3scagAObRXA,2096
+phone_agent/config/prompts.py,sha256=547DMu849nKQKL_PO0TWMgvSaW7Qo_-DV8Hsx2fUWQ4,8091
+phone_agent/config/prompts_en.py,sha256=t8C9YLailtg8kVlFtYvq3t9EdtMGE8HastTfDh5BAUM,2630
+phone_agent/config/prompts_zh.py,sha256=vSWo5_qlWwNHVYUxrePBiL2FmJFnQG0Jpb1NsVsVJos,8256
+phone_agent/model/__init__.py,sha256=w6yFkla9VoUvX5vZkTWa7Z5Bg5_lfA9AajrLjZsdL24,149
+phone_agent/model/client.py,sha256=6EM7BIdj9UvqPG9YmgwSGWVxensH5HDfCSAgHDeBgeo,5842
+autoglm_gui-0.2.2.dist-info/METADATA,sha256=uEeINImNfq60cA7qXSpJkITLU1RYobyOJbs097Y3GU8,4621
+autoglm_gui-0.2.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+autoglm_gui-0.2.2.dist-info/entry_points.txt,sha256=sz4rBO_kgrYmOiT0QnhCCv0b9QqBdWyCjugJgY8AEOI,58
+autoglm_gui-0.2.2.dist-info/licenses/LICENSE,sha256=0IkSHDewdtmXnmYzTNq4U47EJYjTuhjQNpT0bZKuqWc,11342
+autoglm_gui-0.2.2.dist-info/RECORD,,

phone_agent/__init__.py

@@ -0,0 +1,11 @@
+"""
+Phone Agent - An AI-powered phone automation framework.
+
+This package provides tools for automating Android phone interactions
+using AI models for visual understanding and decision making.
+"""
+
+from phone_agent.agent import PhoneAgent
+
+__version__ = "0.1.0"
+__all__ = ["PhoneAgent"]

phone_agent/actions/__init__.py

@@ -0,0 +1,5 @@
+"""Action handling module for Phone Agent."""
+
+from phone_agent.actions.handler import ActionHandler, ActionResult
+
+__all__ = ["ActionHandler", "ActionResult"]

phone_agent/actions/handler.py

@@ -0,0 +1,307 @@
+"""Action handler for processing AI model outputs."""
+
+import time
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from phone_agent.adb import (
+    back,
+    clear_text,
+    detect_and_set_adb_keyboard,
+    double_tap,
+    home,
+    launch_app,
+    long_press,
+    restore_keyboard,
+    swipe,
+    tap,
+    type_text,
+)
+
+
+@dataclass
+class ActionResult:
+    """Result of an action execution."""
+
+    success: bool
+    should_finish: bool
+    message: str | None = None
+    requires_confirmation: bool = False
+
+
+class ActionHandler:
+    """
+    Handles execution of actions from AI model output.
+
+    Args:
+        device_id: Optional ADB device ID for multi-device setups.
+        confirmation_callback: Optional callback for sensitive action confirmation.
+            Should return True to proceed, False to cancel.
+        takeover_callback: Optional callback for takeover requests (login, captcha).
+    """
+
+    def __init__(
+        self,
+        device_id: str | None = None,
+        confirmation_callback: Callable[[str], bool] | None = None,
+        takeover_callback: Callable[[str], None] | None = None,
+    ):
+        self.device_id = device_id
+        self.confirmation_callback = confirmation_callback or self._default_confirmation
+        self.takeover_callback = takeover_callback or self._default_takeover
+
+    def execute(
+        self, action: dict[str, Any], screen_width: int, screen_height: int
+    ) -> ActionResult:
+        """
+        Execute an action from the AI model.
+
+        Args:
+            action: The action dictionary from the model.
+            screen_width: Current screen width in pixels.
+            screen_height: Current screen height in pixels.
+
+        Returns:
+            ActionResult indicating success and whether to finish.
+        """
+        action_type = action.get("_metadata")
+
+        if action_type == "finish":
+            return ActionResult(
+                success=True, should_finish=True, message=action.get("message")
+            )
+
+        if action_type != "do":
+            return ActionResult(
+                success=False,
+                should_finish=True,
+                message=f"Unknown action type: {action_type}",
+            )
+
+        action_name = action.get("action")
+        handler_method = self._get_handler(action_name)
+
+        if handler_method is None:
+            return ActionResult(
+                success=False,
+                should_finish=False,
+                message=f"Unknown action: {action_name}",
+            )
+
+        try:
+            return handler_method(action, screen_width, screen_height)
+        except Exception as e:
+            return ActionResult(
+                success=False, should_finish=False, message=f"Action failed: {e}"
+            )
+
+    def _get_handler(self, action_name: str) -> Callable | None:
+        """Get the handler method for an action."""
+        handlers = {
+            "Launch": self._handle_launch,
+            "Tap": self._handle_tap,
+            "Type": self._handle_type,
+            "Type_Name": self._handle_type,
+            "Swipe": self._handle_swipe,
+            "Back": self._handle_back,
+            "Home": self._handle_home,
+            "Double Tap": self._handle_double_tap,
+            "Long Press": self._handle_long_press,
+            "Wait": self._handle_wait,
+            "Take_over": self._handle_takeover,
+            "Note": self._handle_note,
+            "Call_API": self._handle_call_api,
+            "Interact": self._handle_interact,
+        }
+        return handlers.get(action_name)
+
+    def _convert_relative_to_absolute(
+        self, element: list[int], screen_width: int, screen_height: int
+    ) -> tuple[int, int]:
+        """Convert relative coordinates (0-1000) to absolute pixels."""
+        x = int(element[0] / 1000 * screen_width)
+        y = int(element[1] / 1000 * screen_height)
+        return x, y
+
+    def _handle_launch(self, action: dict, width: int, height: int) -> ActionResult:
+        """Handle app launch action."""
+        app_name = action.get("app")
+        if not app_name:
+            return ActionResult(False, False, "No app name specified")
+
+        success = launch_app(app_name, self.device_id)
+        if success:
+            return ActionResult(True, False)
+        return ActionResult(False, False, f"App not found: {app_name}")
+
+    def _handle_tap(self, action: dict, width: int, height: int) -> ActionResult:
+        """Handle tap action."""
+        element = action.get("element")
+        if not element:
+            return ActionResult(False, False, "No element coordinates")
+
+        x, y = self._convert_relative_to_absolute(element, width, height)
+
+        # Check for sensitive operation
+        if "message" in action:
+            if not self.confirmation_callback(action["message"]):
+                return ActionResult(
+                    success=False,
+                    should_finish=True,
+                    message="User cancelled sensitive operation",
+                )
+
+        tap(x, y, self.device_id)
+        return ActionResult(True, False)
+
+    def _handle_type(self, action: dict, width: int, height: int) -> ActionResult:
+        """Handle text input action."""
+        text = action.get("text", "")
+
+        # Switch to ADB keyboard
+        original_ime = detect_and_set_adb_keyboard(self.device_id)
+        time.sleep(1.0)
+
+        # Clear existing text and type new text
+        clear_text(self.device_id)
+        time.sleep(1.0)
+
+        type_text(text, self.device_id)
+        time.sleep(1.0)
+
+        # Restore original keyboard
+        restore_keyboard(original_ime, self.device_id)
+        time.sleep(1.0)
+
+        return ActionResult(True, False)
+
+    def _handle_swipe(self, action: dict, width: int, height: int) -> ActionResult:
+        """Handle swipe action."""
+        start = action.get("start")
+        end = action.get("end")
+
+        if not start or not end:
+            return ActionResult(False, False, "Missing swipe coordinates")
+
+        start_x, start_y = self._convert_relative_to_absolute(start, width, height)
+        end_x, end_y = self._convert_relative_to_absolute(end, width, height)
+
+        swipe(start_x, start_y, end_x, end_y, device_id=self.device_id)
+        return ActionResult(True, False)
+
+    def _handle_back(self, action: dict, width: int, height: int) -> ActionResult:
+        """Handle back button action."""
+        back(self.device_id)
+        return ActionResult(True, False)
+
+    def _handle_home(self, action: dict, width: int, height: int) -> ActionResult:
+        """Handle home button action."""
+        home(self.device_id)
+        return ActionResult(True, False)
+
+    def _handle_double_tap(self, action: dict, width: int, height: int) -> ActionResult:
+        """Handle double tap action."""
+        element = action.get("element")
+        if not element:
+            return ActionResult(False, False, "No element coordinates")
+
+        x, y = self._convert_relative_to_absolute(element, width, height)
+        double_tap(x, y, self.device_id)
+        return ActionResult(True, False)
+
+    def _handle_long_press(self, action: dict, width: int, height: int) -> ActionResult:
+        """Handle long press action."""
+        element = action.get("element")
+        if not element:
+            return ActionResult(False, False, "No element coordinates")
+
+        x, y = self._convert_relative_to_absolute(element, width, height)
+        long_press(x, y, device_id=self.device_id)
+        return ActionResult(True, False)
+
+    def _handle_wait(self, action: dict, width: int, height: int) -> ActionResult:
+        """Handle wait action."""
+        duration_str = action.get("duration", "1 seconds")
+        try:
+            duration = float(duration_str.replace("seconds", "").strip())
+        except ValueError:
+            duration = 1.0
+
+        time.sleep(duration)
+        return ActionResult(True, False)
+
+    def _handle_takeover(self, action: dict, width: int, height: int) -> ActionResult:
+        """Handle takeover request (login, captcha, etc.)."""
+        message = action.get("message", "User intervention required")
+        self.takeover_callback(message)
+        return ActionResult(True, False)
+
+    def _handle_note(self, action: dict, width: int, height: int) -> ActionResult:
+        """Handle note action (placeholder for content recording)."""
+        # This action is typically used for recording page content
+        # Implementation depends on specific requirements
+        return ActionResult(True, False)
+
+    def _handle_call_api(self, action: dict, width: int, height: int) -> ActionResult:
+        """Handle API call action (placeholder for summarization)."""
+        # This action is typically used for content summarization
+        # Implementation depends on specific requirements
+        return ActionResult(True, False)
+
+    def _handle_interact(self, action: dict, width: int, height: int) -> ActionResult:
+        """Handle interaction request (user choice needed)."""
+        # This action signals that user input is needed
+        return ActionResult(True, False, message="User interaction required")
+
+    @staticmethod
+    def _default_confirmation(message: str) -> bool:
+        """Default confirmation callback using console input."""
+        response = input(f"Sensitive operation: {message}\nConfirm? (Y/N): ")
+        return response.upper() == "Y"
+
+    @staticmethod
+    def _default_takeover(message: str) -> None:
+        """Default takeover callback using console input."""
+        input(f"{message}\nPress Enter after completing manual operation...")
+
+
+def parse_action(response: str) -> dict[str, Any]:
+    """
+    Parse action from model response.
+
+    Args:
+        response: Raw response string from the model.
+
+    Returns:
+        Parsed action dictionary.
+
+    Raises:
+        ValueError: If the response cannot be parsed.
+    """
+    try:
+        # Try to evaluate as Python dict/function call
+        response = response.strip()
+        if response.startswith("do"):
+            action = eval(response)
+        elif response.startswith("finish"):
+            action = {
+                "_metadata": "finish",
+                "message": response.replace("finish(message=", "")[1:-2],
+            }
+        else:
+            raise ValueError(f"Failed to parse action: {response}")
+        return action
+    except Exception as e:
+        raise ValueError(f"Failed to parse action: {e}")
+
+
+def do(**kwargs) -> dict[str, Any]:
+    """Helper function for creating 'do' actions."""
+    kwargs["_metadata"] = "do"
+    return kwargs
+
+
+def finish(**kwargs) -> dict[str, Any]:
+    """Helper function for creating 'finish' actions."""
+    kwargs["_metadata"] = "finish"
+    return kwargs

phone_agent/adb/__init__.py

@@ -0,0 +1,51 @@
+"""ADB utilities for Android device interaction."""
+
+from phone_agent.adb.connection import (
+    ADBConnection,
+    ConnectionType,
+    DeviceInfo,
+    list_devices,
+    quick_connect,
+)
+from phone_agent.adb.device import (
+    back,
+    double_tap,
+    get_current_app,
+    home,
+    launch_app,
+    long_press,
+    swipe,
+    tap,
+)
+from phone_agent.adb.input import (
+    clear_text,
+    detect_and_set_adb_keyboard,
+    restore_keyboard,
+    type_text,
+)
+from phone_agent.adb.screenshot import get_screenshot
+
+__all__ = [
+    # Screenshot
+    "get_screenshot",
+    # Input
+    "type_text",
+    "clear_text",
+    "detect_and_set_adb_keyboard",
+    "restore_keyboard",
+    # Device control
+    "get_current_app",
+    "tap",
+    "swipe",
+    "back",
+    "home",
+    "double_tap",
+    "long_press",
+    "launch_app",
+    # Connection management
+    "ADBConnection",
+    "DeviceInfo",
+    "ConnectionType",
+    "quick_connect",
+    "list_devices",
+]