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

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/schemas.py

@@ -60,6 +60,27 @@ class InitRequest(BaseModel):
     model: APIModelConfig | None = Field(default=None, alias="model_config")
     agent: APIAgentConfig | None = Field(default=None, alias="agent_config")
 
+    # Agent configuration (factory pattern)
+    agent_type: str = "glm"  # Agent type to use (e.g., "glm", "mai")
+    agent_config_params: dict | None = None  # Agent-specific configuration parameters
+
+    # Hot-reload support
+    force: bool = False  # Force re-initialization even if agent already exists
+
+    @field_validator("agent_type")
+    @classmethod
+    def validate_agent_type(cls, v: str) -> str:
+        """验证 agent_type 有效性."""
+        # Don't import at module level to avoid circular imports
+        from AutoGLM_GUI.agents import is_agent_type_registered
+
+        if not is_agent_type_registered(v):
+            raise ValueError(
+                f"Unknown agent_type: '{v}'. "
+                f"Please register the agent type first or use a known type."
+            )
+        return v
+
 
 class ChatRequest(BaseModel):
     message: str
@@ -326,6 +347,13 @@ class ConfigResponse(BaseModel):
     decision_model_name: str = ""
     decision_api_key: str = ""
 
+    # Agent 类型配置
+    agent_type: str = "glm"  # Agent type (e.g., "glm", "mai")
+    agent_config_params: dict | None = None  # Agent-specific configuration
+
+    # Agent 执行配置
+    default_max_steps: int = 100  # 单次任务最大执行步数
+
     conflicts: list[dict] | None = None  # 配置冲突信息（可选）
 
 
@@ -342,6 +370,25 @@ class ConfigSaveRequest(BaseModel):
     decision_model_name: str | None = None
     decision_api_key: str | None = None
 
+    # Agent 类型配置
+    agent_type: str = "glm"  # Agent type to use (e.g., "glm", "mai")
+    agent_config_params: dict | None = None  # Agent-specific configuration parameters
+
+    # Agent 执行配置
+    default_max_steps: int | None = None  # 单次任务最大执行步数
+
+    @field_validator("default_max_steps")
+    @classmethod
+    def validate_default_max_steps(cls, v: int | None) -> int | None:
+        """验证 default_max_steps 范围."""
+        if v is None:
+            return v
+        if v <= 0:
+            raise ValueError("default_max_steps must be positive")
+        if v > 1000:
+            raise ValueError("default_max_steps must be <= 1000")
+        return v
+
     @field_validator("base_url")
     @classmethod
     def validate_base_url(cls, v: str) -> str:

AutoGLM_GUI/scrcpy_stream.py

@@ -7,7 +7,7 @@ import subprocess
 import sys
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any
+from asyncio.subprocess import Process as AsyncProcess
 
 from AutoGLM_GUI.adb_plus import check_device_available
 from AutoGLM_GUI.logger import logger
@@ -69,7 +69,7 @@ class ScrcpyStreamer:
         self.idr_interval_s = idr_interval_s
         self.stream_options = stream_options or ScrcpyVideoStreamOptions()
 
-        self.scrcpy_process: Any | None = None
+        self.scrcpy_process: subprocess.Popen[bytes] | AsyncProcess | None = None
         self.tcp_socket: socket.socket | None = None
         self.forward_cleanup_needed = False
 
@@ -83,8 +83,9 @@ class ScrcpyStreamer:
     def _find_scrcpy_server(self) -> str:
         """Find scrcpy-server binary path."""
         # Priority 1: PyInstaller bundled path (for packaged executable)
-        if getattr(sys, "_MEIPASS", None):
-            bundled_server = Path(sys._MEIPASS) / "scrcpy-server-v3.3.3"
+        meipass = getattr(sys, "_MEIPASS", None)
+        if meipass:
+            bundled_server = Path(meipass) / "scrcpy-server-v3.3.3"
             if bundled_server.exists():
                 logger.info(f"Using bundled scrcpy-server: {bundled_server}")
                 return str(bundled_server)
@@ -262,14 +263,16 @@ class ScrcpyStreamer:
 
             # Check if process is still running
             error_msg = None
-            if is_windows():
-                if self.scrcpy_process.poll() is not None:
-                    stdout, stderr = self.scrcpy_process.communicate()
-                    error_msg = stderr.decode() if stderr else stdout.decode()
-            else:
-                if self.scrcpy_process.returncode is not None:
-                    stdout, stderr = await self.scrcpy_process.communicate()
-                    error_msg = stderr.decode() if stderr else stdout.decode()
+            proc = self.scrcpy_process
+            if proc is not None:
+                if is_windows():
+                    if proc.poll() is not None:  # type: ignore[union-attr]
+                        stdout, stderr = proc.communicate()  # type: ignore[union-attr]
+                        error_msg = stderr.decode() if stderr else stdout.decode()
+                else:
+                    if proc.returncode is not None:  # type: ignore[union-attr]
+                        stdout, stderr = await proc.communicate()  # type: ignore[union-attr]
+                        error_msg = stderr.decode() if stderr else stdout.decode()
 
             if error_msg is not None:
                 if "Address already in use" in error_msg:
@@ -431,7 +434,8 @@ class ScrcpyStreamer:
         if self.scrcpy_process:
             try:
                 self.scrcpy_process.terminate()
-                self.scrcpy_process.wait(timeout=2)
+                if isinstance(self.scrcpy_process, subprocess.Popen):
+                    self.scrcpy_process.wait(timeout=2)
             except Exception:
                 try:
                     self.scrcpy_process.kill()

