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

AutoGLM_GUI/api/media.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from fastapi import APIRouter
 
 from AutoGLM_GUI.adb_plus import capture_screenshot
+from AutoGLM_GUI.exceptions import DeviceNotAvailableError
 from AutoGLM_GUI.logger import logger
 from AutoGLM_GUI.schemas import ScreenshotRequest, ScreenshotResponse
 from AutoGLM_GUI.socketio_server import stop_streamers
@@ -29,8 +30,59 @@ async def reset_video_stream(device_id: str | None = None) -> dict:
 @router.post("/api/screenshot", response_model=ScreenshotResponse)
 def take_screenshot(request: ScreenshotRequest) -> ScreenshotResponse:
     """获取设备截图。此操作无副作用，不影响 PhoneAgent 运行。"""
+    from AutoGLM_GUI.device_manager import DeviceManager
+
     try:
-        screenshot = capture_screenshot(device_id=request.device_id)
+        device_id = request.device_id
+
+        if not device_id:
+            return ScreenshotResponse(
+                success=False,
+                image="",
+                width=0,
+                height=0,
+                is_sensitive=False,
+                error="device_id is required",
+            )
+
+        device_manager = DeviceManager.get_instance()
+        serial = device_manager.get_serial_by_device_id(device_id)
+
+        if not serial:
+            return ScreenshotResponse(
+                success=False,
+                image="",
+                width=0,
+                height=0,
+                is_sensitive=False,
+                error=f"Device {device_id} not found",
+            )
+
+        if serial:
+            managed = device_manager._devices.get(serial)
+            if managed and managed.connection_type.value == "remote":
+                remote_device = device_manager.get_remote_device_instance(serial)
+
+                if not remote_device:
+                    return ScreenshotResponse(
+                        success=False,
+                        image="",
+                        width=0,
+                        height=0,
+                        is_sensitive=False,
+                        error=f"Remote device {serial} not found",
+                    )
+
+                screenshot = remote_device.get_screenshot(timeout=10)  # type: ignore
+                return ScreenshotResponse(
+                    success=True,
+                    image=screenshot.base64_data,
+                    width=screenshot.width,
+                    height=screenshot.height,
+                    is_sensitive=screenshot.is_sensitive,
+                )
+
+        screenshot = capture_screenshot(device_id=device_id)
         return ScreenshotResponse(
             success=True,
             image=screenshot.base64_data,
@@ -38,7 +90,18 @@ def take_screenshot(request: ScreenshotRequest) -> ScreenshotResponse:
             height=screenshot.height,
             is_sensitive=screenshot.is_sensitive,
         )
+    except DeviceNotAvailableError as e:
+        logger.warning("Screenshot failed - device not available: %s", e)
+        return ScreenshotResponse(
+            success=False,
+            image="",
+            width=0,
+            height=0,
+            is_sensitive=False,
+            error=str(e),
+        )
     except Exception as e:
