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

AutoGLM_GUI/phone_agent_patches.py

@@ -0,0 +1,146 @@
+"""
+Monkey patches for phone_agent to add streaming functionality.
+
+This module patches the upstream phone_agent code without modifying the original files.
+"""
+
+from typing import Any, Callable
+
+from phone_agent.model import ModelClient
+
+
+# Store original methods
+_original_model_request = ModelClient.request
+
+
+def _patched_model_request(
+    self,
+    messages: list[dict[str, Any]],
+    on_thinking_chunk: Callable[[str], None] | None = None,
+) -> Any:
+    """
+    Patched version of ModelClient.request that supports streaming thinking chunks.
+
+    This wraps the original request method and adds callback support for thinking chunks.
+    """
+    import time
+
+    from phone_agent.model.client import ModelResponse
+
+    # Start timing
+    start_time = time.time()
+    time_to_first_token = None
+    time_to_thinking_end = None
+
+    stream = self.client.chat.completions.create(
+        messages=messages,
+        model=self.config.model_name,
+        max_tokens=self.config.max_tokens,
+        temperature=self.config.temperature,
+        top_p=self.config.top_p,
+        frequency_penalty=self.config.frequency_penalty,
+        extra_body=self.config.extra_body,
+        stream=True,
+    )
+
+    raw_content = ""
+    buffer = ""  # Buffer to hold content that might be part of a marker
+    action_markers = ["finish(message=", "do(action="]
+    in_action_phase = False  # Track if we've entered the action phase
+    first_token_received = False
+
+    for chunk in stream:
+        if len(chunk.choices) == 0:
+            continue
+        if chunk.choices[0].delta.content is not None:
+            content = chunk.choices[0].delta.content
+            raw_content += content
+
+            # Record time to first token
+            if not first_token_received:
+                time_to_first_token = time.time() - start_time
+                first_token_received = True
+
+            if in_action_phase:
+                # Already in action phase, just accumulate content without printing
+                continue
+
+            buffer += content
+
+            # Check if any marker is fully present in buffer
+            marker_found = False
+            for marker in action_markers:
+                if marker in buffer:
+                    # Marker found, print everything before it
+                    thinking_part = buffer.split(marker, 1)[0]
+                    print(thinking_part, end="", flush=True)
+                    if on_thinking_chunk:
+                        on_thinking_chunk(thinking_part)
+                    print()  # Print newline after thinking is complete
+                    in_action_phase = True
+                    marker_found = True
+
+                    # Record time to thinking end
+                    if time_to_thinking_end is None:
+                        time_to_thinking_end = time.time() - start_time
+
+                    break
+
+            if marker_found:
+                continue  # Continue to collect remaining content
+
+            # Check if buffer ends with a prefix of any marker
+            # If so, don't print yet (wait for more content)
+            is_potential_marker = False
+            for marker in action_markers:
+                for i in range(1, len(marker)):
+                    if buffer.endswith(marker[:i]):
+                        is_potential_marker = True
+                        break
+                if is_potential_marker:
+                    break
+
+            if not is_potential_marker:
+                # Safe to print the buffer
+                print(buffer, end="", flush=True)
+                if on_thinking_chunk:
+                    on_thinking_chunk(buffer)
+                buffer = ""
+
+    # Calculate total time
+    total_time = time.time() - start_time
+
+    # Parse thinking and action from response
+    thinking, action = self._parse_response(raw_content)
+
+    # Print performance metrics
+    from phone_agent.config.i18n import get_message
+
+    lang = self.config.lang
+    print()
+    print("=" * 50)
+    print(f"⏱️  {get_message('performance_metrics', lang)}:")
+    print("-" * 50)
+    if time_to_first_token is not None:
+        print(f"{get_message('time_to_first_token', lang)}: {time_to_first_token:.3f}s")
+    if time_to_thinking_end is not None:
+        print(
+            f"{get_message('time_to_thinking_end', lang)}:        {time_to_thinking_end:.3f}s"
+        )
+    print(f"{get_message('total_inference_time', lang)}:          {total_time:.3f}s")
+    print("=" * 50)
+
+    return ModelResponse(
+        thinking=thinking,
+        action=action,
+        raw_content=raw_content,
+        time_to_first_token=time_to_first_token,
+        time_to_thinking_end=time_to_thinking_end,
+        total_time=total_time,
+    )
+
+
+def apply_patches():
+    """Apply all monkey patches to phone_agent."""
+    # Patch ModelClient.request to support streaming callbacks
+    ModelClient.request = _patched_model_request

