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

{phone_agent/config → AutoGLM_GUI/agents/glm}/prompts_zh.py

@@ -1,15 +1,8 @@
-"""System prompts for the AI agent."""
-
 from datetime import datetime
 
 today = datetime.today()
 weekday_names = ["星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"]
 weekday = weekday_names[today.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}"
 
 SYSTEM_PROMPT = (
@@ -26,37 +19,37 @@ SYSTEM_PROMPT = (
 - {action} 是本次执行的具体操作指令，必须严格遵循下方定义的指令格式。
 
 操作指令及其作用如下：
-- do(action="Launch", app="xxx")  
+- do(action=\"Launch\", app=\"xxx\")  
     Launch是启动目标app的操作，这比通过主屏幕导航更快。此操作完成后，您将自动收到结果状态的截图。
-- do(action="Tap", element=[x,y])  
+- do(action=\"Tap\", element=[x,y])  
     Tap是点击操作，点击屏幕上的特定点。可用此操作点击按钮、选择项目、从主屏幕打开应用程序，或与任何可点击的用户界面元素进行交互。坐标系统从左上角 (0,0) 开始到右下角（999,999)结束。此操作完成后，您将自动收到结果状态的截图。
-- do(action="Tap", element=[x,y], message="重要操作")  
+- do(action=\"Tap\", element=[x,y], message=\"重要操作\")  
     基本功能同Tap，点击涉及财产、支付、隐私等敏感按钮时触发。
-- do(action="Type", text="xxx")  
+- do(action=\"Type\", text=\"xxx\")  
     Type是输入操作，在当前聚焦的输入框中输入文本。使用此操作前，请确保输入框已被聚焦（先点击它）。输入的文本将像使用键盘输入一样输入。重要提示：手机可能正在使用 ADB 键盘，该键盘不会像普通键盘那样占用屏幕空间。要确认键盘已激活，请查看屏幕底部是否显示 'ADB Keyboard {ON}' 类似的文本，或者检查输入框是否处于激活/高亮状态。不要仅仅依赖视觉上的键盘显示。自动清除文本：当你使用输入操作时，输入框中现有的任何文本（包括占位符文本和实际输入）都会在输入新文本前自动清除。你无需在输入前手动清除文本——直接使用输入操作输入所需文本即可。操作完成后，你将自动收到结果状态的截图。
-- do(action="Type_Name", text="xxx")  
+- do(action=\"Type_Name\", text=\"xxx\")  
     Type_Name是输入人名的操作，基本功能同Type。
-- do(action="Interact")  
+- do(action=\"Interact\")  
     Interact是当有多个满足条件的选项时而触发的交互操作，询问用户如何选择。
-- do(action="Swipe", start=[x1,y1], end=[x2,y2])  
+- do(action=\"Swipe\", start=[x1,y1], end=[x2,y2])  
     Swipe是滑动操作，通过从起始坐标拖动到结束坐标来执行滑动手势。可用于滚动内容、在屏幕之间导航、下拉通知栏以及项目栏或进行基于手势的导航。坐标系统从左上角 (0,0) 开始到右下角（999,999)结束。滑动持续时间会自动调整以实现自然的移动。此操作完成后，您将自动收到结果状态的截图。
-- do(action="Note", message="True")  
+- do(action=\"Note\", message=\"True\")  
     记录当前页面内容以便后续总结。
-- do(action="Call_API", instruction="xxx")  
+- do(action=\"Call_API\", instruction=\"xxx\")  
     总结或评论当前页面或已记录的内容。
-- do(action="Long Press", element=[x,y])  
+- do(action=\"Long Press\", element=[x,y])  
     Long Pres是长按操作，在屏幕上的特定点长按指定时间。可用于触发上下文菜单、选择文本或激活长按交互。坐标系统从左上角 (0,0) 开始到右下角（999,999)结束。此操作完成后，您将自动收到结果状态的屏幕截图。
-- do(action="Double Tap", element=[x,y])  
+- do(action=\"Double Tap\", element=[x,y])  
     Double Tap在屏幕上的特定点快速连续点按两次。使用此操作可以激活双击交互，如缩放、选择文本或打开项目。坐标系统从左上角 (0,0) 开始到右下角（999,999)结束。此操作完成后，您将自动收到结果状态的截图。
-- do(action="Take_over", message="xxx")  
+- do(action=\"Take_over\", message=\"xxx\")  
     Take_over是接管操作，表示在登录和验证阶段需要用户协助。
-- do(action="Back")  
+- do(action=\"Back\")  
     导航返回到上一个屏幕或关闭当前对话框。相当于按下 Android 的返回按钮。使用此操作可以从更深的屏幕返回、关闭弹出窗口或退出当前上下文。此操作完成后，您将自动收到结果状态的截图。
-- do(action="Home") 
+- do(action=\"Home\") 
     Home是回到系统桌面的操作，相当于按下 Android 主屏幕按钮。使用此操作可退出当前应用并返回启动器，或从已知状态启动新任务。此操作完成后，您将自动收到结果状态的截图。
-- do(action="Wait", duration="x seconds")  
+- do(action=\"Wait\", duration=\"x seconds\")  
     等待页面加载，x为需要等待多少秒。
-- finish(message="xxx")  
+- finish(message=\"xxx\")  
     finish是结束任务的操作，表示准确完整完成任务，message是终止信息。 
 
 必须遵循的规则：
@@ -70,13 +63,13 @@ SYSTEM_PROMPT = (
 8. 购物车全选后再点击全选可以把状态设为全不选，在做购物车任务时，如果购物车里已经有商品被选中时，你需要点击全选后再点击取消全选，再去找需要购买或者删除的商品。
 9. 在做外卖任务时，如果相应店铺购物车里已经有其他商品你需要先把购物车清空再去购买用户指定的外卖。
 10. 在做点外卖任务时，如果用户需要点多个外卖，请尽量在同一店铺进行购买，如果无法找到可以下单，并说明某个商品未找到。
-11. 请严格遵循用户意图执行任务，用户的特殊要求可以执行多次搜索，滑动查找。比如（i）用户要求点一杯咖啡，要咸的，你可以直接搜索咸咖啡，或者搜索咖啡后滑动查找咸的咖啡，比如海盐咖啡。（ii）用户要找到XX群，发一条消息，你可以先搜索XX群，找不到结果后，将"群"字去掉，搜索XX重试。（iii）用户要找到宠物友好的餐厅，你可以搜索餐厅，找到筛选，找到设施，选择可带宠物，或者直接搜索可带宠物，必要时可以使用AI搜索。
+11. 请严格遵循用户意图执行任务，用户的特殊要求可以执行多次搜索，滑动查找。比如（i）用户要求点一杯咖啡，要咸的，你可以直接搜索咸咖啡，或者搜索咖啡后滑动查找咸的咖啡，比如海盐咖啡。（ii）用户要找到XX群，发一条消息，你可以先搜索XX群，找不到结果后，将\"群\"字去掉，搜索XX重试。（iii）用户要找到宠物友好的餐厅，你可以搜索餐厅，找到筛选，找到设施，选择可带宠物，或者直接搜索可带宠物，必要时可以使用AI搜索。
 12. 在选择日期时，如果原滑动方向与预期日期越来越远，请向反方向滑动查找。
 13. 执行任务过程中如果有多个可选择的项目栏，请逐个查找每个项目栏，直到完成任务，一定不要在同一项目栏多次查找，从而陷入死循环。
 14. 在执行下一步操作前请一定要检查上一步的操作是否生效，如果点击没生效，可能因为app反应较慢，请先稍微等待一下，如果还是不生效请调整一下点击位置重试，如果仍然不生效请跳过这一步继续任务，并在finish message说明点击不生效。
 15. 在执行任务中如果遇到滑动不生效的情况，请调整一下起始点位置，增大滑动距离重试，如果还是不生效，有可能是已经滑到底了，请继续向反方向滑动，直到顶部或底部，如果仍然没有符合要求的结果，请跳过这一步继续任务，并在finish message说明但没找到要求的项目。
 16. 在做游戏任务时如果在战斗页面如果有自动战斗一定要开启自动战斗，如果多轮历史状态相似要检查自动战斗是否开启。
-17. 如果没有合适的搜索结果，可能是因为搜索页面不对，请返回到搜索页面的上一级尝试重新搜索，如果尝试三次返回上一级搜索后仍然没有符合要求的结果，执行 finish(message="原因")。
+17. 如果没有合适的搜索结果，可能是因为搜索页面不对，请返回到搜索页面的上一级尝试重新搜索，如果尝试三次返回上一级搜索后仍然没有符合要求的结果，执行 finish(message=\"原因\")。
 18. 在结束任务前请一定要仔细检查任务是否完整准确的完成，如果出现错选、漏选、多选的情况，请返回之前的步骤进行纠正。
 """
 )

AutoGLM_GUI/agents/mai/__init__.py

@@ -0,0 +1,28 @@
+"""MAI Agent - Internal implementation.
+
+This module co-locates all MAI-specific code:
+- InternalMAIAgent: The main agent implementation
+- MAIParser: XML+JSON format parser with coordinate conversion (0-999 to 0-1000)
+- MAI_MOBILE_SYSTEM_PROMPT: System prompt for Chinese environments
+- TrajMemory, TrajStep: Trajectory memory for multi-step tasks
+
+Design notes:
+- MAI uses 0-999 coordinate system (normalized internally)
+- Supports multi-image history context (configurable via history_n)
+- Chinese-optimized prompts for domestic app scenarios
+- Internal implementation replacing third-party mai_agent dependency
+"""
+
+from .agent import InternalMAIAgent
+from .parser import MAIParser, MAIParseError
+from .prompts import MAI_MOBILE_SYSTEM_PROMPT
+from .traj_memory import TrajMemory, TrajStep
+
+__all__ = [
+    "InternalMAIAgent",
+    "MAIParser",
+    "MAIParseError",
+    "MAI_MOBILE_SYSTEM_PROMPT",
+    "TrajMemory",
+    "TrajStep",
+]

AutoGLM_GUI/agents/mai/agent.py

@@ -0,0 +1,408 @@
+"""Internal MAI Agent Implementation
+
+完全内部化实现的 MAI Agent，替代第三方 mai_agent 依赖。
+
+核心特性：
+- 多图像历史上下文（保留最近 N 张截图）
+- XML 格式的思考过程和动作输出
+- 999 坐标系统归一化
+- 自动重试机制
+"""
+
+import base64
+import time
+import traceback
+from io import BytesIO
+from typing import Any, Callable
+
+from openai import OpenAI
+from PIL import Image
+
+from AutoGLM_GUI.actions import ActionHandler, ActionResult
+from AutoGLM_GUI.config import AgentConfig, ModelConfig, StepResult
+from AutoGLM_GUI.device_protocol import DeviceProtocol
+from AutoGLM_GUI.logger import logger
+from AutoGLM_GUI.model import MessageBuilder
+
+from .traj_memory import TrajMemory, TrajStep
+from .parser import MAIParseError, MAIParser
+from .prompts import MAI_MOBILE_SYSTEM_PROMPT
+
+
+class InternalMAIAgent:
+    def __init__(
+        self,
+        model_config: ModelConfig,
+        agent_config: AgentConfig,
+        device: DeviceProtocol,
+        history_n: int = 3,
+        confirmation_callback: Callable[[str], bool] | None = None,
+        takeover_callback: Callable[[str], None] | None = None,
+        thinking_callback: Callable[[str], None] | None = None,
+    ):
+        self.model_config = model_config
+        self.agent_config = agent_config
+        self.history_n = history_n
+
+        self.openai_client = OpenAI(
+            base_url=model_config.base_url,
+            api_key=model_config.api_key,
+            timeout=120,
+        )
+        self.parser = MAIParser()
+
+        self.device = device
+        self.action_handler = ActionHandler(
+            device=self.device,
+            confirmation_callback=confirmation_callback,
+            takeover_callback=takeover_callback,
+        )
+
+        self.traj_memory = TrajMemory(task_goal="", task_id="", steps=[])
+        self._step_count = 0
+        self._is_running = False
+        self._thinking_callback = thinking_callback
+
+        self._total_llm_time = 0.0
+        self._total_action_time = 0.0
+        self._total_tokens = 0
+
+    def run(self, task: str) -> str:
+        self.traj_memory = TrajMemory(task_goal=task, task_id="", steps=[])
+        self._step_count = 0
+        self._is_running = True
+
+        try:
+            result = self._execute_step(task, is_first=True)
+
+            if result.finished:
+                return result.message or "Task completed"
+
+            while self._step_count < self.agent_config.max_steps and self._is_running:
+                result = self._execute_step(is_first=False)
+
+                if result.finished:
+                    return result.message or "Task completed"
+
+            return "Max steps reached"
+        finally:
+            self._is_running = False
+
+    def step(self, task: str | None = None) -> StepResult:
+        is_first = len(self.traj_memory.steps) == 0
+
+        if is_first and not task:
+            raise ValueError("Task is required for the first step")
+
+        if is_first:
+            self.traj_memory.task_goal = task or ""
+        elif task:
+            # 多轮对话：有新的用户消息，更新 task_goal
+            self.traj_memory.task_goal = task
+
+        return self._execute_step(task, is_first)
+
+    def reset(self) -> None:
+        self.traj_memory.clear()
+        self._step_count = 0
+        self._is_running = False
+        self._total_llm_time = 0.0
+        self._total_action_time = 0.0
+        self._total_tokens = 0
+
+    def abort(self) -> None:
+        self._is_running = False
+        logger.info("InternalMAIAgent aborted by user")
+
+    def _stream_request(
+        self,
+        messages: list[dict[str, Any]],
+        on_thinking_chunk: Callable[[str], None] | None = None,
+    ) -> str:
+        stream = self.openai_client.chat.completions.create(
+            messages=messages,  # type: ignore[arg-type]
+            model=self.model_config.model_name,
+            max_tokens=self.model_config.max_tokens,
+            temperature=self.model_config.temperature,
+            top_p=self.model_config.top_p,
+            frequency_penalty=self.model_config.frequency_penalty,
+            extra_body=self.model_config.extra_body,
+            stream=True,
+        )
+
+        raw_content = ""
+        buffer = ""
+        action_markers = ["</thinking>", "<tool_call>"]
+        in_action_phase = 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
+
+                if in_action_phase:
+                    continue
+
+                buffer += content
+
+                marker_found = False
+                for marker in action_markers:
+                    if marker in buffer:
+                        thinking_part = buffer.split(marker, 1)[0]
+                        if on_thinking_chunk:
+                            on_thinking_chunk(thinking_part)
+                        in_action_phase = True
+                        marker_found = True
+                        break
+
+                if marker_found:
+                    continue
+
+                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:
+                    if on_thinking_chunk:
+                        on_thinking_chunk(buffer)
+                    buffer = ""
+
+        return raw_content
+
+    def _execute_step(
+        self, user_prompt: str | None = None, is_first: bool = False
+    ) -> StepResult:
+        self._step_count += 1
+
+        screenshot = self.device.get_screenshot()
+        current_app = self.device.get_current_app()
+
+        screenshot_bytes = base64.b64decode(screenshot.base64_data)
+        pil_image = Image.open(BytesIO(screenshot_bytes))
+
+        if is_first:
+            instruction = user_prompt or self.traj_memory.task_goal
+        else:
+            instruction = self.traj_memory.task_goal
+
+        screen_info = MessageBuilder.build_screen_info(current_app)
+
+        messages = self._build_messages(
+            instruction=instruction,
+            screen_info=screen_info,
+            current_screenshot_base64=screenshot.base64_data,
+        )
+
+        max_retries = 3
+        raw_content = ""
+        thinking = ""
+        raw_action = None
+        converted_action = None
+
+        for attempt in range(max_retries):
+            try:
+                if self.agent_config.verbose:
+                    retry_info = (
+                        f" (尝试 {attempt + 1}/{max_retries})" if attempt > 0 else ""
+                    )
+                    print("\n" + "=" * 50)
+                    print(f"💭 步骤 {self._step_count}{retry_info} - 思考中...")
+                    print("-" * 50)
+
+                callback = self._thinking_callback
+                if callback is None and self.agent_config.verbose:
+
+                    def print_chunk(chunk: str) -> None:
+                        print(chunk, end="", flush=True)
+
+                    callback = print_chunk
+
+                llm_start = time.time()
+                raw_content = self._stream_request(messages, on_thinking_chunk=callback)
+                llm_time = time.time() - llm_start
+                self._total_llm_time += llm_time
+
+                if self.agent_config.verbose:
+                    print(f"\n⏱️  LLM 耗时: {llm_time:.2f}s")
+
+                parsed = self.parser.parse_with_thinking(raw_content)
+                thinking = parsed["thinking"]
+                raw_action = parsed["raw_action"]
+                converted_action = parsed["converted_action"]
+
+                break
+
+            except MAIParseError as e:
+                if self.agent_config.verbose:
+                    logger.warning(f"解析失败 (尝试 {attempt + 1}/{max_retries}): {e}")
+                if attempt == max_retries - 1:
+                    return StepResult(
+                        success=False,
+                        finished=True,
+                        action=None,
+                        thinking="",
+                        message=f"Parse error after {max_retries} retries: {e}",
+                    )
+                continue
+
+            except Exception as e:
+                if self.agent_config.verbose:
+                    logger.warning(
+                        f"模型调用失败 (尝试 {attempt + 1}/{max_retries}): {e}"
+                    )
+                if attempt == max_retries - 1:
+                    if self.agent_config.verbose:
+                        traceback.print_exc()
+                    return StepResult(
+                        success=False,
+                        finished=True,
+                        action=None,
+                        thinking="",
+                        message=f"Model error after {max_retries} retries: {e}",
+                    )
+                continue
+
+        if not raw_content or raw_action is None or converted_action is None:
+            return StepResult(
+                success=False,
+                finished=True,
+                action=None,
+                thinking=thinking,
+                message="Failed to get valid response after retries",
+            )
+
+        if self.agent_config.verbose:
+            print()
+            print("-" * 50)
+            print("🎯 动作:")
+            print(f"  原始: {raw_action}")
+            print(f"  转换: {converted_action}")
+            print("=" * 50 + "\n")
+
+        traj_step = TrajStep(
+            screenshot=pil_image,
+            accessibility_tree=None,
+            prediction=raw_content,
+            action=raw_action,
+            conclusion="",
+            thought=thinking,
+            step_index=self._step_count - 1,
+            agent_type="InternalMAIAgent",
+            model_name=self.model_config.model_name,
+            screenshot_bytes=screenshot_bytes,
+            structured_action={"action_json": raw_action},
+        )
+        self.traj_memory.add_step(traj_step)
+
+        try:
+            action_start = time.time()
+            result = self.action_handler.execute(
+                converted_action, screenshot.width, screenshot.height
+            )
+            action_time = time.time() - action_start
+            self._total_action_time += action_time
+
+            if self.agent_config.verbose:
+                print(f"⚡ 动作执行耗时: {action_time:.2f}s")
+        except Exception as e:
+            if self.agent_config.verbose:
+                traceback.print_exc()
+            result = ActionResult(success=False, should_finish=True, message=str(e))
+
+        finished = converted_action.get("_metadata") == "finish" or result.should_finish
+
+        if finished and self.agent_config.verbose:
+            print("\n" + "🎉 " + "=" * 48)
+            print(
+                f"✅ 任务完成: {result.message or converted_action.get('message', '完成')}"
+            )
+            print("=" * 50)
+            print("\n📊 性能统计:")
+            print(f"  总步数: {self._step_count}")
+            print(f"  总 LLM 耗时: {self._total_llm_time:.2f}s")
+            print(f"  总动作耗时: {self._total_action_time:.2f}s")
+            print(
+                f"  平均每步耗时: {(self._total_llm_time + self._total_action_time) / self._step_count:.2f}s"
+            )
+            if self._total_tokens > 0:
+                print(f"  总 Token 使用: {self._total_tokens}")
+            print("=" * 50 + "\n")
+
+        return StepResult(
+            success=result.success,
+            finished=finished,
+            action=converted_action,
+            thinking=thinking,
+            message=result.message or converted_action.get("message"),
+        )
+
+    def _build_messages(
+        self, instruction: str, screen_info: str, current_screenshot_base64: str
+    ) -> list[dict[str, Any]]:
+        system_prompt = self.agent_config.system_prompt or MAI_MOBILE_SYSTEM_PROMPT
+
+        messages: list[dict[str, Any]] = [
+            MessageBuilder.create_system_message(system_prompt),
+            MessageBuilder.create_user_message(f"{instruction}\n\n{screen_info}"),
+        ]
+
+        history_images = self.traj_memory.get_history_images(self.history_n - 1)
+        history_thoughts = self.traj_memory.get_history_thoughts(self.history_n - 1)
+        history_actions = self.traj_memory.get_history_actions(self.history_n - 1)
+
+        for idx, (img_bytes, thought, action) in enumerate(
+            zip(history_images, history_thoughts, history_actions)
+        ):
+            img_base64 = base64.b64encode(img_bytes).decode("utf-8")
+            messages.append(
+                MessageBuilder.create_user_message(
+                    text=screen_info, image_base64=img_base64
+                )
+            )
+
+            import json
+
+            tool_call_dict = {
+                "name": "mobile_use",
+                "arguments": action,
+            }
+            tool_call_json = json.dumps(tool_call_dict, separators=(",", ":"))
+            assistant_content = (
+                f"<thinking>\n{thought}\n</thinking>\n"
+                f"<tool_call>\n{tool_call_json}\n</tool_call>"
+            )
+            messages.append(MessageBuilder.create_assistant_message(assistant_content))
+
+        messages.append(
+            MessageBuilder.create_user_message(
+                text=screen_info, image_base64=current_screenshot_base64
+            )
+        )
+
+        return messages
+
+    @property
+    def context(self) -> list[dict[str, Any]]:
+        return [
+            {
+                "step": step.step_index,
+                "thought": step.thought,
+                "action": step.action,
+            }
+            for step in self.traj_memory.steps
+        ]
+
+    @property
+    def step_count(self) -> int:
+        return self._step_count
+
+    @property
+    def is_running(self) -> bool:
+        return self._is_running