+        logger.exception("Screenshot failed for device %s", request.device_id)
         return ScreenshotResponse(
             success=False,
             image="",

AutoGLM_GUI/api/scheduled_tasks.py

@@ -0,0 +1,98 @@
+"""Scheduled tasks API routes."""
+
+from fastapi import APIRouter, HTTPException
+
+from AutoGLM_GUI.scheduler_manager import scheduler_manager
+from AutoGLM_GUI.schemas import (
+    ScheduledTaskCreate,
+    ScheduledTaskListResponse,
+    ScheduledTaskResponse,
+    ScheduledTaskUpdate,
+)
+
+router = APIRouter()
+
+
+def _task_to_response(task) -> ScheduledTaskResponse:
+    next_run = scheduler_manager.get_next_run_time(task.id)
+    return ScheduledTaskResponse(
+        id=task.id,
+        name=task.name,
+        workflow_uuid=task.workflow_uuid,
+        device_serialno=task.device_serialno,
+        cron_expression=task.cron_expression,
+        enabled=task.enabled,
+        created_at=task.created_at.isoformat(),
+        updated_at=task.updated_at.isoformat(),
+        last_run_time=task.last_run_time.isoformat() if task.last_run_time else None,
+        last_run_success=task.last_run_success,
+        last_run_message=task.last_run_message,
+        next_run_time=next_run.isoformat() if next_run else None,
+    )
+
+
+@router.get("/api/scheduled-tasks", response_model=ScheduledTaskListResponse)
+def list_scheduled_tasks() -> ScheduledTaskListResponse:
+    tasks = scheduler_manager.list_tasks()
+    return ScheduledTaskListResponse(tasks=[_task_to_response(t) for t in tasks])
+
+
+@router.post("/api/scheduled-tasks", response_model=ScheduledTaskResponse)
+def create_scheduled_task(request: ScheduledTaskCreate) -> ScheduledTaskResponse:
+    from AutoGLM_GUI.workflow_manager import workflow_manager
+
+    workflow = workflow_manager.get_workflow(request.workflow_uuid)
+    if not workflow:
+        raise HTTPException(status_code=400, detail="Workflow not found")
+
+    task = scheduler_manager.create_task(
+        name=request.name,
+        workflow_uuid=request.workflow_uuid,
+        device_serialno=request.device_serialno,
+        cron_expression=request.cron_expression,
+        enabled=request.enabled,
+    )
+    return _task_to_response(task)
+
+
+@router.get("/api/scheduled-tasks/{task_id}", response_model=ScheduledTaskResponse)
+def get_scheduled_task(task_id: str) -> ScheduledTaskResponse:
+    task = scheduler_manager.get_task(task_id)
+    if not task:
+        raise HTTPException(status_code=404, detail="Task not found")
+    return _task_to_response(task)
+
+
+@router.put("/api/scheduled-tasks/{task_id}", response_model=ScheduledTaskResponse)
+def update_scheduled_task(
+    task_id: str, request: ScheduledTaskUpdate
+) -> ScheduledTaskResponse:
+    update_data = request.model_dump(exclude_unset=True)
+    task = scheduler_manager.update_task(task_id, **update_data)
+    if not task:
+        raise HTTPException(status_code=404, detail="Task not found")
+    return _task_to_response(task)
+
+
+@router.delete("/api/scheduled-tasks/{task_id}")
+def delete_scheduled_task(task_id: str) -> dict:
+    success = scheduler_manager.delete_task(task_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Task not found")
+    return {"success": True, "message": "Task deleted"}
+
+
+@router.post("/api/scheduled-tasks/{task_id}/enable")
+def enable_scheduled_task(task_id: str) -> dict:
+    success = scheduler_manager.set_enabled(task_id, True)
+    if not success:
+        raise HTTPException(status_code=404, detail="Task not found")
+    return {"success": True, "message": "Task enabled"}
+
+
+@router.post("/api/scheduled-tasks/{task_id}/disable")
+def disable_scheduled_task(task_id: str) -> dict:
+    success = scheduler_manager.set_enabled(task_id, False)
+    if not success:
+        raise HTTPException(status_code=404, detail="Task not found")
+    return {"success": True, "message": "Task disabled"}

AutoGLM_GUI/api/version.py

@@ -3,8 +3,9 @@
 import json
 import re
 import time
+import urllib.error
 import urllib.request
-from typing import Any
+from typing_extensions import TypedDict
 
 from fastapi import APIRouter
 
@@ -12,13 +13,30 @@ from AutoGLM_GUI.logger import logger
 from AutoGLM_GUI.schemas import VersionCheckResponse
 from AutoGLM_GUI.version import APP_VERSION
 
+
+class GitHubRelease(TypedDict, total=False):
+    """GitHub Release API response structure."""
+
+    tag_name: str
+    html_url: str
+    published_at: str
+
+
+class _VersionCache(TypedDict):
+    """Internal cache structure for version checking."""
+
+    data: VersionCheckResponse | None
+    timestamp: float
+    ttl: int
+
+
 router = APIRouter()
 
 # In-memory cache for version check results
-_version_cache: dict[str, Any] = {
+_version_cache: _VersionCache = {
     "data": None,
     "timestamp": 0,
-    "ttl": 3600,  # 1 hour cache TTL
+    "ttl": 3600,
 }
 
 # GitHub repository information
@@ -74,13 +92,8 @@ def compare_versions(current: str, latest: str) -> bool:
     return latest_tuple > current_tuple
 
 
-def fetch_latest_release() -> dict[str, Any] | None:
-    """
-    Fetch latest release information from GitHub API.
-
-    Returns:
-        Release data dict with 'tag_name', 'html_url', 'published_at' or None on error
-    """
+def fetch_latest_release() -> GitHubRelease | None:
+    """Fetch latest release information from GitHub API."""
     try:
         # Create request with User-Agent header (required by GitHub API)
         req = urllib.request.Request(

AutoGLM_GUI/api/workflows.py

@@ -17,7 +17,8 @@ def list_workflows() -> WorkflowListResponse:
     """获取所有 workflows."""
     from AutoGLM_GUI.workflow_manager import workflow_manager
 
-    workflows = workflow_manager.list_workflows()
+    workflow_dicts = workflow_manager.list_workflows()
+    workflows = [WorkflowResponse(**wf) for wf in workflow_dicts]
     return WorkflowListResponse(workflows=workflows)
 
 

AutoGLM_GUI/config.py

@@ -1,23 +1,81 @@
-"""Application configuration singleton."""
+"""AutoGLM-GUI 核心配置定义
 
-import os
-from dataclasses import dataclass
+这个模块定义了项目自己的配置类，替代 phone_agent 的配置，
+实现配置层的解耦和扩展性。
+
+设计原则:
+- 配置类提供 AutoGLM-GUI 核心业务逻辑所需的参数
+- 避免在 API 层和业务层直接使用外部库的类型
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
 
 
 @dataclass
-class AppConfig:
-    """Global application configuration."""
+class ModelConfig:
+    """模型配置
 
-    base_url: str = ""
-    model_name: str = "autoglm-phone-9b"
+    OpenAI 兼容 API 的配置参数。
+
+    Attributes:
+        base_url: API 端点 URL (例如: "http://localhost:8000/v1")
+        api_key: API 认证密钥 (本地部署可选)
+        model_name: 模型标识符 (例如: "autoglm-phone-9b")
+        max_tokens: 响应最大 token 数 (默认: 3000)
+        temperature: 采样温度 0-1 (默认: 0.0)
+        top_p: Nucleus 采样阈值 (默认: 0.85)
+        frequency_penalty: 频率惩罚 -2 到 2 (默认: 0.2)
+        extra_body: 特定后端的额外参数
+        lang: UI 消息语言: 'cn' 或 'en'
+    """
+
+    base_url: str = "http://localhost:8000/v1"
     api_key: str = "EMPTY"
+    model_name: str = "autoglm-phone-9b"
+    max_tokens: int = 3000
+    temperature: float = 0.0
+    top_p: float = 0.85
+    frequency_penalty: float = 0.2
+    extra_body: dict[str, Any] = field(default_factory=dict)
+    lang: str = "cn"
+
 
-    def refresh_from_env(self):
-        """从环境变量刷新配置（适用于 reload 模式）"""
-        self.base_url = os.getenv("AUTOGLM_BASE_URL", self.base_url)
-        self.model_name = os.getenv("AUTOGLM_MODEL_NAME", self.model_name)
-        self.api_key = os.getenv("AUTOGLM_API_KEY", self.api_key)
+@dataclass
+class AgentConfig:
+    """Agent 配置
+
+    控制 Agent 的行为参数。
+
+    Attributes:
+        max_steps: 单次任务最大执行步数 (默认: 100)
+        device_id: 设备标识符 (USB serial 或 IP:port)
+        lang: 语言设置 'cn' 或 'en'
+        system_prompt: 自定义系统提示词 (None 则使用默认)
+        verbose: 是否输出详细日志
+    """
+
+    max_steps: int = 100
+    device_id: str | None = None
+    lang: str = "cn"
+    system_prompt: str | None = None
+    verbose: bool = True
+
+
+@dataclass
+class StepResult:
+    """Agent 单步执行结果
 
+    Attributes:
+        success: 本步骤是否执行成功
+        finished: 整个任务是否已完成
+        action: 执行的动作字典 (包含 action type 和参数)
+        thinking: Agent 的思考过程
+        message: 结果消息 (可选)
+    """
 
-# Global singleton instance
-config = AppConfig()
+    success: bool
+    finished: bool
+    action: dict[str, Any] | None
+    thinking: str
+    message: str | None = None

AutoGLM_GUI/config_manager.py

@@ -52,11 +52,27 @@ 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
+
+    # 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:
+        """验证 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
@@ -76,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
 
 
 # ==================== 配置层数据类 ====================
@@ -93,8 +121,12 @@ class ConfigLayer:
     base_url: Optional[str] = None
     model_name: Optional[str] = None
     api_key: Optional[str] = None
-    # 双模型配置
-    dual_model_enabled: Optional[bool] = 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
@@ -125,7 +157,9 @@ class ConfigLayer:
                 "base_url": self.base_url,
                 "model_name": self.model_name,
                 "api_key": self.api_key,
-                "dual_model_enabled": self.dual_model_enabled,
+                "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,
@@ -188,6 +222,12 @@ class UnifiedConfigManager:
             base_url="",
             model_name="autoglm-phone-9b",
             api_key="EMPTY",
+            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,
         )
 
@@ -234,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  # 清除缓存
@@ -296,7 +347,11 @@ 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"),
+                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"),
@@ -327,7 +382,9 @@ class UnifiedConfigManager:
         base_url: str,
         model_name: str,
         api_key: Optional[str] = None,
-        dual_model_enabled: Optional[bool] = 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,
@@ -340,10 +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:
@@ -354,20 +413,26 @@ 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,
             }
 
             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:
+            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 decision_base_url is not None:
                 new_config["decision_base_url"] = decision_base_url
-            if decision_model_name:
+            if decision_model_name is not None:
                 new_config["decision_model_name"] = decision_model_name
-            if decision_api_key:
+            if decision_api_key is not None:
                 new_config["decision_api_key"] = decision_api_key
 
             # 合并模式：保留现有文件中未提供的字段
@@ -379,7 +444,9 @@ class UnifiedConfigManager:
                     # 保留未提供的字段
                     preserve_keys = [
                         "api_key",
-                        "dual_model_enabled",
+                        "agent_type",
+                        "agent_config_params",
+                        "default_max_steps",
                         "decision_base_url",
                         "decision_model_name",
                         "decision_api_key",
@@ -467,7 +534,9 @@ class UnifiedConfigManager:
             "base_url",
             "model_name",
             "api_key",
-            "dual_model_enabled",
+            "agent_type",
+            "agent_config_params",
+            "default_max_steps",
             "decision_base_url",
             "decision_model_name",
             "decision_api_key",
@@ -633,7 +702,9 @@ class UnifiedConfigManager:
             "base_url": config.base_url,
             "model_name": config.model_name,
             "api_key": config.api_key,
-            "dual_model_enabled": config.dual_model_enabled,
+            "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,