AutoGLM_GUI/schemas.py

@@ -1,6 +1,8 @@
 """Shared Pydantic models for the AutoGLM-GUI API."""
 
-from pydantic import BaseModel, Field
+import re
+
+from pydantic import BaseModel, Field, field_validator
 
 
 class APIModelConfig(BaseModel):
@@ -12,6 +14,20 @@ class APIModelConfig(BaseModel):
     top_p: float = 0.85
     frequency_penalty: float = 0.2
 
+    @field_validator("base_url")
+    @classmethod
+    def validate_base_url(cls, v: str | None) -> str | None:
+        """验证 base_url 格式."""
+        if v is None:
+            return v
+        v = v.strip()
+        if not v:
+            return None
+        # 检查是否是有效的 HTTP/HTTPS URL
+        if not re.match(r"^https?://", v):
+            raise ValueError("base_url must start with http:// or https://")
+        return v
+
 
 class APIAgentConfig(BaseModel):
     max_steps: int = 100
@@ -20,6 +36,25 @@ class APIAgentConfig(BaseModel):
     system_prompt: str | None = None
     verbose: bool = True
 
+    @field_validator("max_steps")
+    @classmethod
+    def validate_max_steps(cls, v: int) -> int:
+        """验证 max_steps 范围."""
+        if v <= 0:
+            raise ValueError("max_steps must be positive")
+        if v > 1000:
+            raise ValueError("max_steps must be <= 1000")
+        return v
+
+    @field_validator("lang")
+    @classmethod
+    def validate_lang(cls, v: str) -> str:
+        """验证 lang 有效性."""
+        allowed_langs = ["cn", "en"]
+        if v not in allowed_langs:
+            raise ValueError(f"lang must be one of {allowed_langs}")
+        return v
+
 
 class InitRequest(BaseModel):
     model: APIModelConfig | None = Field(default=None, alias="model_config")
@@ -30,6 +65,16 @@ class ChatRequest(BaseModel):
     message: str
     device_id: str  # 设备 ID（必填）
 
+    @field_validator("message")
+    @classmethod
+    def validate_message(cls, v: str) -> str:
+        """验证 message 非空."""
+        if not v or not v.strip():
+            raise ValueError("message cannot be empty")
+        if len(v) > 10000:
+            raise ValueError("message too long (max 10000 characters)")
+        return v.strip()
+
 
 class ChatResponse(BaseModel):
     result: str
@@ -47,6 +92,12 @@ class ResetRequest(BaseModel):
     device_id: str  # 设备 ID（必填）
 
 
+class AbortRequest(BaseModel):
+    """中断对话请求。"""
+
+    device_id: str  # 设备 ID（必填）
+
+
 class ScreenshotRequest(BaseModel):
     device_id: str | None = None
 
@@ -66,6 +117,26 @@ class TapRequest(BaseModel):
     device_id: str | None = None
     delay: float = 0.0
 
+    @field_validator("x", "y")
+    @classmethod
+    def validate_coordinates(cls, v: int) -> int:
+        """验证坐标范围."""
+        if v < 0:
+            raise ValueError("coordinates must be non-negative")
+        if v > 10000:  # 合理的最大屏幕尺寸
+            raise ValueError("coordinates must be <= 10000")
+        return v
+
+    @field_validator("delay")
+    @classmethod
+    def validate_delay(cls, v: float) -> float:
+        """验证 delay 范围."""
+        if v < 0.0:
+            raise ValueError("delay must be non-negative")
+        if v > 60.0:  # 最大等待 60 秒
+            raise ValueError("delay must be <= 60.0 seconds")
+        return v
+
 
 class TapResponse(BaseModel):
     success: bool
