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

AutoGLM_GUI/api/dual_model.py

@@ -1,317 +0,0 @@
-"""双模型协作API端点"""
-
-import threading
-from typing import 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
-    decision_api_key: str
-    decision_model_name: str
-
-    # 视觉小模型配置(复用现有配置)
-    vision_base_url: Optional[str] = None
-    vision_api_key: Optional[str] = None
-    vision_model_name: Optional[str] = None
-
-    max_steps: int = 50
-    thinking_mode: str = "deep"  # fast, deep, turbo
-
-
-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_manager import config_manager
-    from AutoGLM_GUI.phone_agent_manager import PhoneAgentManager
-
-    device_id = request.device_id
-    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初始化
-    manager = PhoneAgentManager.get_instance()
-    if not manager.is_initialized(device_id):
-        raise HTTPException(
-            status_code=400, detail="设备尚未初始化单模型Agent，请先调用 /api/init"
-        )
-
-    # 获取有效配置
-    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未配置")
-
-    # 创建配置
-    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=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[dict | None] = [None]
-            error_holder: list[Exception | None] = [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/device_adapter.py

@@ -1,263 +0,0 @@
-"""Device Protocol Adapter for phone_agent integration.
-
-This module provides an adapter that bridges DeviceProtocol implementations
-to the interface expected by phone_agent's DeviceFactory.
-
-The adapter allows injecting any DeviceProtocol implementation (ADB, Mock, Remote)
-into phone_agent without modifying the third-party code.
-
-Example:
-    >>> from AutoGLM_GUI.device_adapter import inject_device_protocol
-    >>> from AutoGLM_GUI.devices import MockDevice, ADBDevice
-    >>>
-    >>> # For testing: inject mock device
-    >>> mock = MockDevice("mock_001", state_machine)
-    >>> inject_device_protocol(lambda _: mock)
-    >>>
-    >>> # For production: inject ADB device
-    >>> devices = {"phone_1": ADBDevice("emulator-5554")}
-    >>> inject_device_protocol(lambda device_id: devices[device_id])
-"""
-
-from typing import Callable
-
-import phone_agent.device_factory as device_factory_module
-from AutoGLM_GUI.device_protocol import DeviceProtocol, Screenshot
-
-
-class DeviceProtocolAdapter:
-    """
-    Adapter that bridges DeviceProtocol to phone_agent's DeviceFactory interface.
-
-    This adapter wraps a DeviceProtocol getter function and exposes the same
-    interface as phone_agent's DeviceFactory, allowing seamless injection.
-
-    The adapter handles:
-    - Routing device operations to the correct DeviceProtocol instance
-    - Converting between DeviceProtocol and DeviceFactory method signatures
-    - Managing device_id parameters (phone_agent passes device_id to each method)
-    """
-
-    def __init__(
-        self,
-        get_device: Callable[[str | None], DeviceProtocol],
-        default_device_id: str | None = None,
-    ):
-        """
-        Initialize the adapter.
-
-        Args:
-            get_device: Function that returns a DeviceProtocol given a device_id.
-                       If device_id is None, should return a default device.
-            default_device_id: Default device ID to use when None is passed.
-        """
-        self._get_device = get_device
-        self._default_device_id = default_device_id
-        # For compatibility with code that checks device_type
-        self.device_type = "protocol_adapter"
-
-    def _device(self, device_id: str | None) -> DeviceProtocol:
-        """Get device for the given ID."""
-        effective_id = device_id or self._default_device_id
-        return self._get_device(effective_id)
-
-    # === Screenshot ===
-    def get_screenshot(
-        self, device_id: str | None = None, timeout: int = 10
-    ) -> Screenshot:
-        """Get screenshot from device."""
-        return self._device(device_id).get_screenshot(timeout)
-
-    # === Input Operations ===
-    def tap(
-        self, x: int, y: int, device_id: str | None = None, delay: float | None = None
-    ) -> None:
-        """Tap at coordinates."""
-        self._device(device_id).tap(x, y, delay)
-
-    def double_tap(
-        self, x: int, y: int, device_id: str | None = None, delay: float | None = None
-    ) -> None:
-        """Double tap at coordinates."""
-        self._device(device_id).double_tap(x, y, delay)
-
-    def long_press(
-        self,
-        x: int,
-        y: int,
-        duration_ms: int = 3000,
-        device_id: str | None = None,
-        delay: float | None = None,
-    ) -> None:
-        """Long press at coordinates."""
-        self._device(device_id).long_press(x, y, duration_ms, delay)
-
-    def swipe(
-        self,
-        start_x: int,
-        start_y: int,
-        end_x: int,
-        end_y: int,
-        duration_ms: int | None = None,
-        device_id: str | None = None,
-        delay: float | None = None,
-    ) -> None:
-        """Swipe from start to end."""
-        self._device(device_id).swipe(
-            start_x, start_y, end_x, end_y, duration_ms, delay
-        )
-
-    def type_text(self, text: str, device_id: str | None = None) -> None:
-        """Type text."""
-        self._device(device_id).type_text(text)
-
-    def clear_text(self, device_id: str | None = None) -> None:
-        """Clear text."""
-        self._device(device_id).clear_text()
-
-    # === Navigation ===
-    def back(self, device_id: str | None = None, delay: float | None = None) -> None:
-        """Press back button."""
-        self._device(device_id).back(delay)
-
-    def home(self, device_id: str | None = None, delay: float | None = None) -> None:
-        """Press home button."""
-        self._device(device_id).home(delay)
-
-    def launch_app(
-        self, app_name: str, device_id: str | None = None, delay: float | None = None
-    ) -> bool:
-        """Launch an app."""
-        return self._device(device_id).launch_app(app_name, delay)
-
-    # === State Query ===
-    def get_current_app(self, device_id: str | None = None) -> str:
-        """Get current app name."""
-        return self._device(device_id).get_current_app()
-
-    # === Keyboard Management ===
-    def detect_and_set_adb_keyboard(self, device_id: str | None = None) -> str:
-        """Detect and set keyboard."""
-        return self._device(device_id).detect_and_set_adb_keyboard()
-
-    def restore_keyboard(self, ime: str, device_id: str | None = None) -> None:
-        """Restore keyboard."""
-        self._device(device_id).restore_keyboard(ime)
-
-    # === Device Management ===
-    def list_devices(self) -> list[str]:
-        """
-        List connected devices.
-
-        Note: This is a simplified implementation. For full device listing,
-        use ADBDeviceManager.list_devices() directly.
-        """
-        # This is called by some parts of phone_agent
-        # Return the default device if available
-        if self._default_device_id:
-            return [self._default_device_id]
-        return []
-
-    def get_connection_class(self):
-        """Not applicable for protocol adapter."""
-        raise NotImplementedError(
-            "Protocol adapter does not support get_connection_class. "
-            "Use ADBDeviceManager for connection management."
-        )
-
-
-# Store original factory for restoration
-_original_factory = None
-
-
-def inject_device_protocol(
-    get_device: Callable[[str | None], DeviceProtocol],
-    default_device_id: str | None = None,
-) -> DeviceProtocolAdapter:
-    """
-    Inject a DeviceProtocol implementation into phone_agent.
-
-    This replaces phone_agent's global _device_factory with an adapter
-    that routes all device operations through the provided DeviceProtocol.
-
-    Args:
-        get_device: Function that returns a DeviceProtocol given a device_id.
-        default_device_id: Default device ID when None is passed.
-
-    Returns:
-        The adapter instance (for inspection or further configuration).
-
-    Example:
-        >>> # Single mock device
-        >>> mock = MockDevice("mock_001", state_machine)
-        >>> inject_device_protocol(lambda _: mock)
-        >>>
-        >>> # Multiple devices
-        >>> devices = {
-        ...     "phone_1": ADBDevice("emulator-5554"),
-        ...     "phone_2": RemoteDevice("phone_2", "http://remote:8080"),
-        ... }
-        >>> inject_device_protocol(lambda did: devices.get(did, devices["phone_1"]))
-    """
-    # TODO： 不应该依赖这种全部变量
-    global _original_factory
-
-    # Save original factory if not already saved
-    if _original_factory is None:
-        _original_factory = device_factory_module._device_factory
-
-    # Create and inject adapter
-    adapter = DeviceProtocolAdapter(get_device, default_device_id)
-    device_factory_module._device_factory = adapter
-
-    return adapter
-
-
-def restore_device_factory() -> None:
-    """
-    Restore the original device factory.
-
-    Call this after testing to restore normal operation.
-    """
-    global _original_factory
-
-    if _original_factory is not None:
-        device_factory_module._device_factory = _original_factory
-        _original_factory = None
-
-
-class DeviceProtocolContext:
-    """
-    Context manager for temporarily injecting a DeviceProtocol.
-
-    Example:
-        >>> with DeviceProtocolContext(lambda _: mock_device):
-        ...     agent.run("test instruction")
-        >>> # Original factory is automatically restored
-    """
-
-    def __init__(
-        self,
-        get_device: Callable[[str | None], DeviceProtocol],
-        default_device_id: str | None = None,
-    ):
-        """
-        Initialize context.
-
-        Args:
-            get_device: Function that returns a DeviceProtocol given a device_id.
-            default_device_id: Default device ID when None is passed.
-        """
-        self._get_device = get_device
-        self._default_device_id = default_device_id
-        self._original_factory = None
-
-    def __enter__(self) -> DeviceProtocolAdapter:
-        """Enter context and inject adapter."""
-        self._original_factory = device_factory_module._device_factory
-        return inject_device_protocol(self._get_device, self._default_device_id)
-
-    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
-        """Exit context and restore original factory."""
-        device_factory_module._device_factory = self._original_factory
-        return None

AutoGLM_GUI/dual_model/__init__.py

@@ -1,53 +0,0 @@
-"""
-双模型协作模块
-
-大模型(GLM-4.7): 负责任务分析、决策制定、内容生成
-小模型(autoglm-phone): 负责屏幕识别、动作执行
-"""
-
-from .decision_model import (
-    DecisionModel,
-    Decision,
-    TaskPlan,
-    ActionSequence,
-    ActionStep,
-)
-from .vision_model import VisionModel, ScreenDescription, ExecutionResult
-from .dual_agent import DualModelAgent, DualModelCallbacks
-from .protocols import (
-    DualModelConfig,
-    DecisionModelConfig,
-    DualModelState,
-    DualModelEvent,
-    DualModelEventType,
-    ModelRole,
-    ModelStage,
-    ThinkingMode,
-    DECISION_SYSTEM_PROMPT,
-    DECISION_SYSTEM_PROMPT_TURBO,
-    VISION_DESCRIBE_PROMPT,
-)
-
-__all__ = [
-    "DecisionModel",
-    "Decision",
-    "TaskPlan",
-    "ActionSequence",
-    "ActionStep",
-    "VisionModel",
-    "ScreenDescription",
-    "ExecutionResult",
-    "DualModelAgent",
-    "DualModelCallbacks",
-    "DualModelConfig",
-    "DecisionModelConfig",
-    "DualModelState",
-    "DualModelEvent",
-    "DualModelEventType",
-    "ModelRole",
-    "ModelStage",
-    "ThinkingMode",
-    "DECISION_SYSTEM_PROMPT",
-    "DECISION_SYSTEM_PROMPT_TURBO",
-    "VISION_DESCRIBE_PROMPT",
-]