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

AutoGLM_GUI/metrics.py

@@ -0,0 +1,283 @@
+"""Prometheus metrics collector for AutoGLM-GUI."""
+
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING
+
+from prometheus_client.core import CollectorRegistry, GaugeMetricFamily
+from prometheus_client.registry import Collector
+
+if TYPE_CHECKING:
+    from prometheus_client.core import Metric
+
+from AutoGLM_GUI.logger import logger
+from AutoGLM_GUI.version import APP_VERSION
+
+
+class AutoGLMMetricsCollector(Collector):
+    """
+    Custom Prometheus collector for AutoGLM-GUI metrics.
+
+    Implements on-demand metric collection to avoid:
+    - Stale metric data
+    - Memory leaks from unbounded label cardinality
+    - Complexity of background metric updates
+
+    Thread Safety:
+    - Acquires manager locks during collect() only
+    - Read-only operations (no state modification)
+    - Uses shallow copies where needed
+    """
+
+    def collect(self) -> list[Metric]:
+        """
+        Called by Prometheus client on each scrape.
+
+        Returns:
+            List of MetricFamily objects
+        """
+        metrics = []
+
+        try:
+            # Agent metrics
+            metrics.extend(self._collect_agent_metrics())
+
+            # Device metrics
+            metrics.extend(self._collect_device_metrics())
+
+            # Build info
+            metrics.append(self._collect_build_info())
+
+        except Exception as e:
+            logger.error(f"Error collecting Prometheus metrics: {e}")
+
+        return metrics
+
+    def _collect_agent_metrics(self) -> list[Metric]:
+        """Collect agent-related metrics (high priority only)."""
+        from AutoGLM_GUI.device_manager import DeviceManager
+        from AutoGLM_GUI.phone_agent_manager import AgentState, PhoneAgentManager
+
+        metrics = []
+        manager = PhoneAgentManager.get_instance()
+        device_manager = DeviceManager.get_instance()
+
+        # Metric 1: autoglm_agents_total (per-agent state)
+        agents_gauge = GaugeMetricFamily(
+            "autoglm_agents_total",
+            "Agent state by device",
+            labels=["device_id", "serial", "state"],
+        )
+
+        # Metric 4: autoglm_agent_last_used_timestamp_seconds
+        last_used_gauge = GaugeMetricFamily(
+            "autoglm_agent_last_used_timestamp_seconds",
+            "Agent last used timestamp",
+            labels=["device_id", "serial"],
+        )
+
+        # Metric 5: autoglm_agent_created_timestamp_seconds
+        created_gauge = GaugeMetricFamily(
+            "autoglm_agent_created_timestamp_seconds",
+            "Agent creation timestamp",
+            labels=["device_id", "serial"],
+        )
+
+        busy_count = 0
+
+        with manager._manager_lock:
+            # Get snapshots (shallow copy to minimize lock time)
+            metadata_snapshot = dict(manager._metadata)
+            states_snapshot = dict(manager._states)
+
+        # Iterate over _states (not _metadata) to capture failed agents
+        for device_id, state in states_snapshot.items():
+            # Get metadata if exists (will be None for failed initialization)
+            metadata = metadata_snapshot.get(device_id)
+
+            # Get serial from DeviceManager
+            with device_manager._devices_lock:
+                device = device_manager.get_device_by_device_id(device_id)
+                serial = device.serial if device else "unknown"
+
+            # Per-agent state (1 for actual state, 0 for others)
+            for agent_state in AgentState:
+                value = 1 if state == agent_state else 0
+                agents_gauge.add_metric(
+                    [device_id, serial, agent_state.value],
+                    value,
+                )
+
+            # Count busy agents
+            if state == AgentState.BUSY:
+                busy_count += 1
+
+            # Timestamps (0 if metadata doesn't exist, e.g., failed init)
+            if metadata:
+                last_used_gauge.add_metric(
+                    [device_id, serial],
+                    metadata.last_used,
+                )
+                created_gauge.add_metric(
+                    [device_id, serial],
+                    metadata.created_at,
+                )
+            else:
+                # Failed initialization: report 0 timestamps
+                last_used_gauge.add_metric([device_id, serial], 0)
+                created_gauge.add_metric([device_id, serial], 0)
+
+        metrics.extend([agents_gauge, last_used_gauge, created_gauge])
+
+        # Metric 2: autoglm_agents_busy_count
+        busy_gauge = GaugeMetricFamily(
+            "autoglm_agents_busy_count",
+            "Number of busy agents",
+        )
+        busy_gauge.add_metric([], busy_count)
+        metrics.append(busy_gauge)
+
+        # Metric 3: autoglm_streaming_sessions_active
+        with manager._streaming_contexts_lock:
+            streaming_count = len(manager._streaming_contexts)
+
+        streaming_gauge = GaugeMetricFamily(
+            "autoglm_streaming_sessions_active",
+            "Active streaming agent sessions",
+        )
+        streaming_gauge.add_metric([], streaming_count)
+        metrics.append(streaming_gauge)
+
+        return metrics
+
+    def _collect_device_metrics(self) -> list[Metric]:
+        """Collect device-related metrics (high priority only)."""
+        from AutoGLM_GUI.device_manager import DeviceManager, DeviceState
+
+        metrics = []
+        manager = DeviceManager.get_instance()
+
+        # Metric 6: autoglm_devices_total
+        devices_gauge = GaugeMetricFamily(
+            "autoglm_devices_total",
+            "Device state by serial",
+            labels=["serial", "model", "state", "connection_type", "status"],
+        )
+
+        # Metric 8: autoglm_device_connections_total
+        connections_gauge = GaugeMetricFamily(
+            "autoglm_device_connections_total",
+            "Connection count by type",
+            labels=["serial", "connection_type", "status"],
+        )
+
+        # Metric 10: autoglm_device_last_seen_timestamp_seconds
+        last_seen_gauge = GaugeMetricFamily(
+            "autoglm_device_last_seen_timestamp_seconds",
+            "Device last seen timestamp",
+            labels=["serial", "model"],
+        )
+
+        online_count = 0
+        unauthorized_count = 0
+
+        with manager._devices_lock:
+            devices_snapshot = list(manager._devices.values())
+
+        # Process connected devices
+        for device in devices_snapshot:
+            model = device.model or "unknown"
+
+            # Per-device state
+            for dev_state in DeviceState:
+                value = 1 if device.state == dev_state else 0
+                devices_gauge.add_metric(
+                    [
+                        device.serial,
+                        model,
+                        dev_state.value,
+                        device.connection_type.value,
+                        device.status,
+                    ],
+                    value,
+                )
+
+            # Count online devices
+            if device.state == DeviceState.ONLINE:
+                online_count += 1
+
+            # Connection breakdown
+            for conn in device.connections:
+                connections_gauge.add_metric(
+                    [device.serial, conn.connection_type.value, conn.status],
+                    1,  # Each connection counts as 1
+                )
+
+                if conn.status == "unauthorized":
+                    unauthorized_count += 1
+
+            # Last seen timestamp
+            last_seen_gauge.add_metric([device.serial, model], device.last_seen)
+
+        metrics.extend(
+            [
+                devices_gauge,
+                connections_gauge,
+                last_seen_gauge,
+            ]
+        )
+
+        # Metric 7: autoglm_devices_online_count
+        online_gauge = GaugeMetricFamily(
+            "autoglm_devices_online_count",
+            "Number of online devices",
+        )
+        online_gauge.add_metric([], online_count)
+        metrics.append(online_gauge)
+
+        # Metric 9: autoglm_device_unauthorized_connections_total
+        unauth_gauge = GaugeMetricFamily(
+            "autoglm_device_unauthorized_connections_total",
+            "Total unauthorized connections",
+        )
+        unauth_gauge.add_metric([], unauthorized_count)
+        metrics.append(unauth_gauge)
+
+        return metrics
+
+    def _collect_build_info(self) -> Metric:
+        """Collect build information."""
+        build_info = GaugeMetricFamily(
+            "autoglm_build_info",
+            "Build information",
+            labels=["version", "python_version"],
+        )
+
+        python_version = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+        build_info.add_metric([APP_VERSION, python_version], 1)
+
+        return build_info
+
+
+# Global collector instance (registered once)
+_collector_registry: CollectorRegistry | None = None
+_collector_instance: AutoGLMMetricsCollector | None = None
+
+
+def get_metrics_registry() -> CollectorRegistry:
+    """
+    Get or create the Prometheus registry with AutoGLM collector.
+
+    Returns:
+        CollectorRegistry: Registry instance for prometheus_client
+    """
+    global _collector_registry, _collector_instance
+
+    if _collector_registry is None:
+        _collector_registry = CollectorRegistry()
+        _collector_instance = AutoGLMMetricsCollector()
+        _collector_registry.register(_collector_instance)
+        logger.info("Prometheus metrics collector registered")
+
+    return _collector_registry