@@ -81,6 +152,37 @@ class SwipeRequest(BaseModel):
     device_id: str | None = None
     delay: float = 0.0
 
+    @field_validator("start_x", "start_y", "end_x", "end_y")
+    @classmethod
+    def validate_coordinates(cls, v: int) -> int:
+        """验证坐标范围."""
+        if v < 0:
+            raise ValueError("coordinates must be non-negative")
+        if v > 10000:
+            raise ValueError("coordinates must be <= 10000")
+        return v
+
+    @field_validator("duration_ms")
+    @classmethod
+    def validate_duration(cls, v: int | None) -> int | None:
+        """验证滑动持续时间."""
+        if v is not None:
+            if v < 0:
+                raise ValueError("duration_ms must be non-negative")
+            if v > 10000:  # 最大 10 秒
+                raise ValueError("duration_ms must be <= 10000")
+        return v
+
+    @field_validator("delay")
+    @classmethod
+    def validate_delay(cls, v: float) -> float:
+        """验证 delay 范围."""
+        if v < 0.0:
+            raise ValueError("delay must be non-negative")
+        if v > 60.0:
+            raise ValueError("delay must be <= 60.0 seconds")
+        return v
+
 
 class SwipeResponse(BaseModel):
     success: bool
@@ -93,6 +195,26 @@ class TouchDownRequest(BaseModel):
     device_id: str | None = None
     delay: float = 0.0
 
+    @field_validator("x", "y")
+    @classmethod
+    def validate_coordinates(cls, v: int) -> int:
+        """验证坐标范围."""
+        if v < 0:
+            raise ValueError("coordinates must be non-negative")
+        if v > 10000:
+            raise ValueError("coordinates must be <= 10000")
+        return v
+
+    @field_validator("delay")
+    @classmethod
+    def validate_delay(cls, v: float) -> float:
+        """验证 delay 范围."""
+        if v < 0.0:
+            raise ValueError("delay must be non-negative")
+        if v > 60.0:
+            raise ValueError("delay must be <= 60.0 seconds")
+        return v
+
 
 class TouchDownResponse(BaseModel):
     success: bool
@@ -105,6 +227,26 @@ class TouchMoveRequest(BaseModel):
     device_id: str | None = None
     delay: float = 0.0
 
+    @field_validator("x", "y")
+    @classmethod
+    def validate_coordinates(cls, v: int) -> int:
+        """验证坐标范围."""
+        if v < 0:
+            raise ValueError("coordinates must be non-negative")
+        if v > 10000:
+            raise ValueError("coordinates must be <= 10000")
+        return v
+
+    @field_validator("delay")
+    @classmethod
+    def validate_delay(cls, v: float) -> float:
+        """验证 delay 范围."""
+        if v < 0.0:
+            raise ValueError("delay must be non-negative")
+        if v > 60.0:
+            raise ValueError("delay must be <= 60.0 seconds")
+        return v
+
 
 class TouchMoveResponse(BaseModel):
     success: bool
@@ -117,14 +259,57 @@ class TouchUpRequest(BaseModel):
     device_id: str | None = None
     delay: float = 0.0
 
+    @field_validator("x", "y")
+    @classmethod
+    def validate_coordinates(cls, v: int) -> int:
+        """验证坐标范围."""
+        if v < 0:
+            raise ValueError("coordinates must be non-negative")
+        if v > 10000:
+            raise ValueError("coordinates must be <= 10000")
+        return v
+
+    @field_validator("delay")
+    @classmethod
+    def validate_delay(cls, v: float) -> float:
+        """验证 delay 范围."""
+        if v < 0.0:
+            raise ValueError("delay must be non-negative")
+        if v > 60.0:
+            raise ValueError("delay must be <= 60.0 seconds")
+        return v
+
 
 class TouchUpResponse(BaseModel):
     success: bool
     error: str | None = None
 
 
