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

AutoGLM_GUI/__main__.py

@@ -140,7 +140,6 @@ def main() -> None:
     import uvicorn
 
     from AutoGLM_GUI import server
-    from AutoGLM_GUI.config import config
     from AutoGLM_GUI.config_manager import config_manager
     from AutoGLM_GUI.logger import configure_logger
 
@@ -170,9 +169,6 @@ def main() -> None:
     # 5. 同步到环境变量（reload 模式需要）
     config_manager.sync_to_env()
 
-    # 6. 刷新旧的 config 对象（保持现有代码兼容）
-    config.refresh_from_env()
-
     # 获取配置来源
     config_source = config_manager.get_config_source()
 

AutoGLM_GUI/adb_plus/qr_pair.py

@@ -124,9 +124,9 @@ class QRPairingListener(ServiceListener):
 
         self.last_paired_host: Optional[str] = None
 
-    def add_service(self, zc: Zeroconf, service_type: str, name: str) -> None:
+    def add_service(self, zc: Zeroconf, type_: str, name: str) -> None:
         """Handle new service discovery."""
-        info = zc.get_service_info(service_type, name, timeout=3000)
+        info = zc.get_service_info(type_, name, timeout=3000)
         if not info:
             logger.debug(f"[QR Pair] No info for service: {name}")
             return
@@ -144,7 +144,7 @@ class QRPairingListener(ServiceListener):
         key = (host, port)
 
         # Handle pairing service
-        if service_type == PAIR_SERVICE_TYPE and not self.paired:
+        if type_ == PAIR_SERVICE_TYPE and not self.paired:
             if key in self.attempted_pair:
                 logger.debug(f"[QR Pair] Already attempted pairing for {host}:{port}")
                 return
@@ -161,7 +161,7 @@ class QRPairingListener(ServiceListener):
                 logger.info("[QR Pair] Pairing OK. Waiting for connect service...")
 
         # Handle connect service
