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

AutoGLM_GUI/api/__init__.py

@@ -1,6 +1,7 @@
 """FastAPI application factory and route registration."""
 
 import asyncio
+import os
 import sys
 from contextlib import asynccontextmanager
 from importlib.resources import files
@@ -12,6 +13,7 @@ from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
 
 from AutoGLM_GUI.adb_plus.qr_pair import qr_pairing_manager
+from AutoGLM_GUI.logger import logger
 from AutoGLM_GUI.version import APP_VERSION
 
 from . import (
@@ -19,6 +21,8 @@ from . import (
     control,
     devices,
     dual_model,
+    health,
+    layered_agent,
     mcp,
     media,
     metrics,
@@ -27,11 +31,30 @@ from . import (
 )
 
 
+# TODO：应该要支持运行时动态切换设备
+def _maybe_inject_remote_device() -> None:
+    if remote_base_url := os.getenv("REMOTE_DEVICE_BASE_URL"):
+        from AutoGLM_GUI.device_adapter import inject_device_protocol
+        from AutoGLM_GUI.devices.remote_device import RemoteDevice
+
+        def get_remote_device(device_id: str | None):
+            return RemoteDevice(device_id or "mock_device_001", remote_base_url)
+
+        inject_device_protocol(get_remote_device)
+        logger.info(f"Remote device mode enabled: connecting to {remote_base_url}")
+
+
+def _get_cors_origins() -> list[str]:
+    cors_origins_str = os.getenv("AUTOGLM_CORS_ORIGINS", "http://localhost:3000")
+    if cors_origins_str == "*":
+        return ["*"]
+    return [origin.strip() for origin in cors_origins_str.split(",") if origin.strip()]
+
+
 def _get_static_dir() -> Path | None:
-    """Locate packaged static assets."""
-    # Priority 1: PyInstaller bundled path (for packaged executable)
-    if getattr(sys, "_MEIPASS", None):
-        bundled_static = Path(sys._MEIPASS) / "AutoGLM_GUI" / "static"
+    meipass = getattr(sys, "_MEIPASS", None)
+    if meipass:
+        bundled_static = Path(meipass) / "AutoGLM_GUI" / "static"
         if bundled_static.exists():
             return bundled_static
 
@@ -54,6 +77,9 @@ def _get_static_dir() -> Path | None:
 def create_app() -> FastAPI:
     """Build the FastAPI app with routers and static assets."""
 
+    # Inject RemoteDevice if REMOTE_DEVICE_BASE_URL is set
+    _maybe_inject_remote_device()
+
     # Create MCP ASGI app
     mcp_app = mcp.get_mcp_asgi_app()
 
@@ -82,13 +108,15 @@ def create_app() -> FastAPI:
 
     app.add_middleware(
         CORSMiddleware,
-        allow_origins=["http://localhost:3000"],
+        allow_origins=_get_cors_origins(),
         allow_credentials=True,
         allow_methods=["*"],
         allow_headers=["*"],
     )
 
     app.include_router(agents.router)
+    app.include_router(health.router)
+    app.include_router(layered_agent.router)
     app.include_router(devices.router)
     app.include_router(control.router)
     app.include_router(media.router)
@@ -104,14 +132,29 @@ def create_app() -> FastAPI:
     if static_dir is not None and static_dir.exists():
         assets_dir = static_dir / "assets"
         if assets_dir.exists():
+            # Vite builds assets with content hashes, so we can cache them long-term
             app.mount("/assets", StaticFiles(directory=assets_dir), name="assets")
 
         # Define SPA serving function
         async def serve_spa(full_path: str) -> FileResponse:
             file_path = static_dir / full_path
             if file_path.is_file():
-                return FileResponse(file_path)
-            return FileResponse(static_dir / "index.html")
+                return FileResponse(
+                    file_path,
+                    headers={
+                        "Cache-Control": "no-cache, no-store, must-revalidate",
+                        "Pragma": "no-cache",
+                        "Expires": "0",
+                    },
+                )
+            return FileResponse(
+                static_dir / "index.html",
+                headers={
+                    "Cache-Control": "no-cache, no-store, must-revalidate",
+                    "Pragma": "no-cache",
+                    "Expires": "0",
+                },
+            )
 
         # Add catch-all route for SPA (handles all non-API routes)
         app.add_api_route(

AutoGLM_GUI/api/agents.py

@@ -3,13 +3,12 @@
 import json
 import queue
 import threading
-from typing import Any
 
 from fastapi import APIRouter, HTTPException
 from fastapi.responses import StreamingResponse
+from phone_agent.agent import StepResult
 from pydantic import ValidationError
 
-from AutoGLM_GUI.config import config
 from AutoGLM_GUI.logger import logger
 from AutoGLM_GUI.phone_agent_patches import apply_patches
 from AutoGLM_GUI.schemas import (
@@ -91,9 +90,12 @@ def _initialize_agent_with_config(
     logger.info(f"Agent initialized successfully for device {device_id}")
 
 
+SSEPayload = dict[str, str | int | bool | None | dict]
+
+
 def _create_sse_event(
-    event_type: str, data: dict[str, Any], role: str = "assistant"
-) -> dict[str, Any]:
+    event_type: str, data: SSEPayload, role: str = "assistant"
+) -> SSEPayload:
     """Create an SSE event with standardized fields including role."""
     event_data = {"type": event_type, "role": role, **data}
     return event_data
@@ -116,11 +118,17 @@ def init_agent(request: InitRequest) -> dict:
     # 热重载配置文件（支持运行时手动修改）
     config_manager.load_file_config()
     config_manager.sync_to_env()
-    config.refresh_from_env()
 
-    base_url = req_model_config.base_url or config.base_url
-    api_key = req_model_config.api_key or config.api_key
-    model_name = req_model_config.model_name or config.model_name
+    # 获取有效配置（已合并 CLI > ENV > FILE > DEFAULT）
+    effective_config = config_manager.get_effective_config()
+
+    # 优先级：请求参数 > 有效配置
+    base_url = req_model_config.base_url or effective_config.base_url
+    api_key = req_model_config.api_key or effective_config.api_key
+    model_name = req_model_config.model_name or effective_config.model_name
+
+    # 获取配置的默认最大步数
+    max_steps = effective_config.default_max_steps
 
     if not base_url:
         raise HTTPException(
@@ -139,7 +147,7 @@ def init_agent(request: InitRequest) -> dict:
     )
 
     agent_config = AgentConfig(
-        max_steps=req_agent_config.max_steps,
+        max_steps=max_steps,
         device_id=device_id,
         lang=req_agent_config.lang,
         system_prompt=req_agent_config.system_prompt,
@@ -148,7 +156,35 @@ def init_agent(request: InitRequest) -> dict:
 
     # Initialize agent (includes ADB Keyboard setup)
     try:
-        _initialize_agent_with_config(device_id, model_config, agent_config)
+        # Setup ADB Keyboard (common for all agents)
+        _setup_adb_keyboard(device_id)
+
+        # Use agent factory to create agent
+        from AutoGLM_GUI.phone_agent_manager import PhoneAgentManager
+
+        manager = PhoneAgentManager.get_instance()
+
+        # Initialize agent using factory pattern
+        from typing import cast
+
+        from AutoGLM_GUI.types import AgentSpecificConfig
+
+        agent_config_params = cast(
+            AgentSpecificConfig, request.agent_config_params or {}
+        )
+        manager.initialize_agent_with_factory(
+            device_id=device_id,
+            agent_type=request.agent_type,
+            model_config=model_config,
+            agent_config=agent_config,
+            agent_specific_config=agent_config_params,
+            takeover_callback=non_blocking_takeover,
+            force=request.force,
+        )
+
+        logger.info(
+            f"Agent of type '{request.agent_type}' initialized for device {device_id}"
+        )
     except Exception as e:
         logger.error(f"Failed to initialize agent: {e}")
         raise HTTPException(status_code=500, detail=str(e))
@@ -157,6 +193,7 @@ def init_agent(request: InitRequest) -> dict:
         "success": True,
         "device_id": device_id,
         "message": f"Agent initialized for device {device_id}",
+        "agent_type": request.agent_type,
     }
 
 
@@ -207,12 +244,12 @@ def chat_stream(request: ChatRequest):
         )
 
     def event_generator():
-        """SSE 事件生成器."""
         threads: list[threading.Thread] = []
+        stop_event: threading.Event | None = None
 
         try:
             # 创建事件队列用于 agent → SSE 通信
-            event_queue: queue.Queue[tuple[str, Any]] = queue.Queue()
+            event_queue: queue.Queue[tuple[str, SSEPayload | None]] = queue.Queue()
 
             # 思考块回调
             def on_thinking_chunk(chunk: str):
@@ -231,8 +268,8 @@ def chat_stream(request: ChatRequest):
                     return
 
                 # 在线程中运行 agent 步骤
-                step_result: list[Any] = [None]
-                error_result: list[Any] = [None]
+                step_result: list[StepResult | None] = [None]
+                error_result: list[Exception | None] = [None]
 
                 def run_step(is_first: bool = True, task: str | None = None):
                     try:
@@ -277,6 +314,9 @@ def chat_stream(request: ChatRequest):
                             raise error_result[0]
 
                         result = step_result[0]
+                        if result is None:
+                            raise RuntimeError("step_result is None after step_done")
+
                         event_data = _create_sse_event(
                             "step",
                             {
@@ -349,8 +389,7 @@ def chat_stream(request: ChatRequest):
             yield "event: error\n"
             yield f"data: {json.dumps(error_data, ensure_ascii=False)}\n\n"
         finally:
-            # 通知线程停止
-            if "stop_event" in locals():
+            if stop_event is not None:
                 stop_event.set()
 
             # 等待线程完成（带超时）
@@ -460,7 +499,9 @@ def get_config_endpoint() -> ConfigResponse:
         decision_api_key=effective_config.decision_api_key
         if effective_config.decision_api_key
         else "",
-        thinking_mode=effective_config.thinking_mode,
+        agent_type=effective_config.agent_type,
+        agent_config_params=effective_config.agent_config_params,
+        default_max_steps=effective_config.default_max_steps,
         conflicts=[
             {
                 "field": c.field,
@@ -497,7 +538,9 @@ def save_config_endpoint(request: ConfigSaveRequest) -> dict:
             decision_base_url=request.decision_base_url,
             decision_model_name=request.decision_model_name,
             decision_api_key=request.decision_api_key,
-            thinking_mode=request.thinking_mode,
+            agent_type=request.agent_type,
+            agent_config_params=request.agent_config_params,
+            default_max_steps=request.default_max_steps,
             merge_mode=True,
         )
 
@@ -506,7 +549,6 @@ def save_config_endpoint(request: ConfigSaveRequest) -> dict:
 
         # 同步到环境变量
         config_manager.sync_to_env()
-        config.refresh_from_env()
 
         # 检测冲突并返回警告
         conflicts = config_manager.detect_conflicts()

AutoGLM_GUI/api/devices.py

@@ -15,6 +15,7 @@ from AutoGLM_GUI.logger import logger
 
 from AutoGLM_GUI.schemas import (
     DeviceListResponse,
+    DeviceResponse,
     WiFiConnectRequest,
     WiFiConnectResponse,
     WiFiDisconnectRequest,
@@ -32,29 +33,16 @@ from AutoGLM_GUI.schemas import (
 
 
 def _build_device_response_with_agent(
-    device: ManagedDevice, agent_manager: PhoneAgentManager
-) -> dict:
-    """组合设备信息和 Agent 状态（API 层职责）。
-
-    Args:
-        device: ManagedDevice 实例
-        agent_manager: PhoneAgentManager 实例
-
-    Returns:
-        dict: 完整的设备响应，匹配 DeviceResponse schema
-    """
-    # 获取纯设备信息
+    device: "ManagedDevice", agent_manager: "PhoneAgentManager"
+) -> DeviceResponse:
     response = device.to_dict()
-
-    # 通过 serial 查找 Agent（支持连接切换）
     agent_device_id = agent_manager.find_agent_by_serial(device.serial)
 
     if agent_device_id:
         metadata = agent_manager.get_metadata(agent_device_id)
-
         if metadata:
             response["agent"] = {
-                "state": metadata.state.value,
+                "state": metadata.state,  # AgentState is str, Enum, already a string
                 "created_at": metadata.created_at,
                 "last_used": metadata.last_used,
                 "error_message": metadata.error_message,
@@ -65,7 +53,7 @@ def _build_device_response_with_agent(
     else:
         response["agent"] = None
 
-    return response
+    return DeviceResponse.model_validate(response)
 
 
 router = APIRouter()
@@ -97,9 +85,15 @@ def list_devices() -> DeviceListResponse:
 
 @router.post("/api/devices/connect_wifi", response_model=WiFiConnectResponse)
 def connect_wifi(request: WiFiConnectRequest) -> WiFiConnectResponse:
-    """从 USB 启用 TCP/IP 并连接到 WiFi。"""
     from AutoGLM_GUI.device_manager import DeviceManager
 
+    if not request.device_id:
+        return WiFiConnectResponse(
+            success=False,
+            message="device_id is required",
+            error="device_not_found",
+        )
+
     device_manager = DeviceManager.get_instance()
     success, message, wifi_id = device_manager.connect_wifi(
         device_id=request.device_id,

AutoGLM_GUI/api/dual_model.py

@@ -1,7 +1,7 @@
 """双模型协作API端点"""
 
 import threading
-from typing import Any, Optional
+from typing import Optional
 
 from fastapi import APIRouter, HTTPException
 from fastapi.responses import StreamingResponse
@@ -30,19 +30,17 @@ class DualModelInitRequest(BaseModel):
     device_id: str
 
     # 决策大模型配置
-    decision_base_url: str = "https://api-inference.modelscope.cn/v1"
+    decision_base_url: str
     decision_api_key: str
-    decision_model_name: str = "ZhipuAI/GLM-4.7"
+    decision_model_name: str
 
     # 视觉小模型配置(复用现有配置)
     vision_base_url: Optional[str] = None
     vision_api_key: Optional[str] = None
     vision_model_name: Optional[str] = None
 
-    # 思考模式: fast 或 deep
-    thinking_mode: str = "deep"
-
     max_steps: int = 50
+    thinking_mode: str = "deep"  # fast, deep, turbo
 
 
 class DualModelChatRequest(BaseModel):
@@ -69,13 +67,16 @@ class DualModelStatusResponse(BaseModel):
 @router.post("/init")
 def init_dual_model(request: DualModelInitRequest) -> dict:
     """初始化双模型Agent"""
-    from AutoGLM_GUI.config import config
+    from AutoGLM_GUI.config_manager import config_manager
     from AutoGLM_GUI.phone_agent_manager import PhoneAgentManager
 
     device_id = request.device_id
-    thinking_mode = (
-        ThinkingMode.FAST if request.thinking_mode == "fast" else ThinkingMode.DEEP
-    )
+    thinking_mode_map = {
+        "fast": ThinkingMode.FAST,
+        "deep": ThinkingMode.DEEP,
+        "turbo": ThinkingMode.TURBO,
+    }
+    thinking_mode = thinking_mode_map.get(request.thinking_mode, ThinkingMode.DEEP)
     logger.info(f"初始化双模型Agent: {device_id}, 模式: {thinking_mode.value}")
 
     # 检查设备是否已有单模型Agent初始化
@@ -85,10 +86,16 @@ def init_dual_model(request: DualModelInitRequest) -> dict:
             status_code=400, detail="设备尚未初始化单模型Agent，请先调用 /api/init"
         )
 
-    # 获取视觉模型配置
-    vision_base_url = request.vision_base_url or config.base_url
-    vision_api_key = request.vision_api_key or config.api_key
-    vision_model_name = request.vision_model_name or config.model_name
+    # 获取有效配置
+    effective_config = config_manager.get_effective_config()
+
+    # 获取配置的默认最大步数
+    max_steps = effective_config.default_max_steps
+
+    # 获取视觉模型配置（优先级：请求参数 > 有效配置）
+    vision_base_url = request.vision_base_url or effective_config.base_url
+    vision_api_key = request.vision_api_key or effective_config.api_key
+    vision_model_name = request.vision_model_name or effective_config.model_name
 
     if not vision_base_url:
         raise HTTPException(status_code=400, detail="视觉模型base_url未配置")
@@ -113,7 +120,7 @@ def init_dual_model(request: DualModelInitRequest) -> dict:
             decision_config=decision_config,
             vision_config=vision_config,
             device_id=device_id,
-            max_steps=request.max_steps,
+            max_steps=max_steps,
             thinking_mode=thinking_mode,
         )
 
@@ -163,8 +170,8 @@ def dual_model_chat_stream(request: DualModelChatRequest):
             logger.info(f"开始双模型任务: {request.message[:50]}...")
 
             # 在后台线程运行Agent
-            result_holder: list[Any] = [None]
-            error_holder: list[Any] = [None]
+            result_holder: list[dict | None] = [None]
+            error_holder: list[Exception | None] = [None]
 
             def run_agent():
                 try:

AutoGLM_GUI/api/health.py

@@ -0,0 +1,13 @@
+from fastapi import APIRouter
+
+from AutoGLM_GUI.version import APP_VERSION
+
+router = APIRouter(prefix="/api", tags=["health"])
+
+
+@router.get("/health")
+async def health_check() -> dict:
+    return {
+        "status": "healthy",
+        "version": APP_VERSION,
+    }