autoglm-gui 1.2.1__tar.gz → 1.3.1__tar.gz

{autoglm_gui-1.2.1 → autoglm_gui-1.3.1}/AutoGLM_GUI/adb_plus/__init__.py

@@ -1,14 +1,14 @@
 """Lightweight ADB helpers with a more robust screenshot implementation."""
 
-from .keyboard_installer import ADBKeyboardInstaller
-from .screenshot import Screenshot, capture_screenshot
-from .touch import touch_down, touch_move, touch_up
-from .ip import get_wifi_ip
-from .serial import get_device_serial, extract_serial_from_mdns
 from .device import check_device_available
+from .ip import get_wifi_ip
+from .keyboard_installer import ADBKeyboardInstaller
+from .mdns import MdnsDevice, discover_mdns_devices
 from .pair import pair_device
-from .mdns import discover_mdns_devices, MdnsDevice
 from .qr_pair import qr_pairing_manager
+from .screenshot import Screenshot, capture_screenshot
+from .serial import extract_serial_from_mdns, get_device_serial
+from .touch import touch_down, touch_move, touch_up
 from .version import get_adb_version, supports_mdns_services
 
 __all__ = [

{autoglm_gui-1.2.1 → autoglm_gui-1.3.1}/AutoGLM_GUI/api/__init__.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import sys
+from contextlib import asynccontextmanager
 from importlib.resources import files
 from pathlib import Path
 
@@ -10,10 +11,20 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
 
-from AutoGLM_GUI.version import APP_VERSION
 from AutoGLM_GUI.adb_plus.qr_pair import qr_pairing_manager
+from AutoGLM_GUI.version import APP_VERSION
 
-from . import agents, control, devices, media, version, workflows
+from . import (
+    agents,
+    control,
+    devices,
+    dual_model,
+    mcp,
+    media,
+    metrics,
+    version,
+    workflows,
+)
 
 
 def _get_static_dir() -> Path | None:
@@ -42,7 +53,32 @@ def _get_static_dir() -> Path | None:
 
 def create_app() -> FastAPI:
     """Build the FastAPI app with routers and static assets."""
-    app = FastAPI(title="AutoGLM-GUI API", version=APP_VERSION)
+
+    # Create MCP ASGI app
+    mcp_app = mcp.get_mcp_asgi_app()
+
+    # Define combined lifespan
+    @asynccontextmanager
+    async def combined_lifespan(app: FastAPI):
+        """Combine app startup logic with MCP lifespan."""
+        # App startup
+        asyncio.create_task(qr_pairing_manager.cleanup_expired_sessions())
+
+        from AutoGLM_GUI.device_manager import DeviceManager
+
+        device_manager = DeviceManager.get_instance()
+        device_manager.start_polling()
+
+        # Run MCP lifespan
+        async with mcp_app.lifespan(app):
+            yield
+
+        # App shutdown (if needed in the future)
+
+    # Create FastAPI app with combined lifespan
+    app = FastAPI(
+        title="AutoGLM-GUI API", version=APP_VERSION, lifespan=combined_lifespan
+    )
 
     app.add_middleware(
         CORSMiddleware,
@@ -56,34 +92,36 @@ def create_app() -> FastAPI:
     app.include_router(devices.router)
     app.include_router(control.router)
     app.include_router(media.router)
+    app.include_router(metrics.router)
     app.include_router(version.router)
     app.include_router(workflows.router)
+    app.include_router(dual_model.router)
 
-    @app.on_event("startup")
-    async def startup_event():
-        """Initialize background tasks on server startup."""
-        # Start QR pairing session cleanup task
-        asyncio.create_task(qr_pairing_manager.cleanup_expired_sessions())
-
-        # Start device polling
-        from AutoGLM_GUI.device_manager import DeviceManager
-
-        device_manager = DeviceManager.get_instance()
-        device_manager.start_polling()
-
+    # Mount static files BEFORE MCP to ensure they have priority
+    # This is critical: FastAPI processes mounts in order, so static files
+    # must be mounted before the catch-all MCP mount
     static_dir = _get_static_dir()
     if static_dir is not None and static_dir.exists():
         assets_dir = static_dir / "assets"
         if assets_dir.exists():
             app.mount("/assets", StaticFiles(directory=assets_dir), name="assets")
 
-        @app.get("/{full_path:path}")
+        # 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")
 
+        # Add catch-all route for SPA (handles all non-API routes)
+        app.add_api_route(
+            "/{full_path:path}", serve_spa, methods=["GET"], include_in_schema=False
+        )
+
+    # Mount MCP server at root (mcp_app already has /mcp path prefix)
+    # This must be AFTER static files to avoid intercepting them
+    app.mount("/", mcp_app)
+
     return app
 
 

{autoglm_gui-1.2.1 → autoglm_gui-1.3.1}/AutoGLM_GUI/api/agents.py

@@ -28,7 +28,6 @@ from AutoGLM_GUI.state import (
     non_blocking_takeover,
 )
 from AutoGLM_GUI.version import APP_VERSION
-from phone_agent import PhoneAgent
 from phone_agent.agent import AgentConfig
 from phone_agent.model import ModelConfig
 
@@ -37,31 +36,73 @@ apply_patches()
 
 router = APIRouter()
 
-# Active chat sessions (device_id -> stop_event)
-# Used for aborting ongoing conversations
-_active_chats: dict[str, threading.Event] = {}
-_active_chats_lock = threading.Lock()
 
+def _setup_adb_keyboard(device_id: str) -> None:
+    """检查并自动安装 ADB Keyboard。
 
-def _release_device_lock_when_done(
-    device_id: str, threads: list[threading.Thread]
+    Args:
+        device_id: 设备 ID
+    """
+    from AutoGLM_GUI.adb_plus import ADBKeyboardInstaller
+
+    logger.info(f"Checking ADB Keyboard for device {device_id}...")
+    installer = ADBKeyboardInstaller(device_id=device_id)
+    status = installer.get_status()
+
+    if not (status["installed"] and status["enabled"]):
+        logger.info(f"Setting up ADB Keyboard for device {device_id}...")
+        success, message = installer.auto_setup()
+        if success:
+            logger.info(f"✓ Device {device_id}: {message}")
+        else:
+            logger.warning(f"✗ Device {device_id}: {message}")
+    else:
+        logger.info(f"✓ Device {device_id}: ADB Keyboard ready")
+
+
+def _initialize_agent_with_config(
+    device_id: str,
+    model_config: ModelConfig,
+    agent_config: AgentConfig,
 ) -> None:
-    """Block until threads finish, then release the device lock via manager."""
+    """使用给定配置初始化 Agent。
+
+    Args:
+        device_id: 设备 ID
+        model_config: 模型配置
+        agent_config: Agent 配置
+
+    Raises:
+        Exception: 初始化失败时抛出异常
+    """
     from AutoGLM_GUI.phone_agent_manager import PhoneAgentManager
 
-    for thread in threads:
-        thread.join()
+    # Setup ADB Keyboard first
+    _setup_adb_keyboard(device_id)
 
+    # Initialize agent
     manager = PhoneAgentManager.get_instance()
-    manager.release_device(device_id)
+    manager.initialize_agent(
+        device_id=device_id,
+        model_config=model_config,
+        agent_config=agent_config,
+        takeover_callback=non_blocking_takeover,
+    )
+    logger.info(f"Agent initialized successfully for device {device_id}")
+
+
+def _create_sse_event(
+    event_type: str, data: dict[str, Any], role: str = "assistant"
+) -> dict[str, Any]:
+    """Create an SSE event with standardized fields including role."""
+    event_data = {"type": event_type, "role": role, **data}
+    return event_data
 
 
 @router.post("/api/init")
 def init_agent(request: InitRequest) -> dict:
     """初始化 PhoneAgent（多设备支持）。"""
-    from AutoGLM_GUI.adb_plus import ADBKeyboardInstaller
     from AutoGLM_GUI.config_manager import config_manager
-    from AutoGLM_GUI.logger import logger
 
     req_model_config = request.model or APIModelConfig()
     req_agent_config = request.agent or APIAgentConfig()
@@ -77,21 +118,6 @@ def init_agent(request: InitRequest) -> dict:
     config_manager.sync_to_env()
     config.refresh_from_env()
 
-    # 检查并自动安装 ADB Keyboard
-    logger.info(f"Checking ADB Keyboard for device {device_id}...")
-    installer = ADBKeyboardInstaller(device_id=device_id)
-    status = installer.get_status()
-
-    if not (status["installed"] and status["enabled"]):
-        logger.info(f"Setting up ADB Keyboard for device {device_id}...")
-        success, message = installer.auto_setup()
-        if success:
-            logger.info(f"✓ Device {device_id}: {message}")
-        else:
-            logger.warning(f"✗ Device {device_id}: {message}")
-    else:
-        logger.info(f"✓ Device {device_id}: ADB Keyboard ready")
-
     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
@@ -120,17 +146,9 @@ def init_agent(request: InitRequest) -> dict:
         verbose=req_agent_config.verbose,
     )
 
-    # Initialize agent via PhoneAgentManager (thread-safe, transactional)
-    from AutoGLM_GUI.phone_agent_manager import PhoneAgentManager
-
-    manager = PhoneAgentManager.get_instance()
+    # Initialize agent (includes ADB Keyboard setup)
     try:
-        manager.initialize_agent(
-            device_id=device_id,
-            model_config=model_config,
-            agent_config=agent_config,
-            takeover_callback=non_blocking_takeover,
-        )
+        _initialize_agent_with_config(device_id, model_config, agent_config)
     except Exception as e:
         logger.error(f"Failed to initialize agent: {e}")
         raise HTTPException(status_code=500, detail=str(e))
@@ -175,119 +193,59 @@ def chat(request: ChatRequest) -> ChatResponse:
 @router.post("/api/chat/stream")
 def chat_stream(request: ChatRequest):
     """发送任务给 Agent 并实时推送执行进度（SSE，多设备支持）。"""
-    from AutoGLM_GUI.exceptions import AgentNotInitializedError, DeviceBusyError
+    from AutoGLM_GUI.exceptions import DeviceBusyError
     from AutoGLM_GUI.phone_agent_manager import PhoneAgentManager
 
     device_id = request.device_id
     manager = PhoneAgentManager.get_instance()
 
-    # Check if agent is initialized
+    # 验证 agent 已初始化
     if not manager.is_initialized(device_id):
         raise HTTPException(
             status_code=400,
             detail=f"Device {device_id} not initialized. Call /api/init first.",
         )
 
-    # Acquire device lock (non-blocking) to prevent concurrent requests
-    try:
-        manager.acquire_device(device_id, timeout=0, raise_on_timeout=True)
-    except DeviceBusyError:
-        raise HTTPException(
-            status_code=409,
-            detail=f"Device {device_id} is already processing a request. Please wait.",
-        )
+    def event_generator():
+        """SSE 事件生成器."""
+        threads: list[threading.Thread] = []
 
-    try:
-        # Get the original agent to copy its config
-        original_agent = manager.get_agent(device_id)
-
-        # Get the stored configs for this device
         try:
-            model_config, agent_config = manager.get_config(device_id)
-        except AgentNotInitializedError:
-            manager.release_device(device_id)
-            raise HTTPException(
-                status_code=400,
-                detail=f"Device {device_id} config not found.",
-            )
-
-        def event_generator():
-            """SSE 事件生成器"""
-            threads: list[threading.Thread] = []
-            stop_event = threading.Event()
-
-            # Register stop_event to global mapping for abort support
-            with _active_chats_lock:
-                _active_chats[device_id] = stop_event
-
-            try:
-                # Create a queue to collect events from the agent
-                event_queue: queue.Queue[tuple[str, Any]] = queue.Queue()
-
-                # Create a callback to handle thinking chunks
-                def on_thinking_chunk(chunk: str):
-                    """Emit thinking chunks as they arrive"""
-                    if not stop_event.is_set():
-                        chunk_data = {
-                            "type": "thinking_chunk",
-                            "chunk": chunk,
-                        }
-                        event_queue.put(("thinking_chunk", chunk_data))
-
-                # Create a new agent instance
-                streaming_agent = PhoneAgent(
-                    model_config=model_config,
-                    agent_config=agent_config,
-                    takeover_callback=non_blocking_takeover,
-                )
-
-                # Copy context from original agent (thread-safe due to device lock)
-                streaming_agent._context = original_agent._context.copy()
-                streaming_agent._step_count = original_agent._step_count
-
-                # Monkey-patch the model_client.request to inject the callback
-                original_request = streaming_agent.model_client.request
-
-                def patched_request(messages, **kwargs):
-                    # Inject the on_thinking_chunk callback
-                    return original_request(
-                        messages, on_thinking_chunk=on_thinking_chunk
-                    )
-
-                streaming_agent.model_client.request = patched_request
-
-                # Early abort check (before starting any steps)
+            # 创建事件队列用于 agent → SSE 通信
+            event_queue: queue.Queue[tuple[str, Any]] = queue.Queue()
+
+            # 思考块回调
+            def on_thinking_chunk(chunk: str):
+                chunk_data = _create_sse_event("thinking_chunk", {"chunk": chunk})
+                event_queue.put(("thinking_chunk", chunk_data))
+
+            # 使用 streaming agent context manager（自动处理所有管理逻辑！）
+            with manager.use_streaming_agent(
+                device_id, on_thinking_chunk, timeout=0
+            ) as (streaming_agent, stop_event):
+                # 早期 abort 检查
                 if stop_event.is_set():
-                    logger.info(
-                        f"[Abort] Agent for device {device_id} received abort signal before starting steps"
-                    )
+                    logger.info(f"[Abort] Chat aborted before starting for {device_id}")
                     yield "event: aborted\n"
-                    yield 'data: {"type": "aborted", "message": "Chat aborted by user"}\n\n'
+                    yield 'data: {"type": "aborted", "role": "assistant", "message": "Chat aborted by user"}\n\n'
                     return
 
-                # Run agent step in a separate thread
+                # 在线程中运行 agent 步骤
                 step_result: list[Any] = [None]
                 error_result: list[Any] = [None]
 
                 def run_step(is_first: bool = True, task: str | None = None):
                     try:
-                        # Check before starting step
                         if stop_event.is_set():
-                            logger.info(
-                                f"[Abort] Agent for device {device_id} received abort signal before step execution"
-                            )
                             return
 
-                        if is_first:
-                            result = streaming_agent.step(task)
-                        else:
-                            result = streaming_agent.step()
+                        result = (
+                            streaming_agent.step(task)
+                            if is_first
+                            else streaming_agent.step()
+                        )
 
-                        # Check after step completes
                         if stop_event.is_set():
-                            logger.info(
-                                f"[Abort] Agent for device {device_id} received abort signal after step execution"
-                            )
                             return
 
                         step_result[0] = result
@@ -296,21 +254,18 @@ def chat_stream(request: ChatRequest):
                     finally:
                         event_queue.put(("step_done", None))
 
-                # Start first step
+                # 启动第一步
                 thread = threading.Thread(
                     target=run_step, args=(True, request.message), daemon=True
                 )
                 thread.start()
                 threads.append(thread)
 
+                # 事件循环
                 while not stop_event.is_set():
-                    # Wait for events from the queue
                     try:
                         event_type, event_data = event_queue.get(timeout=0.1)
                     except queue.Empty:
-                        # Check again on timeout
-                        if stop_event.is_set():
-                            break
                         continue
 
                     if event_type == "thinking_chunk":
@@ -318,30 +273,33 @@ def chat_stream(request: ChatRequest):
                         yield f"data: {json.dumps(event_data, ensure_ascii=False)}\n\n"
 
                     elif event_type == "step_done":
-                        # Check for errors
                         if error_result[0]:
                             raise error_result[0]
 
                         result = step_result[0]
-                        event_data = {
-                            "type": "step",
-                            "step": streaming_agent.step_count,
-                            "thinking": result.thinking,
-                            "action": result.action,
-                            "success": result.success,
-                            "finished": result.finished,
-                        }
+                        event_data = _create_sse_event(
+                            "step",
+                            {
+                                "step": streaming_agent.step_count,
+                                "thinking": result.thinking,
+                                "action": result.action,
+                                "success": result.success,
+                                "finished": result.finished,
+                            },
+                        )
 
                         yield "event: step\n"
                         yield f"data: {json.dumps(event_data, ensure_ascii=False)}\n\n"
 
                         if result.finished:
-                            done_data = {
-                                "type": "done",
-                                "message": result.message,
-                                "steps": streaming_agent.step_count,
-                                "success": result.success,
-                            }
+                            done_data = _create_sse_event(
+                                "done",
+                                {
+                                    "message": result.message,
+                                    "steps": streaming_agent.step_count,
+                                    "success": result.success,
+                                },
+                            )
                             yield "event: done\n"
                             yield f"data: {json.dumps(done_data, ensure_ascii=False)}\n\n"
                             break
@@ -350,17 +308,19 @@ def chat_stream(request: ChatRequest):
                             streaming_agent.step_count
                             >= streaming_agent.agent_config.max_steps
                         ):