+class AgentStatusResponse(BaseModel):
+    """Agent 运行状态信息."""
+
+    state: str  # "idle" | "busy" | "error" | "initializing"
+    created_at: float  # Unix 时间戳
+    last_used: float  # Unix 时间戳
+    error_message: str | None = None
+    model_name: str  # 来自 ModelConfig
+
+
+class DeviceResponse(BaseModel):
+    """设备信息及可选的 Agent 状态."""
+
+    id: str
+    serial: str
+    model: str
+    status: str
+    connection_type: str
+    state: str
+    is_available_only: bool
+    agent: AgentStatusResponse | None = None
+
+
 class DeviceListResponse(BaseModel):
-    devices: list[dict]
+    devices: list[DeviceResponse]  # 从 list[dict] 改为强类型
 
 
 class ConfigResponse(BaseModel):
@@ -153,11 +338,38 @@ class ConfigSaveRequest(BaseModel):
     model_name: str = "autoglm-phone-9b"
     api_key: str | None = None
 
+    @field_validator("base_url")
+    @classmethod
+    def validate_base_url(cls, v: str) -> str:
+        """验证 base_url 格式."""
+        v = v.strip()
+        if not v:
+            raise ValueError("base_url cannot be empty")
+        if not re.match(r"^https?://", v):
+            raise ValueError("base_url must start with http:// or https://")
+        return v
+
+    @field_validator("model_name")
+    @classmethod
+    def validate_model_name(cls, v: str) -> str:
+        """验证 model_name 非空."""
+        if not v or not v.strip():
+            raise ValueError("model_name cannot be empty")
+        return v.strip()
+
 
 class WiFiConnectRequest(BaseModel):
     device_id: str | None = None
     port: int = 5555
 
+    @field_validator("port")
+    @classmethod
+    def validate_port(cls, v: int) -> int:
+        """验证端口范围."""
+        if v < 1 or v > 65535:
+            raise ValueError("port must be between 1 and 65535")
+        return v
+
 
 class WiFiConnectResponse(BaseModel):
     success: bool
@@ -183,6 +395,25 @@ class WiFiManualConnectRequest(BaseModel):
     ip: str  # IP 地址
     port: int = 5555  # 端口，默认 5555
 
+    @field_validator("ip")
+    @classmethod
+    def validate_ip(cls, v: str) -> str:
+        """验证 IP 地址格式."""
+        v = v.strip()
+        # 简单的 IPv4 格式验证
+        ip_pattern = r"^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$"
+        if not re.match(ip_pattern, v):
+            raise ValueError("invalid IPv4 address format")
+        return v
+
+    @field_validator("port")
+    @classmethod
+    def validate_port(cls, v: int) -> int:
+        """验证端口范围."""
+        if v < 1 or v > 65535:
+            raise ValueError("port must be between 1 and 65535")
+        return v
+
 
 class WiFiManualConnectResponse(BaseModel):
     """手动连接 WiFi 响应."""
@@ -193,6 +424,51 @@ class WiFiManualConnectResponse(BaseModel):
     error: str | None = None
 
 
+class WiFiPairRequest(BaseModel):
+    """WiFi pairing request (Android 11+ wireless debugging)."""
+
+    ip: str  # Device IP address
+    pairing_port: int  # Pairing port (from "Pair device with code" dialog)
+    pairing_code: str  # 6-digit pairing code
+    connection_port: int = 5555  # Standard ADB connection port (default 5555)
+
+    @field_validator("ip")
+    @classmethod
+    def validate_ip(cls, v: str) -> str:
+        """验证 IP 地址格式."""
+        v = v.strip()
+        ip_pattern = r"^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$"
+        if not re.match(ip_pattern, v):
+            raise ValueError("invalid IPv4 address format")
+        return v
+
+    @field_validator("pairing_port", "connection_port")
+    @classmethod
+    def validate_port(cls, v: int) -> int:
+        """验证端口范围."""
+        if v < 1 or v > 65535:
+            raise ValueError("port must be between 1 and 65535")
+        return v
+
+    @field_validator("pairing_code")
+    @classmethod
+    def validate_pairing_code(cls, v: str) -> str:
+        """验证配对码格式."""
+        v = v.strip()
+        if not re.match(r"^\d{6}$", v):
+            raise ValueError("pairing_code must be a 6-digit number")
+        return v
+
+
+class WiFiPairResponse(BaseModel):
+    """WiFi pairing response."""
+
+    success: bool
+    message: str
+    device_id: str | None = None  # Device ID after connection (ip:connection_port)
+    error: str | None = None  # Error code for frontend handling
+
+
 class VersionCheckResponse(BaseModel):
     """Version update check response."""
 