AutoGLM_GUI/phone_agent_manager.py

@@ -44,6 +44,15 @@ class AgentMetadata:
     error_message: Optional[str] = None
 
 
+@dataclass
+class StreamingAgentContext:
+    """Streaming agent 会话上下文."""
+
+    streaming_agent: "PhoneAgent"
+    original_agent: "PhoneAgent"
+    stop_event: threading.Event
+
+
 class PhoneAgentManager:
     """
     Singleton manager for PhoneAgent lifecycle and concurrency control.
@@ -91,6 +100,13 @@ class PhoneAgentManager:
         # 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()
+
+        # Abort events (device_id -> threading.Event)
+        self._abort_events: dict[str, threading.Event] = {}
+
     @classmethod
     def get_instance(cls) -> PhoneAgentManager:
         """Get singleton instance (thread-safe, double-checked locking)."""
@@ -190,10 +206,194 @@ class PhoneAgentManager:
                     f"Failed to initialize agent: {str(e)}"
                 ) from e
 
+    def _create_streaming_agent(
+        self,
+        model_config: "ModelConfig",
+        agent_config: "AgentConfig",
+        on_thinking_chunk: Callable[[str], None],
+    ) -> "PhoneAgent":
+        """
+        创建支持流式输出的 PhoneAgent（monkey-patched model_client）.
+
+        Args:
+            model_config: 模型配置
+            agent_config: Agent 配置
+            on_thinking_chunk: 思考块回调函数
+
+        Returns:
+            已 patch 的 PhoneAgent 实例
+        """
+        from phone_agent import PhoneAgent
+
+        from AutoGLM_GUI.state import non_blocking_takeover
+
+        # 创建 agent
+        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
+
+        def patched_request(messages, **kwargs):
+            return original_request(messages, on_thinking_chunk=on_thinking_chunk)
+
+        agent.model_client.request = patched_request
+
+        return agent
+
+    @contextmanager
+    def use_streaming_agent(
+        self,
+        device_id: str,
+        on_thinking_chunk: Callable[[str], None],
+        timeout: Optional[float] = None,
+        auto_initialize: bool = True,
+    ):
+        """
+        Context manager for streaming-enabled agent with automatic:
+        - 设备锁获取/释放
+        - Streaming agent 创建（带 monkey-patch）
+        - 上下文隔离和同步
+        - Abort 事件注册/清理
+
+        By default, automatically initializes the agent using global configuration
+        if not already initialized. Set auto_initialize=False to require explicit
+        initialization via initialize_agent().
+
+        Args:
+            device_id: 设备标识符
+            on_thinking_chunk: 流式思考块回调函数
+            timeout: 锁获取超时时间（None=阻塞，0=非阻塞）
+            auto_initialize: 自动初始化（默认: True）
+
+        Yields:
+            tuple[PhoneAgent, threading.Event]: (streaming_agent, stop_event)
+
+        Raises:
+            DeviceBusyError: 设备忙
+            AgentNotInitializedError: Agent 未初始化且 auto_initialize=False
+            AgentInitializationError: auto_initialize=True 且初始化失败
+
+        Example:
+            >>> def on_chunk(chunk: str):
+            >>>     print(chunk, end='', flush=True)
+            >>>
+            >>> with manager.use_streaming_agent("device_123", on_chunk) as (agent, stop_event):
+            >>>     result = agent.step("Open WeChat")
+        """
+        acquired = False
+        streaming_agent = None
+        stop_event = threading.Event()
+
+        try:
+            # 获取设备锁（默认非阻塞）
+            acquired = self.acquire_device(
+                device_id,
+                timeout=timeout if timeout is not None else 0,
+                raise_on_timeout=True,
+                auto_initialize=auto_initialize,
+            )
+
+            # 获取原始 agent 和配置
+            original_agent = self.get_agent(device_id)
+            model_config, agent_config = self.get_config(device_id)
+
+            # 创建 streaming agent
+            streaming_agent = self._create_streaming_agent(
+                model_config=model_config,
+                agent_config=agent_config,
+                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
+                self._streaming_contexts[device_id] = StreamingAgentContext(
+                    streaming_agent=streaming_agent,
+                    original_agent=original_agent,
+                    stop_event=stop_event,
+                )
+
+            logger.debug(f"Streaming agent created for {device_id}")
+
+            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
+                    logger.debug(
+                        f"Synchronized context back to original agent for {device_id}"
+                    )
+
+            # 清理 abort 事件注册
+            with self._streaming_contexts_lock:
+                self._abort_events.pop(device_id, None)
+                self._streaming_contexts.pop(device_id, None)
+
+            # 释放设备锁
+            if acquired:
+                self.release_device(device_id)
+
+    def _auto_initialize_agent(self, device_id: str) -> None:
+        """
+        使用全局配置自动初始化 agent（内部方法，需在 manager_lock 内调用）.
+
+        Args:
+            device_id: 设备标识符
+
+        Raises:
+            AgentInitializationError: 如果配置不完整或初始化失败
+        """
+        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()
+
+        if not effective_config.base_url:
+            raise AgentInitializationError(
+                f"Cannot auto-initialize agent for {device_id}: base_url not configured. "
+                f"Please configure base_url via /api/config or call /api/init explicitly."
+            )
+
+        model_config = ModelConfig(
+            base_url=effective_config.base_url,
+            api_key=effective_config.api_key,
+            model_name=effective_config.model_name,
+        )
+
+        agent_config = AgentConfig(device_id=device_id)
+
+        # 调用 initialize_agent（RLock 支持重入，不会死锁）
+        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
 
@@ -201,16 +401,14 @@ class PhoneAgentManager:
             PhoneAgent: Agent instance
 
         Raises:
-            AgentNotInitializedError: If agent not initialized
+            AgentInitializationError: If agent not initialized and auto-init fails
         """
         from AutoGLM_GUI.state import agents
 
         with self._manager_lock:
             if device_id not in agents:
-                raise AgentNotInitializedError(
-                    f"Agent not initialized for device {device_id}. "
-                    f"Call /api/init first."
-                )
+                # 自动初始化：使用全局配置
+                self._auto_initialize_agent(device_id)
             return agents[device_id]
 
     def get_agent_safe(self, device_id: str) -> Optional[PhoneAgent]:
@@ -336,6 +534,7 @@ class PhoneAgentManager:
         device_id: str,
         timeout: Optional[float] = None,
         raise_on_timeout: bool = True,
+        auto_initialize: bool = False,
     ) -> bool:
         """
         Acquire device lock for exclusive access.
@@ -344,19 +543,28 @@ class PhoneAgentManager:
             device_id: Device identifier
             timeout: Lock acquisition timeout (None = blocking, 0 = non-blocking)
             raise_on_timeout: Raise DeviceBusyError on timeout
+            auto_initialize: Auto-initialize agent if not already initialized (default: False)
 
         Returns:
             bool: True if acquired, False if timeout (when raise_on_timeout=False)
 
         Raises:
             DeviceBusyError: If timeout and raise_on_timeout=True
-            AgentNotInitializedError: If agent not initialized
+            AgentNotInitializedError: If agent not initialized AND auto_initialize=False
+            AgentInitializationError: If auto_initialize=True and initialization fails
         """
