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

AutoGLM_GUI/config_manager.py

@@ -54,13 +54,10 @@ class ConfigModel(BaseModel):
 
     # 双模型配置
     dual_model_enabled: bool = False
-    decision_base_url: str = "https://api-inference.modelscope.cn/v1"
-    decision_model_name: str = "ZhipuAI/GLM-4.7"
+    decision_base_url: str = ""
+    decision_model_name: str = ""
     decision_api_key: str = ""
 
-    # 思考模式配置
-    thinking_mode: str = "deep"  # "fast" 或 "deep"
-
     @field_validator("base_url")
     @classmethod
     def validate_base_url(cls, v: str) -> str:
@@ -85,14 +82,6 @@ class ConfigModel(BaseModel):
             raise ValueError("decision_base_url must start with http:// or https://")
         return v.rstrip("/")  # 去除尾部斜杠
 
-    @field_validator("thinking_mode")
-    @classmethod
-    def validate_thinking_mode(cls, v: str) -> str:
-        """验证思考模式."""
-        if v not in ("fast", "deep"):
-            raise ValueError("thinking_mode must be 'fast' or 'deep'")
-        return v
-
 
 # ==================== 配置层数据类 ====================
 
@@ -109,8 +98,6 @@ class ConfigLayer:
     decision_base_url: Optional[str] = None
     decision_model_name: Optional[str] = None
     decision_api_key: Optional[str] = None
-    # 思考模式配置
-    thinking_mode: Optional[str] = None
 
     source: ConfigSource = ConfigSource.DEFAULT
 
@@ -142,7 +129,6 @@ class ConfigLayer:
                 "decision_base_url": self.decision_base_url,
                 "decision_model_name": self.decision_model_name,
                 "decision_api_key": self.decision_api_key,
-                "thinking_mode": self.thinking_mode,
             }.items()
             if v is not None
         }
@@ -314,7 +300,6 @@ class UnifiedConfigManager:
                 decision_base_url=config_data.get("decision_base_url"),
                 decision_model_name=config_data.get("decision_model_name"),
                 decision_api_key=config_data.get("decision_api_key"),
-                thinking_mode=config_data.get("thinking_mode"),
                 source=ConfigSource.FILE,
             )
             self._effective_config = None  # 清除缓存
@@ -346,7 +331,6 @@ class UnifiedConfigManager:
         decision_base_url: Optional[str] = None,
         decision_model_name: Optional[str] = None,
         decision_api_key: Optional[str] = None,