-                            done_data = {
-                                "type": "done",
-                                "message": "Max steps reached",
-                                "steps": streaming_agent.step_count,
-                                "success": result.success,
-                            }
+                            done_data = _create_sse_event(
+                                "done",
+                                {
+                                    "message": "Max steps reached",
+                                    "steps": streaming_agent.step_count,
+                                    "success": result.success,
+                                },
+                            )
                             yield "event: done\n"
                             yield f"data: {json.dumps(done_data, ensure_ascii=False)}\n\n"
                             break
 
-                        # Start next step
+                        # 启动下一步
                         step_result[0] = None
                         error_result[0] = None
                         thread = threading.Thread(
@@ -369,61 +329,44 @@ def chat_stream(request: ChatRequest):
                         thread.start()
                         threads.append(thread)
 
-                # Check if loop exited due to abort
+                # 检查是否被中止
                 if stop_event.is_set():
-                    logger.info(
-                        f"[Abort] Agent for device {device_id} event loop terminated due to abort signal"
-                    )
+                    logger.info(f"[Abort] Streaming chat terminated for {device_id}")
                     yield "event: aborted\n"
-                    yield 'data: {"type": "aborted", "message": "Chat aborted by user"}\n\n'
-
-                # Update original agent state (thread-safe due to device lock)
-                original_agent._context = streaming_agent._context
-                original_agent._step_count = streaming_agent._step_count
+                    yield 'data: {"type": "aborted", "role": "assistant", "message": "Chat aborted by user"}\n\n'
 
+                # 重置原始 agent（context 已由 use_streaming_agent 同步）
+                original_agent = manager.get_agent(device_id)
                 original_agent.reset()
 
-            except Exception as e:
-                error_data = {
-                    "type": "error",
-                    "message": str(e),
-                }
-                yield "event: error\n"
-                yield f"data: {json.dumps(error_data, ensure_ascii=False)}\n\n"
-            finally:
-                # Clean up active chats mapping
-                with _active_chats_lock:
-                    _active_chats.pop(device_id, None)
-
-                # Signal all threads to stop
+        except DeviceBusyError:
+            error_data = _create_sse_event("error", {"message": "Device is busy"})
+            yield "event: error\n"
+            yield f"data: {json.dumps(error_data, ensure_ascii=False)}\n\n"
+        except Exception as e:
+            logger.exception(f"Error in streaming chat for {device_id}")
+            error_data = _create_sse_event("error", {"message": str(e)})
+            yield "event: error\n"
+            yield f"data: {json.dumps(error_data, ensure_ascii=False)}\n\n"
+        finally:
+            # 通知线程停止
+            if "stop_event" in locals():
                 stop_event.set()
 
-                alive_threads = [thread for thread in threads if thread.is_alive()]
-                if alive_threads:
-                    # Release lock after background threads complete
-                    cleanup_thread = threading.Thread(
-                        target=_release_device_lock_when_done,
-                        args=(device_id, alive_threads),
-                        daemon=True,
-                    )
-                    cleanup_thread.start()
-                else:
-                    # Release lock immediately if no threads are alive
-                    manager.release_device(device_id)
-
-        return StreamingResponse(
-            event_generator(),
-            media_type="text/event-stream",
-            headers={
-                "Cache-Control": "no-cache",
-                "Connection": "keep-alive",
-                "X-Accel-Buffering": "no",
-            },
-        )
-    except Exception:
-        # Release lock if exception occurs before generator starts
-        manager.release_device(device_id)
-        raise
+            # 等待线程完成（带超时）
+            for thread in threads:
+                if thread.is_alive():
+                    thread.join(timeout=5.0)
+
+    return StreamingResponse(
+        event_generator(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",
+        },
+    )
 
 
 @router.get("/api/status", response_model=StatusResponse)
@@ -478,18 +421,17 @@ def reset_agent(request: ResetRequest) -> dict:
 @router.post("/api/chat/abort")
 def abort_chat(request: AbortRequest) -> dict:
     """中断正在进行的对话流。"""
-    from AutoGLM_GUI.logger import logger
+    from AutoGLM_GUI.phone_agent_manager import PhoneAgentManager
 
     device_id = request.device_id
+    manager = PhoneAgentManager.get_instance()
 
-    with _active_chats_lock:
-        if device_id in _active_chats:
-            logger.info(f"Aborting chat for device {device_id}")
-            _active_chats[device_id].set()  # 设置中断标志
-            return {"success": True, "message": "Abort requested"}
-        else:
-            logger.warning(f"No active chat found for device {device_id}")
-            return {"success": False, "message": "No active chat found"}
+    success = manager.abort_streaming_chat(device_id)
+
+    return {
+        "success": success,
+        "message": "Abort requested" if success else "No active chat found",
+    }
 
 
 @router.get("/api/config", response_model=ConfigResponse)
@@ -512,6 +454,13 @@ def get_config_endpoint() -> ConfigResponse:
         model_name=effective_config.model_name,
         api_key=effective_config.api_key if effective_config.api_key != "EMPTY" else "",
         source=source.value,
+        dual_model_enabled=effective_config.dual_model_enabled,
+        decision_base_url=effective_config.decision_base_url,
+        decision_model_name=effective_config.decision_model_name,
+        decision_api_key=effective_config.decision_api_key
+        if effective_config.decision_api_key
+        else "",
+        thinking_mode=effective_config.thinking_mode,
         conflicts=[
             {
                 "field": c.field,
@@ -532,7 +481,7 @@ def save_config_endpoint(request: ConfigSaveRequest) -> dict:
     from AutoGLM_GUI.config_manager import ConfigModel, config_manager
 
     try:
-        # Validate incoming configuration to avoid silently falling back to defaults
+        # Validate incoming configuration
         ConfigModel(
             base_url=request.base_url,
             model_name=request.model_name,
@@ -544,6 +493,11 @@ def save_config_endpoint(request: ConfigSaveRequest) -> dict:
             base_url=request.base_url,
             model_name=request.model_name,
             api_key=request.api_key,
+            dual_model_enabled=request.dual_model_enabled,
+            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,
             merge_mode=True,
         )