@@ -202,3 +478,105 @@ class VersionCheckResponse(BaseModel):
     release_url: str | None = None
     published_at: str | None = None
     error: str | None = None
+
+
+class MdnsDeviceResponse(BaseModel):
+    """Single mDNS-discovered device."""
+
+    name: str  # Device name (e.g., "adb-243a09b7-cbCO6P")
+    ip: str  # IP address
+    port: int  # Port number
+    has_pairing: bool  # Whether pairing service was also advertised
+    service_type: str  # Service type
+    pairing_port: int | None = None  # Pairing port if has_pairing is True
+
+
+class MdnsDiscoverResponse(BaseModel):
+    """mDNS device discovery response."""
+
+    success: bool
+    devices: list[MdnsDeviceResponse]
+    error: str | None = None
+
+
+# QR Code Pairing Models
+
+
+class QRPairGenerateResponse(BaseModel):
+    """QR code pairing generation response."""
+
+    success: bool
+    qr_payload: str | None = (
+        None  # QR text payload (WIFI:T:ADB;S:{name};P:{password};;)
+    )
+    session_id: str | None = None  # Session tracking ID (UUID)
+    expires_at: float | None = None  # Unix timestamp when session expires
+    message: str
+    error: str | None = None  # Error code for frontend handling
+
+
+class QRPairStatusResponse(BaseModel):
+    """QR code pairing status response."""
+
+    session_id: str
+    status: str  # "listening" | "pairing" | "paired" | "connecting" | "connected" | "timeout" | "error"
+    device_id: str | None = None  # Device ID when connected (ip:port)
+    message: str
+    error: str | None = None  # Error details
+
+
+class QRPairCancelResponse(BaseModel):
+    """QR code pairing cancellation response."""
+
+    success: bool
+    message: str
+
+
+# Workflow Models
+
+
+class WorkflowBase(BaseModel):
+    """Workflow 基础模型."""
+
+    name: str
+    text: str
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v: str) -> str:
+        """验证 name 非空."""
+        if not v or not v.strip():
+            raise ValueError("name cannot be empty")
+        return v.strip()
+
+    @field_validator("text")
+    @classmethod
+    def validate_text(cls, v: str) -> str:
+        """验证 text 非空."""
+        if not v or not v.strip():
+            raise ValueError("text cannot be empty")
+        return v.strip()
+
+
+class WorkflowCreate(WorkflowBase):
+    """创建 Workflow 请求."""
+
+    pass
+
+
+class WorkflowUpdate(WorkflowBase):
+    """更新 Workflow 请求."""
+
+    pass
+
+
+class WorkflowResponse(WorkflowBase):
+    """Workflow 响应."""
+
+    uuid: str
+
+
+class WorkflowListResponse(BaseModel):
+    """Workflow 列表响应."""
+
+    workflows: list[WorkflowResponse]

AutoGLM_GUI/state.py

@@ -14,8 +14,29 @@ if TYPE_CHECKING:
     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

AutoGLM_GUI/static/assets/{about-BOnRPlKQ.js → about-PcGX7dIG.js}

@@ -1 +1 @@
-import{j as o}from"./index-DH-Dl4tK.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-CnEYDOXp.js";function t(){return o.jsx("div",{className:"p-2",children:o.jsx("h3",{children:"About"})})}export{t as component};