autoglm-gui 1.2.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

AutoGLM_GUI/api/dual_model.py

@@ -0,0 +1,310 @@
+"""双模型协作API端点"""
+
+import threading
+from typing import Any, Optional
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+
+from AutoGLM_GUI.logger import logger
+from AutoGLM_GUI.dual_model import (
+    DecisionModelConfig,
+    DualModelAgent,
+    DualModelEvent,
+    DualModelEventType,
+)
+from AutoGLM_GUI.dual_model.protocols import ThinkingMode
+from phone_agent.model import ModelConfig
+
+router = APIRouter(prefix="/api/dual", tags=["dual-model"])
+
+# 活跃的双模型会话 (device_id -> (agent, stop_event))
+_active_dual_sessions: dict[str, tuple[DualModelAgent, threading.Event]] = {}
+_active_dual_sessions_lock = threading.Lock()
+
+
+class DualModelInitRequest(BaseModel):
+    """双模型初始化请求"""
+
+    device_id: str
+
+    # 决策大模型配置
+    decision_base_url: str = "https://api-inference.modelscope.cn/v1"
+    decision_api_key: str
+    decision_model_name: str = "ZhipuAI/GLM-4.7"
+
+    # 视觉小模型配置(复用现有配置)
+    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
+
+
+class DualModelChatRequest(BaseModel):
+    """双模型聊天请求"""
+
+    device_id: str
+    message: str
+
+
+class DualModelAbortRequest(BaseModel):
+    """中止请求"""
+
+    device_id: str
+
+
+class DualModelStatusResponse(BaseModel):
+    """状态响应"""
+
+    active: bool
+    device_id: Optional[str] = None
+    state: Optional[dict] = None
+
+
+@router.post("/init")
+def init_dual_model(request: DualModelInitRequest) -> dict:
+    """初始化双模型Agent"""
+    from AutoGLM_GUI.config import config
+    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
+    )
+    logger.info(f"初始化双模型Agent: {device_id}, 模式: {thinking_mode.value}")
+
+    # 检查设备是否已有单模型Agent初始化
+    manager = PhoneAgentManager.get_instance()
+    if not manager.is_initialized(device_id):
+        raise HTTPException(
+            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
+
+    if not vision_base_url:
+        raise HTTPException(status_code=400, detail="视觉模型base_url未配置")
+
+    # 创建配置
+    decision_config = DecisionModelConfig(
+        base_url=request.decision_base_url,
+        api_key=request.decision_api_key,
+        model_name=request.decision_model_name,
+        thinking_mode=thinking_mode,
+    )
+
+    vision_config = ModelConfig(
+        base_url=vision_base_url,
+        api_key=vision_api_key,
+        model_name=vision_model_name,
+    )
+
+    # 创建双模型Agent
+    try:
+        agent = DualModelAgent(
+            decision_config=decision_config,
+            vision_config=vision_config,
+            device_id=device_id,
+            max_steps=request.max_steps,
+            thinking_mode=thinking_mode,
+        )
+
+        # 存储到活跃会话
+        with _active_dual_sessions_lock:
+            # 清理旧会话
+            if device_id in _active_dual_sessions:
+                old_agent, old_event = _active_dual_sessions[device_id]
+                old_event.set()
+
+            _active_dual_sessions[device_id] = (agent, threading.Event())
+
+        logger.info(f"双模型Agent初始化成功: {device_id}")
+
+        return {
+            "success": True,
+            "device_id": device_id,
+            "message": "双模型Agent初始化成功",
+            "decision_model": request.decision_model_name,
+            "vision_model": vision_model_name,
+            "thinking_mode": thinking_mode.value,
+        }
+
+    except Exception as e:
+        logger.error(f"双模型Agent初始化失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/chat/stream")
+def dual_model_chat_stream(request: DualModelChatRequest):
+    """双模型聊天(SSE流式)"""
+    device_id = request.device_id
+
+    with _active_dual_sessions_lock:
+        if device_id not in _active_dual_sessions:
+            raise HTTPException(
+                status_code=400, detail="双模型Agent未初始化，请先调用 /api/dual/init"
+            )
+        agent, stop_event = _active_dual_sessions[device_id]
+
+    # 重置停止事件
+    stop_event.clear()
+
+    def event_generator():
+        """SSE事件生成器"""
+        try:
+            logger.info(f"开始双模型任务: {request.message[:50]}...")
+
+            # 在后台线程运行Agent
+            result_holder: list[Any] = [None]
+            error_holder: list[Any] = [None]
+
+            def run_agent():
+                try:
+                    result = agent.run(request.message)
+                    result_holder[0] = result
+                except Exception as e:
+                    error_holder[0] = e
+
+            thread = threading.Thread(target=run_agent, daemon=True)
+            thread.start()
+
+            # 持续发送事件
+            while thread.is_alive() or not agent.event_queue.empty():
+                if stop_event.is_set():
+                    agent.abort()
+                    yield "event: aborted\n"
+                    yield 'data: {"type": "aborted", "message": "任务被用户中断"}\n\n'
+                    break
+
+                # 获取事件
+                try:
+                    events = agent.get_events(timeout=0.1)
+                    for event in events:
+                        yield event.to_sse()
+
+                        # 如果是完成或错误事件，结束循环
+                        if event.type in [
+                            DualModelEventType.TASK_COMPLETE,
+                            DualModelEventType.ERROR,
+                        ]:
+                            return
+                except Exception:
+                    continue
+
+            # 等待线程完成
+            thread.join(timeout=5)
+
+            # 检查错误
+            if error_holder[0]:
+                error_event = DualModelEvent(
+                    type=DualModelEventType.ERROR,
+                    data={"message": str(error_holder[0])},
+                )
+                yield error_event.to_sse()
+
+            # 如果没有发送完成事件，发送一个
+            if result_holder[0] and not stop_event.is_set():
+                result = result_holder[0]
+                if isinstance(result, dict):
+                    done_event = DualModelEvent(
+                        type=DualModelEventType.TASK_COMPLETE,
+                        data={
+                            "success": result.get("success", False),
+                            "message": result.get("message", ""),
+                            "steps": result.get("steps", 0),
+                        },
+                    )
+                    yield done_event.to_sse()
+
+        except Exception as e:
+            logger.exception(f"双模型任务异常: {e}")
+            error_event = DualModelEvent(
+                type=DualModelEventType.ERROR,
+                data={"message": str(e)},
+            )
+            yield error_event.to_sse()
+
+    return StreamingResponse(
+        event_generator(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",
+        },
+    )
+
+
+@router.post("/chat/abort")
+def abort_dual_model_chat(request: DualModelAbortRequest) -> dict:
+    """中止双模型聊天"""
+    device_id = request.device_id
+
+    with _active_dual_sessions_lock:
+        if device_id in _active_dual_sessions:
+            agent, stop_event = _active_dual_sessions[device_id]
+            stop_event.set()
+            agent.abort()
+            logger.info(f"双模型任务已中止: {device_id}")
+            return {"success": True, "message": "已发送中止信号"}
+        else:
+            return {"success": False, "message": "未找到活跃的双模型会话"}
+
+
+@router.get("/status")
+def get_dual_model_status(device_id: Optional[str] = None) -> DualModelStatusResponse:
+    """获取双模型状态"""
+    with _active_dual_sessions_lock:
+        if device_id:
+            if device_id in _active_dual_sessions:
+                agent, _ = _active_dual_sessions[device_id]
+                return DualModelStatusResponse(
+                    active=True,
+                    device_id=device_id,
+                    state=agent.get_state(),
+                )
+            else:
+                return DualModelStatusResponse(active=False, device_id=device_id)
+        else:
+            # 返回所有活跃会话
+            return DualModelStatusResponse(
+                active=len(_active_dual_sessions) > 0,
+                state={"active_devices": list(_active_dual_sessions.keys())},
+            )
+
+
+@router.post("/reset")
+def reset_dual_model(request: DualModelAbortRequest) -> dict:
+    """重置双模型Agent"""
+    device_id = request.device_id
+
+    with _active_dual_sessions_lock:
+        if device_id in _active_dual_sessions:
+            agent, stop_event = _active_dual_sessions[device_id]
+            stop_event.set()
+            agent.reset()
+            logger.info(f"双模型Agent已重置: {device_id}")
+            return {"success": True, "message": "双模型Agent已重置"}
+        else:
+            return {"success": False, "message": "未找到双模型会话"}
+
+
+@router.delete("/session/{device_id}")
+def delete_dual_model_session(device_id: str) -> dict:
+    """删除双模型会话"""
+    with _active_dual_sessions_lock:
+        if device_id in _active_dual_sessions:
+            agent, stop_event = _active_dual_sessions.pop(device_id)
+            stop_event.set()
+            logger.info(f"双模型会话已删除: {device_id}")
+            return {"success": True, "message": "双模型会话已删除"}
+        else:
+            return {"success": False, "message": "未找到双模型会话"}

AutoGLM_GUI/api/mcp.py

@@ -0,0 +1,134 @@
+"""MCP (Model Context Protocol) tools for AutoGLM-GUI."""
+
+from typing import Any, Dict, List
+
+from fastmcp import FastMCP
+
+from AutoGLM_GUI.logger import logger
+from AutoGLM_GUI.prompts import MCP_SYSTEM_PROMPT_ZH
+
+# 创建 MCP 服务器实例
+mcp = FastMCP("AutoGLM-GUI MCP Server")
+
+# MCP-specific step limit
+MCP_MAX_STEPS = 5
+
+
+@mcp.tool()
+def chat(device_id: str, message: str) -> Dict[str, Any]:
+    """
+    Send a task to the AutoGLM Phone Agent for execution.
+
+    The agent will be automatically initialized with global configuration
+    if not already initialized. MCP calls use a specialized Fail-Fast prompt
+    optimized for atomic operations within 5 steps.
+
+    Args:
+        device_id: Device identifier (e.g., "192.168.1.100:5555" or serial)
+        message: Natural language task (e.g., "打开微信", "发送消息")
+
+    Returns:
+        {
+            "result": str,    # Task execution result
+            "steps": int,     # Number of steps taken
+            "success": bool   # Success flag
+        }
+    """
+    from AutoGLM_GUI.exceptions import DeviceBusyError
+    from AutoGLM_GUI.phone_agent_manager import PhoneAgentManager
+
+    logger.info(f"[MCP] chat tool called: device_id={device_id}")
+
+    manager = PhoneAgentManager.get_instance()
+
+    # 使用上下文管理器获取 agent（自动管理锁，自动初始化）
+    try:
+        with manager.use_agent(device_id, timeout=None) as agent:
+            # Temporarily override config for MCP (thread-safe within device lock)
+            original_max_steps = agent.agent_config.max_steps
+            original_system_prompt = agent.agent_config.system_prompt
+
+            agent.agent_config.max_steps = MCP_MAX_STEPS
+            agent.agent_config.system_prompt = MCP_SYSTEM_PROMPT_ZH
+
+            try:
+                # Reset agent before each chat to ensure clean state
+                agent.reset()
+
+                result = agent.run(message)
+                steps = agent.step_count
+
+                # Check if MCP step limit was reached
+                if steps >= MCP_MAX_STEPS and result == "Max steps reached":
+                    return {
+                        "result": (
+                            f"已达到 MCP 最大步数限制（{MCP_MAX_STEPS}步）。任务可能未完成，"
+                            "建议将任务拆分为更小的子任务。"
+                        ),
+                        "steps": MCP_MAX_STEPS,
+                        "success": False,
+                    }
+
+                return {"result": result, "steps": steps, "success": True}
+
+            finally:
+                # Restore original config
+                agent.agent_config.max_steps = original_max_steps
+                agent.agent_config.system_prompt = original_system_prompt
+
+    except DeviceBusyError:
+        raise RuntimeError(f"Device {device_id} is busy. Please wait.")
+    except Exception as e:
+        logger.error(f"[MCP] chat tool error: {e}")
+        return {"result": str(e), "steps": 0, "success": False}
+
+
+@mcp.tool()
+def list_devices() -> List[Dict[str, Any]]:
+    """
+    List all connected ADB devices and their agent status.
+
+    Returns:
+        List of devices, each containing:
+        - id: Device identifier for API calls
+        - serial: Hardware serial number
+        - model: Device model name
+        - status: Connection status
+        - connection_type: "usb" | "wifi" | "remote"
+        - state: "online" | "offline" | "disconnected"
+        - agent: Agent status (if initialized)
+    """
+    from AutoGLM_GUI.api.devices import _build_device_response_with_agent
+    from AutoGLM_GUI.device_manager import DeviceManager
+    from AutoGLM_GUI.phone_agent_manager import PhoneAgentManager
+
+    logger.info("[MCP] list_devices tool called")
+
+    device_manager = DeviceManager.get_instance()
+    agent_manager = PhoneAgentManager.get_instance()
+
+    # Fallback: 如果轮询未启动，执行同步刷新
+    if not device_manager._poll_thread or not device_manager._poll_thread.is_alive():
+        logger.warning("Polling not started, performing sync refresh")
+        device_manager.force_refresh()
+
+    managed_devices = device_manager.get_devices()
+
+    # 重用现有的聚合逻辑
+    devices_with_agents = [
+        _build_device_response_with_agent(d, agent_manager) for d in managed_devices
+    ]
+
+    return devices_with_agents
+
+
+def get_mcp_asgi_app():
+    """
+    Get the MCP server's ASGI app for mounting in FastAPI.
+
+    Returns:
+        ASGI app that handles MCP protocol requests
+    """
+    # 创建 MCP HTTP app with /mcp path prefix
+    # This will create routes under /mcp when mounted at root
+    return mcp.http_app(path="/mcp")

AutoGLM_GUI/api/metrics.py

@@ -0,0 +1,36 @@
+"""Prometheus metrics endpoint."""
+
+from fastapi import APIRouter, Response
+from prometheus_client import CONTENT_TYPE_LATEST, generate_latest
+
+from AutoGLM_GUI.metrics import get_metrics_registry
+
+router = APIRouter()
+
+
+@router.get("/api/metrics")
+def metrics_endpoint() -> Response:
+    """
+    Prometheus metrics endpoint.
+
+    Returns metrics in Prometheus text exposition format.
+    This endpoint should be scraped by Prometheus at regular intervals.
+
+    Example Prometheus scrape config:
+        scrape_configs:
+          - job_name: 'autoglm-gui'
+            scrape_interval: 15s
+            static_configs:
+              - targets: ['localhost:8000']
+            metrics_path: '/api/metrics'
+
+    Returns:
+        Response: Prometheus-compatible text format
+    """
+    registry = get_metrics_registry()
+    data = generate_latest(registry)
+
+    return Response(
+        content=data,
+        media_type=CONTENT_TYPE_LATEST,
+    )

AutoGLM_GUI/config_manager.py

@@ -38,6 +38,13 @@ class ConfigSource(str, Enum):
 # ==================== 类型安全配置模型 ====================
 
 
+class ThinkingMode(str, Enum):
+    """思考模式枚举."""
+
+    FAST = "fast"  # 快速响应模式 - 减少思考时间
+    DEEP = "deep"  # 深度思考模式 - 完整思考过程
+
+
 class ConfigModel(BaseModel):
     """类型安全的配置模型，使用 Pydantic 进行验证."""
 
@@ -45,6 +52,15 @@ class ConfigModel(BaseModel):
     model_name: str = "autoglm-phone-9b"
     api_key: str = "EMPTY"
 
+    # 双模型配置
+    dual_model_enabled: bool = False
+    decision_base_url: str = "https://api-inference.modelscope.cn/v1"
+    decision_model_name: str = "ZhipuAI/GLM-4.7"
+    decision_api_key: str = ""
+
+    # 思考模式配置
+    thinking_mode: str = "deep"  # "fast" 或 "deep"
+
     @field_validator("base_url")
     @classmethod
     def validate_base_url(cls, v: str) -> str:
@@ -61,6 +77,22 @@ class ConfigModel(BaseModel):
             raise ValueError("model_name cannot be empty")
         return v.strip()
 
+    @field_validator("decision_base_url")
+    @classmethod
+    def validate_decision_base_url(cls, v: str) -> str:
+        """验证 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("/")  # 去除尾部斜杠
+
+    @field_validator("thinking_mode")
+    @classmethod
+    def validate_thinking_mode(cls, v: str) -> str:
+        """验证思考模式."""
+        if v not in ("fast", "deep"):
+            raise ValueError("thinking_mode must be 'fast' or 'deep'")
+        return v
+
 
 # ==================== 配置层数据类 ====================
 
@@ -72,6 +104,14 @@ class ConfigLayer:
     base_url: Optional[str] = None
     model_name: Optional[str] = None
     api_key: Optional[str] = None
+    # 双模型配置
+    dual_model_enabled: Optional[bool] = None
+    decision_base_url: Optional[str] = None
+    decision_model_name: Optional[str] = None
+    decision_api_key: Optional[str] = None
+    # 思考模式配置
+    thinking_mode: Optional[str] = None
+
     source: ConfigSource = ConfigSource.DEFAULT
 
     def has_value(self, key: str) -> bool:
@@ -98,6 +138,11 @@ class ConfigLayer:
                 "base_url": self.base_url,
                 "model_name": self.model_name,
                 "api_key": self.api_key,
+                "dual_model_enabled": self.dual_model_enabled,
+                "decision_base_url": self.decision_base_url,
+                "decision_model_name": self.decision_model_name,
+                "decision_api_key": self.decision_api_key,
+                "thinking_mode": self.thinking_mode,
             }.items()
             if v is not None
         }
@@ -265,6 +310,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"),
+                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"),
+                thinking_mode=config_data.get("thinking_mode"),
                 source=ConfigSource.FILE,
             )
             self._effective_config = None  # 清除缓存
@@ -292,6 +342,11 @@ class UnifiedConfigManager:
         base_url: str,
         model_name: str,
         api_key: Optional[str] = None,
+        dual_model_enabled: Optional[bool] = None,
+        decision_base_url: Optional[str] = None,
+        decision_model_name: Optional[str] = None,
+        decision_api_key: Optional[str] = None,
+        thinking_mode: Optional[str] = None,
         merge_mode: bool = True,
     ) -> bool:
         """
@@ -301,6 +356,11 @@ 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
+            thinking_mode: 思考模式 (fast/deep)
             merge_mode: 是否合并现有配置（True: 保留未提供的字段）
 
         Returns:
@@ -318,6 +378,16 @@ class UnifiedConfigManager:
 
             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:
+                new_config["decision_base_url"] = decision_base_url
+            if decision_model_name:
+                new_config["decision_model_name"] = decision_model_name
+            if decision_api_key:
+                new_config["decision_api_key"] = decision_api_key
+            if thinking_mode:
+                new_config["thinking_mode"] = thinking_mode
 
             # 合并模式：保留现有文件中未提供的字段
             if merge_mode and self._config_path.exists():
@@ -325,9 +395,18 @@ class UnifiedConfigManager:
                     with open(self._config_path, "r", encoding="utf-8") as f:
                         existing = json.load(f)
 
-                    # 保留 api_key（如果新配置未提供）
-                    if not api_key and "api_key" in existing:
-                        new_config["api_key"] = existing["api_key"]
+                    # 保留未提供的字段
+                    preserve_keys = [
+                        "api_key",
+                        "dual_model_enabled",
+                        "decision_base_url",
+                        "decision_model_name",
+                        "decision_api_key",
+                        "thinking_mode",
+                    ]
+                    for key in preserve_keys:
+                        if key not in new_config and key in existing:
+                            new_config[key] = existing[key]
 
                 except (json.JSONDecodeError, Exception) as e:
                     logger.warning(f"Could not merge with existing config: {e}")
@@ -387,6 +466,11 @@ class UnifiedConfigManager:
         Returns:
             ConfigModel: 验证后的配置对象
         """
+        # 首次加载：如果文件层为空且配置文件存在，自动加载
+        if not self._file_layer.to_dict() and self._config_path.exists():
+            logger.debug("Auto-loading config file on first access")
+            self.load_file_config()
+
         # 重新加载文件（热重载支持）
         if reload_file:
             self.load_file_config(force_reload=True)
@@ -398,7 +482,19 @@ class UnifiedConfigManager:
         # 按优先级合并配置
         merged = {}
 
-        for key in ["base_url", "model_name", "api_key"]:
+        # 所有配置字段
+        config_keys = [
+            "base_url",
+            "model_name",
+            "api_key",
+            "dual_model_enabled",
+            "decision_base_url",
+            "decision_model_name",
+            "decision_api_key",
+            "thinking_mode",
+        ]
+
+        for key in config_keys:
             # 1. CLI 优先
             if self._cli_layer.has_value(key):
                 merged[key] = getattr(self._cli_layer, key)
@@ -408,8 +504,11 @@ class UnifiedConfigManager:
             # 3. 配置文件
             elif self._file_layer.has_value(key):
                 merged[key] = getattr(self._file_layer, key)
-            # 4. 默认值
-            else:
+            # 4. 默认值（只对 base_url, model_name, api_key 有效）
+            elif (
+                hasattr(self._default_layer, key)
+                and getattr(self._default_layer, key, None) is not None
+            ):
                 merged[key] = getattr(self._default_layer, key)
 
         # 验证并缓存
@@ -555,6 +654,11 @@ class UnifiedConfigManager:
             "base_url": config.base_url,
             "model_name": config.model_name,
             "api_key": config.api_key,
+            "dual_model_enabled": config.dual_model_enabled,
+            "decision_base_url": config.decision_base_url,
+            "decision_model_name": config.decision_model_name,
+            "decision_api_key": config.decision_api_key,
+            "thinking_mode": config.thinking_mode,
         }