AutoGLM_GUI/server.py

@@ -5,6 +5,8 @@ from socketio import ASGIApp
 from AutoGLM_GUI.api import app as fastapi_app
 from AutoGLM_GUI.socketio_server import sio
 
-app = ASGIApp(sio, other_asgi_app=fastapi_app)
+app = ASGIApp(
+    other_asgi_app=fastapi_app, socketio_server=sio, socketio_path="/socket.io"
+)
 
 __all__ = ["app"]

AutoGLM_GUI/socketio_server.py

@@ -4,7 +4,9 @@ from __future__ import annotations
 
 import asyncio
 import time
-from typing import Any
+from typing import NotRequired
+
+from typing_extensions import TypedDict
 
 import socketio
 
@@ -12,9 +14,19 @@ from AutoGLM_GUI.logger import logger
 from AutoGLM_GUI.scrcpy_protocol import ScrcpyMediaStreamPacket
 from AutoGLM_GUI.scrcpy_stream import ScrcpyStreamer
 
+
+class VideoPacketPayload(TypedDict):
+    type: str
+    data: bytes
+    timestamp: int
+    keyframe: NotRequired[bool | None]
+    pts: NotRequired[int | None]
+
+
 sio = socketio.AsyncServer(
     async_mode="asgi",
     cors_allowed_origins="*",
+    server_kwargs={"socketio_path": "/socket.io"},
 )
 
 _socket_streamers: dict[str, ScrcpyStreamer] = {}
@@ -64,8 +76,8 @@ async def _stream_packets(sid: str, streamer: ScrcpyStreamer) -> None:
         await _stop_stream_for_sid(sid)
 
 
-def _packet_to_payload(packet: ScrcpyMediaStreamPacket) -> dict[str, Any]:
-    payload: dict[str, Any] = {
+def _packet_to_payload(packet: ScrcpyMediaStreamPacket) -> VideoPacketPayload:
+    payload: VideoPacketPayload = {
         "type": packet.type,
         "data": packet.data,
         "timestamp": int(time.time() * 1000),
@@ -87,7 +99,7 @@ async def disconnect(sid: str) -> None:
     await _stop_stream_for_sid(sid)
 
 
-@sio.on("connect-device")
+@sio.on("connect-device")  # type: ignore[misc]
 async def connect_device(sid: str, data: dict | None) -> None:
     payload = data or {}
     device_id = payload.get("device_id") or payload.get("deviceId")

AutoGLM_GUI/state.py

@@ -1,4 +1,13 @@
-"""Shared runtime state for the AutoGLM-GUI API."""
+"""Shared runtime state for the AutoGLM-GUI API.
+
+NOTE: Agent instances and configurations are now managed internally
+by PhoneAgentManager singleton. This module only contains:
+- scrcpy_streamers: Video streaming state per device
+- scrcpy_locks: Async locks for stream management
+- non_blocking_takeover: Takeover callback handler
+
+See PhoneAgentManager (phone_agent_manager.py) for agent lifecycle management.
+"""
 
 from __future__ import annotations
 
@@ -6,38 +15,9 @@ import asyncio
 from typing import TYPE_CHECKING
 
 from AutoGLM_GUI.logger import logger
-from phone_agent.agent import AgentConfig
-from phone_agent.model import ModelConfig
 
 if TYPE_CHECKING:
     from AutoGLM_GUI.scrcpy_stream import ScrcpyStreamer
-    from phone_agent import PhoneAgent
-
-# Agent instances keyed by device_id
-#
-# IMPORTANT: Managed by PhoneAgentManager (AutoGLM_GUI/phone_agent_manager.py)
-# - Do NOT directly modify these dictionaries
-# - Use PhoneAgentManager.get_instance() for all agent operations
-#
-# device_id changes when connection method changes
-# (e.g., USB "ABC123" → WiFi "192.168.1.100:5555")
-#
-# This means the same physical device may have different device_ids:
-#   - USB connection: device_id = hardware serial (e.g., "ABC123DEF")
-#   - WiFi connection: device_id = IP:port (e.g., "192.168.1.100:5555")
-#   - mDNS connection: device_id = service name (e.g., "adb-ABC123._adb-tls-connect._tcp")
-#
-# DeviceManager tracks devices by hardware serial and maintains
-# device_id ↔ serial mapping. Use PhoneAgentManager.find_agent_by_serial()
-# to find agents when device_id changes.
-#
-# See CLAUDE.md "Device Identification" section for details.
-agents: dict[str, "PhoneAgent"] = {}
-
-# Cached configs to rebuild agents on reset
-# Keyed by device_id (same semantics as agents dict)
-# IMPORTANT: Managed by PhoneAgentManager - do NOT modify directly
-agent_configs: dict[str, tuple[ModelConfig, AgentConfig]] = {}
 
 # Scrcpy streaming per device
 scrcpy_streamers: dict[str, "ScrcpyStreamer"] = {}

AutoGLM_GUI/static/assets/{about-DeclntHg.js → about-_XNhzQZX.js}

@@ -1 +1 @@
-import{j as o}from"./index-DHF1NZh0.js";function t(){return o.jsx("div",{className:"p-2",children:o.jsx("h3",{children:"About"})})}export{t as component};
+import{j as o}from"./index-UYYauTly.js";function t(){return o.jsx("div",{className:"p-2",children:o.jsx("h3",{children:"About"})})}export{t as component};