-        if service_type == CONNECT_SERVICE_TYPE and self.paired and not self.connected:
+        if type_ == CONNECT_SERVICE_TYPE and self.paired and not self.connected:
             # Prefer same host as paired if we have it
             if self.last_paired_host and host != self.last_paired_host:
                 logger.debug(
@@ -186,13 +186,13 @@ class QRPairingListener(ServiceListener):
                 self.session.device_id = f"{host}:{port}"
                 logger.info(f"[QR Pair] Connected! Device ID: {self.session.device_id}")
 
-    def update_service(self, zc: Zeroconf, service_type: str, name: str) -> None:
+    def update_service(self, zc: Zeroconf, type_: str, name: str) -> None:
         """Handle service updates (treat as adds)."""
-        self.add_service(zc, service_type, name)
+        self.add_service(zc, type_, name)
 
-    def remove_service(self, _zc: Zeroconf, _service_type: str, _name: str) -> None:
+    def remove_service(self, zc: Zeroconf, type_: str, name: str) -> None:
         """Handle service removal (no action needed)."""
-        pass
+        _ = (zc, type_, name)  # Mark as intentionally unused
 
 
 class QRPairingManager:

AutoGLM_GUI/agents/__init__.py

@@ -0,0 +1,20 @@
+"""Agent adapters and factory for different agent implementations."""
+
+from .factory import (
+    create_agent,
+    is_agent_type_registered,
+    list_agent_types,
+    register_agent,
+)
+from .mai_adapter import MAIAgentAdapter, MAIAgentConfig
+
+__all__ = [
+    # Factory
+    "create_agent",
+    "register_agent",
+    "list_agent_types",
+    "is_agent_type_registered",
+    # Adapters
+    "MAIAgentAdapter",
+    "MAIAgentConfig",
+]

AutoGLM_GUI/agents/factory.py

@@ -0,0 +1,160 @@
+"""Agent factory for creating different agent implementations.
+
+This module provides a factory pattern + registry for creating agents,
+making it easy to add new agent types without modifying existing code.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Callable, Dict
+
+from AutoGLM_GUI.logger import logger
+from AutoGLM_GUI.types import AgentSpecificConfig
+
+from .protocols import BaseAgent
+
+if TYPE_CHECKING:
+    from phone_agent import PhoneAgent
+    from phone_agent.agent import AgentConfig
+    from phone_agent.model import ModelConfig
+
+    from .mai_adapter import MAIAgentAdapter
+
+
+# Agent registry: agent_type -> (creator_function, config_schema)
+AGENT_REGISTRY: Dict[str, Callable] = {}
+
+
+def register_agent(
+    agent_type: str,
+    creator: Callable,
+) -> None:
+    """
+    Register a new agent type.
+
+    Args:
+        agent_type: Unique identifier for the agent type (e.g., "glm", "mai")
+        creator: Function that creates the agent instance.
+                  Signature: (model_config, agent_config, agent_specific_config, callbacks) -> BaseAgent
+
+    Example:
+        >>> def create_mai_agent(model_config, agent_config, mai_config, callbacks):
+        >>>     return MAIAgentAdapter(...)
+        >>>
+        >>> register_agent("mai", create_mai_agent)
+    """
+    if agent_type in AGENT_REGISTRY:
+        logger.warning(f"Agent type '{agent_type}' already registered, overwriting")
+
+    AGENT_REGISTRY[agent_type] = creator
+    logger.info(f"Registered agent type: {agent_type}")
+
+
+def create_agent(
+    agent_type: str,
+    model_config: "ModelConfig",
+    agent_config: "AgentConfig",
+    agent_specific_config: AgentSpecificConfig,
+    takeover_callback: Callable | None = None,
+    confirmation_callback: Callable | None = None,
+) -> "BaseAgent":
+    """
+    Create an agent instance using the factory pattern.
+
+    Args:
+        agent_type: Type of agent to create (e.g., "glm", "mai")
+        model_config: Model configuration
+        agent_config: Agent configuration
+        agent_specific_config: Agent-specific configuration (e.g., MAIConfig fields)
+        takeover_callback: Takeover callback
+        confirmation_callback: Confirmation callback
+
+    Returns:
+        Agent instance implementing BaseAgent interface
+
+    Raises:
+        ValueError: If agent_type is not registered
+    """
+    if agent_type not in AGENT_REGISTRY:
+        available = ", ".join(AGENT_REGISTRY.keys())
+        raise ValueError(
+            f"Unknown agent type: '{agent_type}'. Available types: {available}"
+        )
+
+    creator = AGENT_REGISTRY[agent_type]
+
+    try:
+        agent = creator(
+            model_config=model_config,
+            agent_config=agent_config,
+            agent_specific_config=agent_specific_config,
+            takeover_callback=takeover_callback,
+            confirmation_callback=confirmation_callback,
+        )
+        logger.debug(f"Created agent of type '{agent_type}'")
+        return agent
+    except Exception as e:
+        logger.error(f"Failed to create agent of type '{agent_type}': {e}")
+        raise
+
+
+def list_agent_types() -> list[str]:
+    """Get list of registered agent types."""
+    return list(AGENT_REGISTRY.keys())
+
+
+def is_agent_type_registered(agent_type: str) -> bool:
+    """Check if an agent type is registered."""
+    return agent_type in AGENT_REGISTRY
+
+
+# ==================== Built-in Agent Creators ====================
+
+
+def _create_phone_agent(
+    model_config: "ModelConfig",
+    agent_config: "AgentConfig",
+    agent_specific_config: AgentSpecificConfig,
+    takeover_callback: Callable | None = None,
+    confirmation_callback: Callable | None = None,
+) -> "PhoneAgent":
+    from phone_agent import PhoneAgent
+
+    return PhoneAgent(
+        model_config=model_config,
+        agent_config=agent_config,
+        takeover_callback=takeover_callback,
+        confirmation_callback=confirmation_callback,
+    )
+
+
+def _create_mai_agent(
+    model_config: "ModelConfig",
+    agent_config: "AgentConfig",
+    agent_specific_config: AgentSpecificConfig,
+    takeover_callback: Callable | None = None,
+    confirmation_callback: Callable | None = None,
+) -> "MAIAgentAdapter":
+    from .mai_adapter import MAIAgentAdapter, MAIAgentConfig
+
+    # Build MAI config from dict
+    mai_config = MAIAgentConfig(
+        history_n=agent_specific_config.get("history_n", 3),
+        max_pixels=agent_specific_config.get("max_pixels"),
+        min_pixels=agent_specific_config.get("min_pixels"),
+        tools=agent_specific_config.get("tools"),
+        use_mai_prompt=agent_specific_config.get("use_mai_prompt", False),
+    )
+
+    return MAIAgentAdapter(
+        model_config=model_config,
+        agent_config=agent_config,
+        mai_config=mai_config,
+        takeover_callback=takeover_callback,
+        confirmation_callback=confirmation_callback,
+    )
+
+
+# Register built-in agents
+register_agent("glm", _create_phone_agent)
+register_agent("mai", _create_mai_agent)