-        thinking_mode: Optional[str] = None,
         merge_mode: bool = True,
     ) -> bool:
         """
@@ -360,7 +344,6 @@ class UnifiedConfigManager:
             decision_base_url: 决策模型 Base URL
             decision_model_name: 决策模型名称
             decision_api_key: 决策模型 API key
-            thinking_mode: 思考模式 (fast/deep)
             merge_mode: 是否合并现有配置（True: 保留未提供的字段）
 
         Returns:
@@ -386,8 +369,6 @@ class UnifiedConfigManager:
                 new_config["decision_model_name"] = decision_model_name
             if decision_api_key:
                 new_config["decision_api_key"] = decision_api_key
-            if thinking_mode:
-                new_config["thinking_mode"] = thinking_mode
 
             # 合并模式：保留现有文件中未提供的字段
             if merge_mode and self._config_path.exists():
@@ -402,7 +383,6 @@ class UnifiedConfigManager:
                         "decision_base_url",
                         "decision_model_name",
                         "decision_api_key",
-                        "thinking_mode",
                     ]
                     for key in preserve_keys:
                         if key not in new_config and key in existing:
@@ -491,7 +471,6 @@ class UnifiedConfigManager:
             "decision_base_url",
             "decision_model_name",
             "decision_api_key",
-            "thinking_mode",
         ]
 
         for key in config_keys:
@@ -658,7 +637,6 @@ class UnifiedConfigManager:
             "decision_base_url": config.decision_base_url,
             "decision_model_name": config.decision_model_name,
             "decision_api_key": config.decision_api_key,
-            "thinking_mode": config.thinking_mode,
         }
 
 

AutoGLM_GUI/dual_model/protocols.py

@@ -21,9 +21,9 @@ class ThinkingMode(str, Enum):
 class DecisionModelConfig(BaseModel):
     """决策大模型配置"""
 
-    base_url: str = "https://api-inference.modelscope.cn/v1"
+    base_url: str
     api_key: str = ""
-    model_name: str = "ZhipuAI/GLM-4.7"
+    model_name: str
     max_tokens: int = 4096
     temperature: float = 0.7
     thinking_mode: ThinkingMode = ThinkingMode.DEEP
@@ -33,7 +33,7 @@ class DualModelConfig(BaseModel):
     """双模型协作配置"""
 
     enabled: bool = False
-    decision_model: DecisionModelConfig = DecisionModelConfig()
+    decision_model: Optional[DecisionModelConfig] = None
 
 
 class ModelRole(str, Enum):

AutoGLM_GUI/mai_ui_adapter/agent_wrapper.py

@@ -0,0 +1,291 @@
+"""MAI-UI PhoneAgent wrapper for compatibility with AutoGLM-GUI interface."""
+
+from dataclasses import dataclass
+from typing import Any, Callable, Optional
+
+from phone_agent.agent import AgentConfig, StepResult
+from phone_agent.actions.handler import ActionHandler
+from phone_agent.model import ModelConfig
+
+from AutoGLM_GUI.logger import logger
+from AutoGLM_GUI.mai_ui.mai_navigation_agent import MAIUINaivigationAgent
+from AutoGLM_GUI.mai_ui_adapter.action_adapter import MAIUIActionAdapter
+
+
+@dataclass
+class MAIUIConfig:
+    """MAI-UI specific configuration."""
+
+    history_n: int = 3
+    temperature: float = 0.0
+    top_k: int = -1
+    top_p: float = 1.0
+    max_tokens: int = 2048
+
+
+class MAIUIPhoneAgent:
+    """
+    MAI-UI Agent wrapper that implements the PhoneAgent interface.
+
+    This wrapper allows MAI-UI agents to be used transparently in place of
+    the standard PhoneAgent, providing compatibility with the existing
+    PhoneAgentManager and API infrastructure.
+
+    Usage:
+        agent = MAIUIPhoneAgent(
+            model_config=model_config,
+            agent_config=agent_config,
+        )
+        result = agent.run("Open WeChat")
+    """
+
+    def __init__(
+        self,
+        model_config: ModelConfig,
+        agent_config: AgentConfig,
+        mai_config: Optional[MAIUIConfig] = None,
+        takeover_callback: Optional[Callable[[str], None]] = None,
+    ):
+        """
+        Initialize MAI-UI PhoneAgent wrapper.
+
+        Args:
+            model_config: Model configuration (base_url, api_key, model_name).
+            agent_config: Agent configuration (device_id, max_steps, etc.).
+            mai_config: MAI-UI specific configuration.
+            takeover_callback: Callback for takeover requests.
+        """
+        self.model_config = model_config
+        self.agent_config = agent_config
+        self.mai_config = mai_config or MAIUIConfig()
+
+        # Create MAI-UI navigation agent
+        self._mai_agent = MAIUINaivigationAgent(
+            llm_base_url=model_config.base_url,
+            model_name=model_config.model_name,
+            api_key=model_config.api_key,
+            runtime_conf={
+                "history_n": self.mai_config.history_n,
+                "temperature": self.mai_config.temperature,
+                "top_k": self.mai_config.top_k,
+                "top_p": self.mai_config.top_p,
+                "max_tokens": self.mai_config.max_tokens,
+            },
+        )
+
+        # Action adapter and handler
+        self._action_adapter = MAIUIActionAdapter()
+        self.action_handler = ActionHandler(
+            device_id=agent_config.device_id,
+            takeover_callback=takeover_callback,
+        )
+
+        # PhoneAgent-compatible state
+        self._context: list[dict[str, Any]] = []
+        self._step_count = 0
+        self._current_task: str = ""
+
+        # For model_client compatibility (used by streaming patches)
+        self.model_client = _DummyModelClient()
+
+        # Debug: Print model configuration for troubleshooting
+        logger.info("=" * 60)
+        logger.info("[MAI-UI Agent] Initialization")
+        logger.info(f"  Device ID: {agent_config.device_id}")
+        logger.info(f"  Base URL:  {model_config.base_url}")
+        logger.info(f"  Model:     {model_config.model_name}")
+        logger.info("=" * 60)
+
+    def run(self, task: str) -> str:
+        """
+        Execute a complete task.
+
+        Args:
+            task: Natural language task description.
+
+        Returns:
+            Final message from the agent.
+        """
+        self.reset()
+        self._current_task = task
+
+        # First step
+        result = self._execute_step(task, is_first=True)
+
+        if result.finished:
+            return result.message or "Task completed"
+
+        # Continue until finished or max steps reached
+        while self._step_count < self.agent_config.max_steps:
+            result = self._execute_step(is_first=False)
+
+            if result.finished:
+                return result.message or "Task completed"
+
+        return "Max steps reached"
+
+    def step(self, task: Optional[str] = None) -> StepResult:
+        """
+        Execute a single step.
+
+        Args:
+            task: Task description (required for first step).
+
+        Returns:
+            StepResult with step details.
+        """
+        is_first = len(self._context) == 0
+
+        if is_first:
+            if not task:
+                raise ValueError("Task is required for the first step")
+            self._current_task = task
+
+        return self._execute_step(task, is_first)
+
+    def _execute_step(
+        self, user_prompt: Optional[str] = None, is_first: bool = False
+    ) -> StepResult:
+        """Execute a single step of the agent loop."""
+        from phone_agent.device_factory import get_device_factory
+        from PIL import Image
+        from io import BytesIO
+
+        self._step_count += 1
+        logger.info(f"[MAI-UI] Executing step {self._step_count}")
+
+        # Get screenshot
+        device_factory = get_device_factory()
+        screenshot = device_factory.get_screenshot(self.agent_config.device_id)
+
+        # Convert base64 to PIL Image
+        import base64
+
+        image_bytes = base64.b64decode(screenshot.base64_data)
+        pil_image = Image.open(BytesIO(image_bytes))
+
+        # Build observation
+        obs = {
+            "screenshot": pil_image,
+            "accessibility_tree": None,
+        }
+
+        # Get instruction
+        instruction = user_prompt or self._current_task
+
+        # Call MAI-UI predict
+        try:
+            raw_response, action_json = self._mai_agent.predict(
+                instruction=instruction,
+                obs=obs,
+            )
+        except Exception as e:
+            logger.error(f"[MAI-UI] Predict failed: {e}")
+            return StepResult(
+                success=False,
+                finished=True,
+                action=None,
+                thinking="",
+                message=f"Prediction failed: {e}",
+            )
+
+        # Check for error
+        if action_json.get("action") is None:
+            logger.error("[MAI-UI] Invalid action returned")
+            return StepResult(
+                success=False,
+                finished=True,
+                action=None,
+                thinking="",
+                message="Invalid action from model",
+            )
+
+        # Get thinking from trajectory
+        thinking = ""
+        if self._mai_agent.traj_memory.steps:
+            last_step = self._mai_agent.traj_memory.steps[-1]
+            thinking = last_step.thought or ""
+
+        # Convert action to AutoGLM-GUI format
+        converted_action = self._action_adapter.convert(action_json)
+        logger.debug(f"[MAI-UI] Converted action: {converted_action}")
+
+        # Check if finished (terminate action)
+        if converted_action.get("_metadata") == "finish":
+            return StepResult(
+                success=True,
+                finished=True,
+                action=converted_action,
+                thinking=thinking,
+                message=converted_action.get("message", "Task completed"),
+            )
+
+        # Execute action
+        try:
+            result = self.action_handler.execute(
+                converted_action,
+                screenshot.width,
+                screenshot.height,
+            )
+        except Exception as e:
+            logger.error(f"[MAI-UI] Action execution failed: {e}")
+            return StepResult(
+                success=False,
+                finished=False,
+                action=converted_action,
+                thinking=thinking,
+                message=f"Action failed: {e}",
+            )
+
+        # Update context for compatibility
+        self._context.append(
+            {
+                "step": self._step_count,
+                "action": action_json,
+                "converted_action": converted_action,
+                "result": result.success,
+                "thinking": thinking,
+            }
+        )
+
+        return StepResult(
+            success=result.success,
+            finished=result.should_finish,
+            action=converted_action,
+            thinking=thinking,
+            message=result.message,
+        )
+
+    def reset(self) -> None:
+        """Reset agent state for a new task."""
+        self._context = []
+        self._step_count = 0
+        self._current_task = ""
+        self._mai_agent.reset()
+        logger.debug("[MAI-UI] Agent reset")
+
+    @property
+    def step_count(self) -> int:
+        """Get current step count."""
+        return self._step_count
+
+    @property
+    def context(self) -> list[dict[str, Any]]:
+        """Get conversation context (for compatibility)."""
+        return self._context.copy()
+
+
+class _DummyModelClient:
+    """
+    Dummy model client for compatibility with streaming patches.
+
+    The actual model calls are handled by MAI-UI agent internally.
+    This exists to satisfy code that expects model_client attribute.
+    """
+
+    def request(self, messages: list, **kwargs) -> Any:
+        """Dummy request method - should not be called directly."""
+        raise NotImplementedError(
+            "MAIUIPhoneAgent handles model calls internally. "
+            "Do not call model_client.request() directly."
+        )

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

AutoGLM_GUI/schemas.py

@@ -326,9 +326,6 @@ class ConfigResponse(BaseModel):
     decision_model_name: str = ""
     decision_api_key: str = ""
 
-    # 思考模式
-    thinking_mode: str = "deep"  # "fast" | "deep"
-
     conflicts: list[dict] | None = None  # 配置冲突信息（可选）
 
 
@@ -345,9 +342,6 @@ class ConfigSaveRequest(BaseModel):
     decision_model_name: str | None = None
     decision_api_key: str | None = None
 
-    # 思考模式
-    thinking_mode: str | None = None  # "fast" | "deep"
-
     @field_validator("base_url")
     @classmethod
     def validate_base_url(cls, v: str) -> str:
@@ -367,16 +361,6 @@ class ConfigSaveRequest(BaseModel):
             raise ValueError("model_name cannot be empty")
         return v.strip()
 
-    @field_validator("thinking_mode")
-    @classmethod
-    def validate_thinking_mode(cls, v: str | None) -> str | None:
-        """验证 thinking_mode."""
-        if v is None:
-            return v
-        if v not in ("fast", "deep"):
-            raise ValueError("thinking_mode must be 'fast' or 'deep'")
-        return v
-
     @field_validator("decision_base_url")
     @classmethod
     def validate_decision_base_url(cls, v: str | None) -> str | None:

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

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