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

AutoGLM_GUI/api/devices.py

@@ -16,6 +16,18 @@ from AutoGLM_GUI.logger import logger
 from AutoGLM_GUI.schemas import (
     DeviceListResponse,
     DeviceResponse,
+    MdnsDeviceResponse,
+    MdnsDiscoverResponse,
+    QRPairCancelResponse,
+    QRPairGenerateResponse,
+    QRPairStatusResponse,
+    RemoteDeviceAddRequest,
+    RemoteDeviceAddResponse,
+    RemoteDeviceDiscoverRequest,
+    RemoteDeviceDiscoverResponse,
+    RemoteDeviceInfo,
+    RemoteDeviceRemoveRequest,
+    RemoteDeviceRemoveResponse,
     WiFiConnectRequest,
     WiFiConnectResponse,
     WiFiDisconnectRequest,
@@ -24,23 +36,27 @@ from AutoGLM_GUI.schemas import (
     WiFiManualConnectResponse,
     WiFiPairRequest,
     WiFiPairResponse,
-    MdnsDiscoverResponse,
-    MdnsDeviceResponse,
-    QRPairGenerateResponse,
-    QRPairStatusResponse,
-    QRPairCancelResponse,
 )
 
 
 def _build_device_response_with_agent(
     device: "ManagedDevice", agent_manager: "PhoneAgentManager"
 ) -> DeviceResponse:
+    """聚合设备信息和 Agent 状态（API 层职责）.
+
+    API 层负责协调 DeviceManager 和 PhoneAgentManager，
+    通过遍历设备的所有连接来查找已初始化的 Agent。
+    """
+
     response = device.to_dict()
-    agent_device_id = agent_manager.find_agent_by_serial(device.serial)
 
-    if agent_device_id:
-        metadata = agent_manager.get_metadata(agent_device_id)
+    # 遍历设备的所有连接，查找已初始化的 Agent
+    # 使用 device.connections 公开属性（ManagedDevice 提供）
+    for conn in device.connections:
+        # 只调用 PhoneAgentManager 的公开方法
+        metadata = agent_manager.get_metadata(conn.device_id)
         if metadata:
+            # 找到了已初始化的 Agent
             response["agent"] = {
                 "state": metadata.state,  # AgentState is str, Enum, already a string
                 "created_at": metadata.created_at,
@@ -48,9 +64,10 @@ def _build_device_response_with_agent(
                 "error_message": metadata.error_message,
                 "model_name": metadata.model_config.model_name,
             }
-        else:
-            response["agent"] = None
+
+            break  # 找到第一个 Agent 即可退出
     else:
+        # 没有找到任何已初始化的 Agent
         response["agent"] = None
 
     return DeviceResponse.model_validate(response)
@@ -229,7 +246,7 @@ def pair_wifi(request: WiFiPairRequest) -> WiFiPairResponse:
 @router.get("/api/devices/discover_mdns", response_model=MdnsDiscoverResponse)
 def discover_mdns() -> MdnsDiscoverResponse:
     """Discover wireless ADB devices via mDNS."""
-    from phone_agent.adb import ADBConnection
+    from AutoGLM_GUI.adb import ADBConnection
     from AutoGLM_GUI.adb_plus import discover_mdns_devices
 
     try:
@@ -275,7 +292,7 @@ def generate_qr_pairing(timeout: int = 90) -> QRPairGenerateResponse:
         QR code payload and session information
     """
     try:
-        from phone_agent.adb import ADBConnection
+        from AutoGLM_GUI.adb import ADBConnection
 
         conn = ADBConnection()
         session = qr_pairing_manager.create_session(
@@ -364,3 +381,76 @@ def cancel_qr_pairing(session_id: str) -> QRPairCancelResponse:
             success=False,
             message="Session not found or already completed",
         )
+
+
+@router.post(
+    "/api/devices/discover_remote", response_model=RemoteDeviceDiscoverResponse
+)
+def discover_remote_devices(
+    request: RemoteDeviceDiscoverRequest,
+) -> RemoteDeviceDiscoverResponse:
+    """Discover devices from a remote Device Agent Server."""
+    from AutoGLM_GUI.device_manager import DeviceManager
+
+    device_manager = DeviceManager.get_instance()
+    success, message, devices_list = device_manager.discover_remote_devices(
+        base_url=request.base_url,
+        timeout=request.timeout,
+    )
+
+    devices = [RemoteDeviceInfo(**d) for d in devices_list]
+
+    return RemoteDeviceDiscoverResponse(
+        success=success,
+        devices=devices,
+        message=message,
+        error=None if success else message,
+    )
+
+
+@router.post("/api/devices/add_remote", response_model=RemoteDeviceAddResponse)
+def add_remote_device(request: RemoteDeviceAddRequest) -> RemoteDeviceAddResponse:
+    """Add a remote HTTP proxy device manually."""
+    from AutoGLM_GUI.device_manager import DeviceManager
+
+    device_manager = DeviceManager.get_instance()
+    success, message, serial = device_manager.add_remote_device(
+        base_url=request.base_url,
+        device_id=request.device_id,
+    )
+
+    if success:
+        return RemoteDeviceAddResponse(
+            success=True,
+            message=message,
+            serial=serial,
+        )
+    else:
+        error_type = "add_failed"
+        if "already exists" in message.lower():
+            error_type = "already_exists"
+        elif "connection failed" in message.lower():
+            error_type = "connection_failed"
+
+        return RemoteDeviceAddResponse(
+            success=False,
+            message=message,
+            error=error_type,
+        )
+
+
+@router.post("/api/devices/remove_remote", response_model=RemoteDeviceRemoveResponse)
+def remove_remote_device(
+    request: RemoteDeviceRemoveRequest,
+) -> RemoteDeviceRemoveResponse:
+    """Remove a remote device."""
+    from AutoGLM_GUI.device_manager import DeviceManager
+
+    device_manager = DeviceManager.get_instance()
+    success, message = device_manager.remove_remote_device(request.serial)
+
+    return RemoteDeviceRemoveResponse(
+        success=success,
+        message=message,
+        error=None if success else "remove_failed",
+    )

AutoGLM_GUI/api/history.py

@@ -0,0 +1,78 @@
+"""History API routes."""
+
+from fastapi import APIRouter, HTTPException
+
+from AutoGLM_GUI.history_manager import history_manager
+from AutoGLM_GUI.schemas import HistoryListResponse, HistoryRecordResponse
+
+router = APIRouter()
+
+
+@router.get("/api/history/{serialno}", response_model=HistoryListResponse)
+def list_history(
+    serialno: str, limit: int = 50, offset: int = 0
+) -> HistoryListResponse:
+    if limit < 1 or limit > 100:
+        raise HTTPException(status_code=400, detail="limit must be between 1 and 100")
+    if offset < 0:
+        raise HTTPException(status_code=400, detail="offset must be non-negative")
+
+    records = history_manager.list_records(serialno, limit=limit, offset=offset)
+    total = history_manager.get_total_count(serialno)
+
+    return HistoryListResponse(
+        records=[
+            HistoryRecordResponse(
+                id=r.id,
+                task_text=r.task_text,
+                final_message=r.final_message,
+                success=r.success,
+                steps=r.steps,
+                start_time=r.start_time.isoformat(),
+                end_time=r.end_time.isoformat() if r.end_time else None,
+                duration_ms=r.duration_ms,
+                source=r.source,
+                source_detail=r.source_detail,
+                error_message=r.error_message,
+            )
+            for r in records
+        ],
+        total=total,
+        limit=limit,
+        offset=offset,
+    )
+
+
+@router.get("/api/history/{serialno}/{record_id}", response_model=HistoryRecordResponse)
+def get_history_record(serialno: str, record_id: str) -> HistoryRecordResponse:
+    record = history_manager.get_record(serialno, record_id)
+    if not record:
+        raise HTTPException(status_code=404, detail="Record not found")
+
+    return HistoryRecordResponse(
+        id=record.id,
+        task_text=record.task_text,
+        final_message=record.final_message,
+        success=record.success,
+        steps=record.steps,
+        start_time=record.start_time.isoformat(),
+        end_time=record.end_time.isoformat() if record.end_time else None,
+        duration_ms=record.duration_ms,
+        source=record.source,
+        source_detail=record.source_detail,
+        error_message=record.error_message,
+    )
+
+
+@router.delete("/api/history/{serialno}/{record_id}")
+def delete_history_record(serialno: str, record_id: str) -> dict:
+    success = history_manager.delete_record(serialno, record_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Record not found")
+    return {"success": True, "message": "Record deleted"}
+
+
+@router.delete("/api/history/{serialno}")
+def clear_history(serialno: str) -> dict:
+    history_manager.clear_device_history(serialno)
+    return {"success": True, "message": f"History cleared for {serialno}"}

AutoGLM_GUI/api/layered_agent.py

@@ -53,9 +53,20 @@ def _clear_session(session_id: str) -> bool:
 
 
 def get_planner_model() -> str:
-    """获取规划层使用的模型名称，从配置读取."""
-    config = config_manager.get_effective_config()
-    return config.decision_model_name or "glm-4.7"
+    """获取规划层使用的模型名称."""
+    config_manager.load_file_config()
+    effective_config = config_manager.get_effective_config()
+
+    model_name = effective_config.decision_model_name
+
+    if not model_name:
+        raise ValueError(
+            "决策模型未配置。使用分层代理模式需要配置决策模型。\n"
+            "请在全局配置中设置决策模型的 Base URL、模型名称和 API Key。"
+        )
+
+    logger.info(f"[LayeredAgent] Using decision model: {model_name}")
+    return model_name
 
 
 PLANNER_INSTRUCTIONS = """## 核心目标
@@ -282,20 +293,31 @@ async def chat(device_id: str, message: str) -> str:
 
 
 def _setup_openai_client() -> AsyncOpenAI:
-    """设置 OpenAI 客户端，使用 AutoGLM 的配置"""
+    """设置 OpenAI 客户端，使用决策模型配置"""
     config_manager.load_file_config()
     effective_config = config_manager.get_effective_config()
 
-    if not effective_config.base_url:
-        raise ValueError("base_url not configured")
+    # 检查决策模型配置
+    decision_base_url = effective_config.decision_base_url
+    decision_api_key = effective_config.decision_api_key
 
-    planner_model = get_planner_model()
-    logger.info(f"[LayeredAgent] API Base URL: {effective_config.base_url}")
-    logger.info(f"[LayeredAgent] Planner Model: {planner_model}")
+    if not decision_base_url:
+        raise ValueError(
+            "决策模型 Base URL 未配置。使用分层代理模式需要配置决策模型。\n"
+            "请在全局配置中设置决策模型的 Base URL、模型名称和 API Key。"
+        )
+
+    # decision_api_key 可以为 None（某些本地模型不需要）
+    planner_model = get_planner_model()  # 这里会再次检查 model_name
+
+    logger.info("[LayeredAgent] Decision model config:")
+    logger.info(f"  - Base URL: {decision_base_url}")
+    logger.info(f"  - Model: {planner_model}")
+    logger.info(f"  - API Key: {'***' if decision_api_key else 'None'}")
 
     return AsyncOpenAI(
-        base_url=effective_config.base_url,
-        api_key=effective_config.api_key,
+        base_url=decision_base_url,
+        api_key=decision_api_key or "EMPTY",  # 某些本地模型需要非空字符串
     )
 
 
@@ -375,18 +397,24 @@ async def layered_agent_chat(request: LayeredAgentRequest):
     - done: Final response
     - error: Error occurred
     """
+    from datetime import datetime
+
     from agents.stream_events import (
         RawResponsesStreamEvent,
         RunItemStreamEvent,
     )
 
+    from AutoGLM_GUI.history_manager import history_manager
+    from AutoGLM_GUI.models.history import ConversationRecord
+
     async def event_generator():
+        start_time = datetime.now()
+        final_output = ""
+        final_success = False
+
         try:
-            # Ensure agent is initialized
             agent = _ensure_agent()
 
-            # 获取或创建 session 以保持对话上下文
-            # 优先使用 session_id，其次使用 device_id，最后使用默认值
             session_id = request.session_id or request.device_id or "default"
             session = _get_or_create_session(session_id)
 
@@ -574,10 +602,10 @@ async def layered_agent_chat(request: LayeredAgentRequest):
                 with _active_runs_lock:
                     _active_runs.pop(session_id, None)
 
-            # Final result
             final_output = (
                 result.final_output if hasattr(result, "final_output") else ""
             )
+            final_success = True
             event_data = {
                 "type": "done",
                 "content": final_output,
@@ -587,12 +615,36 @@ async def layered_agent_chat(request: LayeredAgentRequest):
 
         except Exception as e:
             logger.exception(f"[LayeredAgent] Error: {e}")
+            final_output = str(e)
+            final_success = False
             event_data = {
                 "type": "error",
                 "message": str(e),
             }
             yield f"data: {json.dumps(event_data, ensure_ascii=False)}\n\n"
 
+        finally:
+            if request.device_id and final_output:
+                from AutoGLM_GUI.device_manager import DeviceManager
+
+                device_manager = DeviceManager.get_instance()
+                serialno = device_manager.get_serial_by_device_id(request.device_id)
+                if serialno:
+                    end_time = datetime.now()
+                    record = ConversationRecord(
+                        task_text=request.message,
+                        final_message=final_output,
+                        success=final_success,
+                        steps=0,
+                        start_time=start_time,
+                        end_time=end_time,
+                        duration_ms=int((end_time - start_time).total_seconds() * 1000),
+                        source="layered",
+                        source_detail=request.session_id or "",
+                        error_message=None if final_success else final_output,
+                    )
+                    history_manager.add_record(serialno, record)
+
     return StreamingResponse(
         event_generator(),
         media_type="text/event-stream",

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/config.py

@@ -0,0 +1,81 @@
+"""AutoGLM-GUI 核心配置定义
+
+这个模块定义了项目自己的配置类，替代 phone_agent 的配置，
+实现配置层的解耦和扩展性。
+
+设计原则:
+- 配置类提供 AutoGLM-GUI 核心业务逻辑所需的参数
+- 避免在 API 层和业务层直接使用外部库的类型
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class ModelConfig:
+    """模型配置
+
+    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"
+
+
+@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: 结果消息 (可选)
+    """
+
+    success: bool
+    finished: bool
+    action: dict[str, Any] | None
+    thinking: str
+    message: str | None = None