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

AutoGLM_GUI/phone_agent_manager.py

@@ -9,6 +9,8 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import TYPE_CHECKING, Callable, Optional
 
+from AutoGLM_GUI.agents.protocols import BaseAgent
+from AutoGLM_GUI.types import AgentSpecificConfig
 from AutoGLM_GUI.exceptions import (
     AgentInitializationError,
     AgentNotInitializedError,
@@ -17,7 +19,6 @@ from AutoGLM_GUI.exceptions import (
 from AutoGLM_GUI.logger import logger
 
 if TYPE_CHECKING:
-    from phone_agent import PhoneAgent
     from phone_agent.agent import AgentConfig
     from phone_agent.model import ModelConfig
 
@@ -46,10 +47,8 @@ class AgentMetadata:
 
 @dataclass
 class StreamingAgentContext:
-    """Streaming agent 会话上下文."""
-
-    streaming_agent: "PhoneAgent"
-    original_agent: "PhoneAgent"
+    streaming_agent: BaseAgent
+    original_agent: BaseAgent
     stop_event: threading.Event
 
 
@@ -95,11 +94,9 @@ class PhoneAgentManager:
         self._device_locks_lock = threading.Lock()
 
         # Agent metadata (indexed by device_id)
+        # State is stored in AgentMetadata.state (single source of truth)
         self._metadata: dict[str, AgentMetadata] = {}
 
-        # State tracking
-        self._states: dict[str, AgentState] = {}
-
         # Streaming agent state (device_id -> StreamingAgentContext)
         self._streaming_contexts: dict[str, StreamingAgentContext] = {}
         self._streaming_contexts_lock = threading.Lock()
@@ -107,6 +104,10 @@ class PhoneAgentManager:
         # Abort events (device_id -> threading.Event)
         self._abort_events: dict[str, threading.Event] = {}
 
+        # Agent storage (transition from global state to instance state)
+        self._agents: dict[str, BaseAgent] = {}
+        self._agent_configs: dict[str, tuple["ModelConfig", "AgentConfig"]] = {}
+
     @classmethod
     def get_instance(cls) -> PhoneAgentManager:
         """Get singleton instance (thread-safe, double-checked locking)."""
@@ -122,11 +123,11 @@ class PhoneAgentManager:
     def initialize_agent(
         self,
         device_id: str,
-        model_config: ModelConfig,
-        agent_config: AgentConfig,
+        model_config: "ModelConfig",
+        agent_config: "AgentConfig",
         takeover_callback: Optional[Callable] = None,
         force: bool = False,
-    ) -> PhoneAgent:
+    ) -> BaseAgent:
         """
         Initialize PhoneAgent for a device (thread-safe, idempotent).
 
@@ -148,15 +149,14 @@ class PhoneAgentManager:
             - On failure, state is rolled back
             - state.agents and state.agent_configs remain consistent
         """
+        from AutoGLM_GUI.state import non_blocking_takeover
         from phone_agent import PhoneAgent
 
-        from AutoGLM_GUI.state import agent_configs, agents, non_blocking_takeover
-
         with self._manager_lock:
             # Check if already initialized
-            if device_id in agents and not force:
+            if device_id in self._agents and not force:
                 logger.debug(f"Agent already initialized for {device_id}")
-                return agents[device_id]
+                return self._agents[device_id]
 
             # Check device availability (non-blocking check)
             device_lock = self._get_device_lock(device_id)
@@ -165,8 +165,15 @@ class PhoneAgentManager:
                     f"Device {device_id} is currently processing a request"
                 )
 
-            # Set initializing state
-            self._states[device_id] = AgentState.INITIALIZING
+            # Create metadata first with INITIALIZING state
+            self._metadata[device_id] = AgentMetadata(
+                device_id=device_id,
+                state=AgentState.INITIALIZING,
+                model_config=model_config,
+                agent_config=agent_config,
+                created_at=time.time(),
+                last_used=time.time(),
+            )
 
             try:
                 # Create agent
@@ -177,29 +184,119 @@ class PhoneAgentManager:
                 )
 
                 # Store in state (transactional)