-        # Verify agent exists
+        # Verify agent exists (with optional auto-initialization)
         if not self.is_initialized(device_id):
-            raise AgentNotInitializedError(
-                f"Agent not initialized for device {device_id}"
-            )
+            if auto_initialize:
+                # Double-check locking pattern for thread safety
+                with self._manager_lock:
+                    if not self.is_initialized(device_id):
+                        self._auto_initialize_agent(device_id)
+            else:
+                raise AgentNotInitializedError(
+                    f"Agent not initialized for device {device_id}. "
+                    f"Use auto_initialize=True or call initialize_agent() first."
+                )
 
         lock = self._get_device_lock(device_id)
 
@@ -407,29 +615,47 @@ class PhoneAgentManager:
             logger.debug(f"Device lock released for {device_id}")
 
     @contextmanager
-    def use_agent(self, device_id: str, timeout: Optional[float] = None):
+    def use_agent(
+        self,
+        device_id: str,
+        timeout: Optional[float] = None,
+        auto_initialize: bool = True,
+    ):
         """
         Context manager for automatic lock acquisition/release.
 
+        By default, automatically initializes the agent using global configuration
+        if not already initialized. Set auto_initialize=False to require explicit
+        initialization via initialize_agent().
+
         Args:
             device_id: Device identifier
             timeout: Lock acquisition timeout
+            auto_initialize: Auto-initialize if not already initialized (default: True)
 
         Yields:
             PhoneAgent: Agent instance
 
         Raises:
             DeviceBusyError: If device is busy
-            AgentNotInitializedError: If agent not initialized
+            AgentNotInitializedError: If agent not initialized AND auto_initialize=False
+            AgentInitializationError: If auto_initialize=True and initialization fails
 
         Example:
             >>> manager = PhoneAgentManager.get_instance()
-            >>> with manager.use_agent("device_123") as agent:
+            >>> with manager.use_agent("device_123") as agent:  # Auto-initializes
             >>>     result = agent.run("Open WeChat")
+            >>> with manager.use_agent("device_123", auto_initialize=False) as agent:
+            >>>     result = agent.run("Open WeChat")  # Requires prior init
         """
         acquired = False
         try:
-            acquired = self.acquire_device(device_id, timeout, raise_on_timeout=True)
+            acquired = self.acquire_device(
+                device_id,
+                timeout,
+                raise_on_timeout=True,
+                auto_initialize=auto_initialize,
+            )
             agent = self.get_agent(device_id)
             yield agent
         except Exception as exc:
@@ -547,3 +773,27 @@ class PhoneAgentManager:
         """Get agent metadata."""
         with self._manager_lock:
             return self._metadata.get(device_id)
+
+    def abort_streaming_chat(self, device_id: str) -> bool:
+        """
+        中止正在进行的流式对话.
+
+        Args:
+            device_id: 设备标识符
+
+        Returns:
+            bool: True 表示发送了中止信号，False 表示没有活跃会话
+        """
+        with self._streaming_contexts_lock:
+            if device_id in self._abort_events:
+                logger.info(f"Aborting streaming chat for device {device_id}")
+                self._abort_events[device_id].set()
+                return True
+            else:
+                logger.warning(f"No active streaming chat for device {device_id}")
+                return False
+
+    def is_streaming_active(self, device_id: str) -> bool:
+        """检查设备是否有活跃的流式会话."""
+        with self._streaming_contexts_lock:
+            return device_id in self._abort_events