-                agents[device_id] = agent
-                agent_configs[device_id] = (model_config, agent_config)
+                self._agents[device_id] = agent
+                self._agent_configs[device_id] = (model_config, agent_config)
+
+                # Update state to IDLE on success
+                self._metadata[device_id].state = AgentState.IDLE
+
+                logger.info(f"Agent initialized for device {device_id}")
+                return agent
+
+            except Exception as e:
+                # Rollback on error
+                self._agents.pop(device_id, None)
+                self._agent_configs.pop(device_id, None)
+                self._metadata[device_id].state = AgentState.ERROR
+                self._metadata[device_id].error_message = str(e)
+
+                logger.error(f"Failed to initialize agent for {device_id}: {e}")
+                raise AgentInitializationError(
+                    f"Failed to initialize agent: {str(e)}"
+                ) from e
+
+    def initialize_agent_with_factory(
+        self,
+        device_id: str,
+        agent_type: str,
+        model_config: ModelConfig,
+        agent_config: AgentConfig,
+        agent_specific_config: AgentSpecificConfig,
+        takeover_callback: Optional[Callable] = None,
+        confirmation_callback: Optional[Callable] = None,
+        force: bool = False,
+    ) -> "BaseAgent":
+        """
+        Initialize agent using factory pattern (thread-safe, idempotent).
+
+        This method uses the agent factory to create agents dynamically based on agent_type.
+        New agent types can be added without modifying this method by registering them.
+
+        Args:
+            device_id: Device identifier (USB serial / IP:port)
+            agent_type: Type of agent to create (e.g., "phone", "mai")
+            model_config: Model configuration
+            agent_config: Agent configuration
+            agent_specific_config: Agent-specific configuration dict
+            takeover_callback: Optional takeover callback
+            confirmation_callback: Optional confirmation callback
+            force: Force re-initialization even if agent exists
+
+        Returns:
+            BaseAgent: Initialized agent instance
+
+        Raises:
+            AgentInitializationError: If initialization fails
+            DeviceBusyError: If device is currently processing
+
+        Transactional Guarantee:
+            - On failure, state is rolled back
+            - state.agents and state.agent_configs remain consistent
+        """
+        from AutoGLM_GUI.agents import create_agent
+
+        with self._manager_lock:
+            # Check if already initialized
+            if device_id in self._agents and not force:
+                logger.debug(f"Agent already initialized for {device_id}")
+                return self._agents[device_id]
+
+            # Check device availability (non-blocking check)
+            device_lock = self._get_device_lock(device_id)
+            if device_lock.locked():
+                raise DeviceBusyError(
+                    f"Device {device_id} is currently processing a request"
+                )
+
+            # Create metadata first with INITIALIZING state
+            self._metadata[device_id] = AgentMetadata(
+                device_id=device_id,
+                state=AgentState.INITIALIZING,
+                model_config=model_config,
+                agent_config=agent_config,
+                created_at=time.time(),
+                last_used=time.time(),
+            )
 
-                # Update metadata
-                self._metadata[device_id] = AgentMetadata(
-                    device_id=device_id,
-                    state=AgentState.IDLE,
+            try:
+                # Create agent using factory
+                agent = create_agent(
+                    agent_type=agent_type,
                     model_config=model_config,
                     agent_config=agent_config,
-                    created_at=time.time(),
-                    last_used=time.time(),
+                    agent_specific_config=agent_specific_config,
+                    takeover_callback=takeover_callback,
+                    confirmation_callback=confirmation_callback,
                 )
-                self._states[device_id] = AgentState.IDLE
 
-                logger.info(f"Agent initialized for device {device_id}")
+                # Store in state (transactional)
+                self._agents[device_id] = agent
+                self._agent_configs[device_id] = (model_config, agent_config)
+
+                # Update state to IDLE on success
+                self._metadata[device_id].state = AgentState.IDLE
+
+                logger.info(
+                    f"Agent of type '{agent_type}' initialized for device {device_id}"
+                )
                 return agent
 
             except Exception as e:
                 # Rollback on error
-                agents.pop(device_id, None)
-                agent_configs.pop(device_id, None)
-                self._metadata.pop(device_id, None)
-                self._states[device_id] = AgentState.ERROR
+                self._agents.pop(device_id, None)
+                self._agent_configs.pop(device_id, None)
+                self._metadata[device_id].state = AgentState.ERROR
+                self._metadata[device_id].error_message = str(e)
 
                 logger.error(f"Failed to initialize agent for {device_id}: {e}")
                 raise AgentInitializationError(
@@ -208,41 +305,61 @@ class PhoneAgentManager:
 
     def _create_streaming_agent(
         self,
-        model_config: "ModelConfig",
-        agent_config: "AgentConfig",
+        device_id: str,
+        original_agent: "BaseAgent",
         on_thinking_chunk: Callable[[str], None],
-    ) -> "PhoneAgent":
+    ) -> "BaseAgent":
         """
-        创建支持流式输出的 PhoneAgent（monkey-patched model_client）.
+        创建支持流式输出的 agent（复制原始 agent）.
 
         Args:
-            model_config: 模型配置
-            agent_config: Agent 配置
+            device_id: 设备标识符
+            original_agent: 原始 agent 实例
             on_thinking_chunk: 思考块回调函数
 
         Returns:
-            已 patch 的 PhoneAgent 实例
+            已 patch 的 agent 实例
         """
+        from AutoGLM_GUI.agents.mai_adapter import MAIAgentAdapter
         from phone_agent import PhoneAgent
 
-        from AutoGLM_GUI.state import non_blocking_takeover
+        model_config, agent_config = self.get_config(device_id)
 
-        # 创建 agent
-        agent = PhoneAgent(
-            model_config=model_config,
-            agent_config=agent_config,
-            takeover_callback=non_blocking_takeover,
-        )
+        streaming_agent: BaseAgent
+        if isinstance(original_agent, MAIAgentAdapter):
+            streaming_agent = MAIAgentAdapter(
+                model_config=model_config,
+                agent_config=agent_config,
+                mai_config=original_agent.mai_config,
+                takeover_callback=original_agent.action_handler.takeover_callback,
+                confirmation_callback=original_agent.action_handler.confirmation_callback,
+                on_thinking_chunk=on_thinking_chunk,
+            )
+            streaming_agent.mai_agent.traj_memory = original_agent.mai_agent.traj_memory
+            streaming_agent._step_count = original_agent._step_count
+            streaming_agent._current_instruction = original_agent._current_instruction
+        elif isinstance(original_agent, PhoneAgent):
+            from AutoGLM_GUI.state import non_blocking_takeover
+
+            phone_streaming_agent = PhoneAgent(
+                model_config=model_config,
+                agent_config=agent_config,
+                takeover_callback=non_blocking_takeover,
+            )
 
-        # Monkey-patch model_client.request 以支持流式回调
-        original_request = agent.model_client.request
+            original_request = phone_streaming_agent.model_client.request
 
-        def patched_request(messages, **kwargs):
-            return original_request(messages, on_thinking_chunk=on_thinking_chunk)
+            def patched_request(messages, **kwargs):  # type: ignore[no-untyped-def]
+                return original_request(messages, on_thinking_chunk=on_thinking_chunk)  # type: ignore[call-arg]
 
-        agent.model_client.request = patched_request
+            phone_streaming_agent.model_client.request = patched_request  # type: ignore[method-assign]
+            phone_streaming_agent._context = original_agent._context.copy()
+            phone_streaming_agent._step_count = original_agent._step_count
+            streaming_agent = phone_streaming_agent
+        else:
+            raise ValueError(f"Unknown agent type: {type(original_agent)}")
 
-        return agent
+        return streaming_agent
 
     @contextmanager
     def use_streaming_agent(
@@ -297,21 +414,16 @@ class PhoneAgentManager:
                 auto_initialize=auto_initialize,
             )
 
-            # 获取原始 agent 和配置
+            # 获取原始 agent
             original_agent = self.get_agent(device_id)
-            model_config, agent_config = self.get_config(device_id)
 
-            # 创建 streaming agent
+            # 创建 streaming agent（自动检测类型）
             streaming_agent = self._create_streaming_agent(
-                model_config=model_config,
-                agent_config=agent_config,
+                device_id=device_id,
+                original_agent=original_agent,
                 on_thinking_chunk=on_thinking_chunk,
             )
 
-            # 复制上下文（由于持有设备锁，线程安全）
-            streaming_agent._context = original_agent._context.copy()
-            streaming_agent._step_count = original_agent._step_count
-
             # 注册 abort 事件
             with self._streaming_contexts_lock:
                 self._abort_events[device_id] = stop_event
@@ -326,12 +438,28 @@ class PhoneAgentManager:
             yield streaming_agent, stop_event
 
         finally:
-            # 同步状态回原始 agent
             if streaming_agent and not stop_event.is_set():
                 original_agent = self.get_agent_safe(device_id)
                 if original_agent:
-                    original_agent._context = streaming_agent._context
-                    original_agent._step_count = streaming_agent._step_count
+                    from AutoGLM_GUI.agents.mai_adapter import MAIAgentAdapter
+                    from phone_agent import PhoneAgent
+
+                    if isinstance(original_agent, MAIAgentAdapter) and isinstance(
+                        streaming_agent, MAIAgentAdapter
+                    ):
+                        original_agent.mai_agent.traj_memory = (
+                            streaming_agent.mai_agent.traj_memory
+                        )
+                        original_agent._step_count = streaming_agent._step_count
+                        original_agent._current_instruction = (
+                            streaming_agent._current_instruction
+                        )
+                    elif isinstance(original_agent, PhoneAgent) and isinstance(
+                        streaming_agent, PhoneAgent
+                    ):
+                        original_agent._context = streaming_agent._context
+                        original_agent._step_count = streaming_agent._step_count
+
                     logger.debug(
                         f"Synchronized context back to original agent for {device_id}"
                     )
@@ -355,18 +483,15 @@ class PhoneAgentManager:
         Raises:
             AgentInitializationError: 如果配置不完整或初始化失败
         """
+        from AutoGLM_GUI.config_manager import config_manager
         from phone_agent.agent import AgentConfig
         from phone_agent.model import ModelConfig
 
-        from AutoGLM_GUI.config import config
-        from AutoGLM_GUI.config_manager import config_manager
-
         logger.info(f"Auto-initializing agent for device {device_id}...")
 
         # 热重载配置
         config_manager.load_file_config()
         config_manager.sync_to_env()
-        config.refresh_from_env()
 
         effective_config = config_manager.get_effective_config()
 
@@ -388,43 +513,15 @@ class PhoneAgentManager:
         self.initialize_agent(device_id, model_config, agent_config)
         logger.info(f"Agent auto-initialized for device {device_id}")
 
-    def get_agent(self, device_id: str) -> PhoneAgent:
-        """
-        Get initialized agent for a device.
-
-        Auto-initializes the agent using global config if not already initialized.
-
-        Args:
-            device_id: Device identifier
-
-        Returns:
-            PhoneAgent: Agent instance
-
-        Raises:
-            AgentInitializationError: If agent not initialized and auto-init fails
-        """
-        from AutoGLM_GUI.state import agents
-
+    def get_agent(self, device_id: str) -> BaseAgent:
         with self._manager_lock:
-            if device_id not in agents:
-                # 自动初始化：使用全局配置
+            if device_id not in self._agents:
                 self._auto_initialize_agent(device_id)
-            return agents[device_id]
-
-    def get_agent_safe(self, device_id: str) -> Optional[PhoneAgent]:
-        """
-        Get initialized agent for a device (safe version, no exception).
-
-        Args:
-            device_id: Device identifier
-
-        Returns:
-            PhoneAgent or None: Agent instance or None if not initialized
-        """
-        from AutoGLM_GUI.state import agents
+            return self._agents[device_id]
 
+    def get_agent_safe(self, device_id: str) -> Optional[BaseAgent]:
         with self._manager_lock:
-            return agents.get(device_id)
+            return self._agents.get(device_id)
 
     def reset_agent(self, device_id: str) -> None:
         """
@@ -436,28 +533,27 @@ class PhoneAgentManager:
         Raises:
             AgentNotInitializedError: If agent not initialized
         """
+        from AutoGLM_GUI.state import non_blocking_takeover
         from phone_agent import PhoneAgent
 
-        from AutoGLM_GUI.state import agent_configs, agents, non_blocking_takeover
-
         with self._manager_lock:
-            if device_id not in agents:
+            if device_id not in self._agents:
                 raise AgentNotInitializedError(
                     f"Agent not initialized for device {device_id}"
                 )
 
             # Get cached config
-            if device_id not in agent_configs:
+            if device_id not in self._agent_configs:
                 logger.warning(
                     f"No cached config for {device_id}, only resetting agent state"
                 )
-                agents[device_id].reset()
+                self._agents[device_id].reset()
                 return
 
             # Rebuild agent from cached config
-            model_config, agent_config = agent_configs[device_id]
+            model_config, agent_config = self._agent_configs[device_id]
 
-            agents[device_id] = PhoneAgent(
+            self._agents[device_id] = PhoneAgent(
                 model_config=model_config,
                 agent_config=agent_config,
                 takeover_callback=non_blocking_takeover,
@@ -467,8 +563,7 @@ class PhoneAgentManager:
             if device_id in self._metadata:
                 self._metadata[device_id].last_used = time.time()
                 self._metadata[device_id].error_message = None
-
-            self._states[device_id] = AgentState.IDLE
+                self._metadata[device_id].state = AgentState.IDLE
 
             logger.info(f"Agent reset for device {device_id}")
 
@@ -479,11 +574,9 @@ class PhoneAgentManager:
         Args:
             device_id: Device identifier
         """
-        from AutoGLM_GUI.state import agent_configs, agents
-
         with self._manager_lock:
             # Remove agent
-            agent = agents.pop(device_id, None)
+            agent = self._agents.pop(device_id, None)
             if agent:
                 try:
                     agent.reset()  # Clean up agent state
@@ -491,20 +584,17 @@ class PhoneAgentManager:
                     logger.warning(f"Error resetting agent during destroy: {e}")
 
             # Remove config
-            agent_configs.pop(device_id, None)
+            self._agent_configs.pop(device_id, None)
 
             # Remove metadata
             self._metadata.pop(device_id, None)
-            self._states.pop(device_id, None)
 
             logger.info(f"Agent destroyed for device {device_id}")
 
     def is_initialized(self, device_id: str) -> bool:
         """Check if agent is initialized for device."""
-        from AutoGLM_GUI.state import agents
-
         with self._manager_lock:
-            return device_id in agents
+            return device_id in self._agents
 
     # ==================== Concurrency Control ====================
 
@@ -582,8 +672,8 @@ class PhoneAgentManager:
         if acquired:
             # Update state
             with self._manager_lock:
-                self._states[device_id] = AgentState.BUSY
                 if device_id in self._metadata:
+                    self._metadata[device_id].state = AgentState.BUSY
                     self._metadata[device_id].last_used = time.time()
 
             logger.debug(f"Device lock acquired for {device_id}")
@@ -610,7 +700,8 @@ class PhoneAgentManager:
 
             # Update state
             with self._manager_lock:
-                self._states[device_id] = AgentState.IDLE
+                if device_id in self._metadata:
+                    self._metadata[device_id].state = AgentState.IDLE
 
             logger.debug(f"Device lock released for {device_id}")
 
@@ -671,13 +762,14 @@ class PhoneAgentManager:
     def get_state(self, device_id: str) -> AgentState:
         """Get current agent state."""
         with self._manager_lock:
-            return self._states.get(device_id, AgentState.ERROR)
+            metadata = self._metadata.get(device_id)
+            return metadata.state if metadata else AgentState.ERROR
 
     def set_error_state(self, device_id: str, error_message: str) -> None:
         """Mark agent as errored."""
         with self._manager_lock:
-            self._states[device_id] = AgentState.ERROR
             if device_id in self._metadata:
+                self._metadata[device_id].state = AgentState.ERROR
                 self._metadata[device_id].error_message = error_message
 
             logger.error(f"Agent error for {device_id}: {error_message}")
@@ -686,14 +778,12 @@ class PhoneAgentManager:
 
     def get_config(self, device_id: str) -> tuple[ModelConfig, AgentConfig]:
         """Get cached configuration for device."""
-        from AutoGLM_GUI.state import agent_configs
-
         with self._manager_lock:
-            if device_id not in agent_configs:
+            if device_id not in self._agent_configs:
                 raise AgentNotInitializedError(
                     f"No configuration found for device {device_id}"
                 )
-            return agent_configs[device_id]
+            return self._agent_configs[device_id]
 
     def update_config(
         self,
@@ -709,15 +799,13 @@ class PhoneAgentManager:
             model_config: New model config (None = keep existing)
             agent_config: New agent config (None = keep existing)
         """
-        from AutoGLM_GUI.state import agent_configs
-
         with self._manager_lock:
-            if device_id not in agent_configs:
+            if device_id not in self._agent_configs:
                 raise AgentNotInitializedError(
                     f"No configuration found for device {device_id}"
                 )
 
-            old_model_config, old_agent_config = agent_configs[device_id]
+            old_model_config, old_agent_config = self._agent_configs[device_id]
 
             new_model_config = model_config or old_model_config
             new_agent_config = agent_config or old_agent_config
@@ -743,7 +831,6 @@ class PhoneAgentManager:
             Optional[str]: device_id of initialized agent, or None
         """
         from AutoGLM_GUI.device_manager import DeviceManager
-        from AutoGLM_GUI.state import agents
 
         with self._manager_lock:
             # Get device by serial from DeviceManager
@@ -755,7 +842,7 @@ class PhoneAgentManager:
 
             # Check all connections for initialized agents
             for conn in device.connections:
-                if conn.device_id in agents:
+                if conn.device_id in self._agents:
                     return conn.device_id
 
             return None
@@ -764,10 +851,8 @@ class PhoneAgentManager:
 
     def list_agents(self) -> list[str]:
         """Get list of all initialized device IDs."""
-        from AutoGLM_GUI.state import agents
-
         with self._manager_lock:
-            return list(agents.keys())
+            return list(self._agents.keys())
 
     def get_metadata(self, device_id: str) -> Optional[AgentMetadata]:
         """Get agent metadata."""

AutoGLM_GUI/phone_agent_patches.py

@@ -7,6 +7,7 @@ This module patches the upstream phone_agent code without modifying the original
 from typing import Any, Callable
 
 from phone_agent.model import ModelClient
+from phone_agent.model.client import ModelResponse
 
 
 # Store original methods
@@ -17,7 +18,7 @@ def _patched_model_request(
     self,
     messages: list[dict[str, Any]],
     on_thinking_chunk: Callable[[str], None] | None = None,
-) -> Any:
+) -> ModelResponse:
     """
     Patched version of ModelClient.request that supports streaming thinking chunks.
 

AutoGLM_GUI/platform_utils.py

@@ -3,7 +3,8 @@
 import asyncio
 import platform
 import subprocess
-from typing import Any, Sequence
+from asyncio.subprocess import Process as AsyncProcess
+from typing import Sequence
 
 
 def is_windows() -> bool:
@@ -51,7 +52,9 @@ async def run_cmd_silently(cmd: Sequence[str]) -> subprocess.CompletedProcess:
     return subprocess.CompletedProcess(cmd, return_code, stdout_str, stderr_str)
 
 
-async def spawn_process(cmd: Sequence[str], *, capture_output: bool = False) -> Any:
+async def spawn_process(
+    cmd: Sequence[str], *, capture_output: bool = False
+) -> subprocess.Popen[bytes] | AsyncProcess:
     """Start a long-running process with optional stdio capture."""
     stdout = subprocess.PIPE if capture_output else None
     stderr = subprocess.PIPE if capture_output else None

AutoGLM_GUI/prompts.py

@@ -11,7 +11,12 @@ from datetime import datetime
 today = datetime.today()
 weekday_names = ["星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"]
 weekday = weekday_names[today.weekday()]
-formatted_date = today.strftime("%Y年%m月%d日") + " " + weekday
+# NOTE: Do NOT use strftime with Chinese characters in format string!
+# On some Windows systems with non-UTF-8 locale (e.g., GBK/CP936),
+# strftime("%Y年%m月%d日") raises UnicodeEncodeError because the C library's
+# strftime uses locale encoding, not Python's UTF-8 mode.
+# Use f-string instead to avoid this issue completely.
+formatted_date = f"{today.year}年{today.month:02d}月{today.day:02d}日 {weekday}"
 
 MCP_SYSTEM_PROMPT_ZH = f"""
 # Context