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

AutoGLM_GUI/agents/glm/agent.py

@@ -0,0 +1,292 @@
+import json
+import traceback
+from typing import Any, Callable, cast
+
+from openai import OpenAI
+
+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.prompt_config import get_messages, get_system_prompt
+
+from .message_builder import MessageBuilder
+from .parser import GLMParser
+
+
+class GLMAgent:
+    def __init__(
+        self,
+        model_config: ModelConfig,
+        agent_config: AgentConfig,
+        device: DeviceProtocol,
+        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.openai_client = OpenAI(
+            base_url=model_config.base_url,
+            api_key=model_config.api_key,
+            timeout=120,
+        )
+        self.parser = GLMParser()
+
+        self.device = device
+        self.action_handler = ActionHandler(
+            device=self.device,
+            confirmation_callback=confirmation_callback,
+            takeover_callback=takeover_callback,
+        )
+
+        self._context: list[dict[str, Any]] = []
+        self._step_count = 0
+        self._is_running = False
+        self._thinking_callback = thinking_callback
+
+    def run(self, task: str) -> str:
+        self._context = []
+        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._context) == 0
+
+        if is_first and not task:
+            raise ValueError("Task is required for the first step")
+
+        return self._execute_step(task, is_first)
+
+    def reset(self) -> None:
+        self._context = []
+        self._step_count = 0
+        self._is_running = False
+
+    def abort(self) -> None:
+        self._is_running = False
+        logger.info("Agent aborted by user")
+
+    def _stream_request(
+        self,
+        messages: list[dict[str, Any]],
+        on_thinking_chunk: Callable[[str], None] | None = None,
+    ) -> tuple[str, str, str]:
+        stream = self.openai_client.chat.completions.create(
+            messages=cast(Any, messages),
+            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 = ["finish(message=", "do(action="]
+        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 = ""
+
+        thinking, action = self._parse_raw_response(raw_content)
+        return thinking, action, raw_content
+
+    def _parse_raw_response(self, content: str) -> tuple[str, str]:
+        if "finish(message=" in content:
+            parts = content.split("finish(message=", 1)
+            thinking = parts[0].strip()
+            action = "finish(message=" + parts[1]
+            return thinking, action
+
+        if "do(action=" in content:
+            parts = content.split("do(action=", 1)
+            thinking = parts[0].strip()
+            action = "do(action=" + parts[1]
+            return thinking, action
+
+        if "<answer>" in content:
+            parts = content.split("<answer>", 1)
+            thinking = parts[0].replace("<think>", "").replace("</think>", "").strip()
+            action = parts[1].replace("</answer>", "").strip()
+            return thinking, action
+
+        return "", 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()
+
+        if is_first:
+            system_prompt = self.agent_config.system_prompt
+            if system_prompt is None:
+                system_prompt = get_system_prompt(self.agent_config.lang)
+
+            self._context.append(MessageBuilder.create_system_message(system_prompt))
+
+            screen_info = MessageBuilder.build_screen_info(current_app)
+            text_content = f"{user_prompt}\n\n{screen_info}"
+
+            self._context.append(
+                MessageBuilder.create_user_message(
+                    text=text_content, image_base64=screenshot.base64_data
+                )
+            )
+        else:
+            screen_info = MessageBuilder.build_screen_info(current_app)
+            text_content = f"** Screen Info **\n\n{screen_info}"
+
+            self._context.append(
+                MessageBuilder.create_user_message(
+                    text=text_content, image_base64=screenshot.base64_data
+                )
+            )
+
+        try:
+            msgs = get_messages(self.agent_config.lang)
+            if self.agent_config.verbose:
+                print("\n" + "=" * 50)
+                print(f"💭 {msgs['thinking']}:")
+                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
+
+            thinking, action_str, raw_content = self._stream_request(
+                self._context, on_thinking_chunk=callback
+            )
+        except Exception as e:
+            if self.agent_config.verbose:
+                traceback.print_exc()
+            return StepResult(
+                success=False,
+                finished=True,
+                action=None,
+                thinking="",
+                message=f"Model error: {e}",
+            )
+
+        try:
+            action = self.parser.parse(action_str)
+        except ValueError as e:
+            if self.agent_config.verbose:
+                logger.warning(f"Failed to parse action: {e}, treating as finish")
+            action = {"_metadata": "finish", "message": action_str}
+
+        if self.agent_config.verbose:
+            print()
+            print("-" * 50)
+            print(f"🎯 {msgs['action']}:")
+            print(json.dumps(action, ensure_ascii=False, indent=2))
+            print("=" * 50 + "\n")
+
+        self._context[-1] = MessageBuilder.remove_images_from_message(self._context[-1])
+
+        try:
+            result = self.action_handler.execute(
+                action, screenshot.width, screenshot.height
+            )
+        except Exception as e:
+            if self.agent_config.verbose:
+                traceback.print_exc()
+            result = ActionResult(success=False, should_finish=True, message=str(e))
+
+        self._context.append(
+            MessageBuilder.create_assistant_message(
+                f"<think>{thinking}</think><answer>{action_str}</answer>"
+            )
+        )
+
+        finished = action.get("_metadata") == "finish" or result.should_finish
+
+        if finished and self.agent_config.verbose:
+            msgs = get_messages(self.agent_config.lang)
+            print("\n" + "🎉 " + "=" * 48)
+            print(
+                f"✅ {msgs['task_completed']}: {result.message or action.get('message', msgs['done'])}"
+            )
+            print("=" * 50 + "\n")
+
+        return StepResult(
+            success=result.success,
+            finished=finished,
+            action=action,
+            thinking=thinking,
+            message=result.message or action.get("message"),
+        )
+
+    @property
+    def context(self) -> list[dict[str, Any]]:
+        return self._context.copy()
+
+    @property
+    def step_count(self) -> int:
+        return self._step_count
+
+    @property
+    def is_running(self) -> bool:
+        return self._is_running

AutoGLM_GUI/agents/glm/message_builder.py

@@ -0,0 +1,81 @@
+"""Message builder for GLM agent - copied from phone_agent.model.client.
+
+This is an exact copy of the upstream MessageBuilder to ensure consistent behavior.
+"""
+
+import json
+from typing import Any
+
+
+class MessageBuilder:
+    """Helper class for building conversation messages."""
+
+    @staticmethod
+    def create_system_message(content: str) -> dict[str, Any]:
+        """Create a system message."""
+        return {"role": "system", "content": content}
+
+    @staticmethod
+    def create_user_message(
+        text: str, image_base64: str | None = None
+    ) -> dict[str, Any]:
+        """
+        Create a user message with optional image.
+
+        Args:
+            text: Text content.
+            image_base64: Optional base64-encoded image.
+
+        Returns:
+            Message dictionary.
+        """
+        content = []
+
+        if image_base64:
+            content.append(
+                {
+                    "type": "image_url",
+                    "image_url": {"url": f"data:image/png;base64,{image_base64}"},
+                }
+            )
+
+        content.append({"type": "text", "text": text})
+
+        return {"role": "user", "content": content}
+
+    @staticmethod
+    def create_assistant_message(content: str) -> dict[str, Any]:
+        """Create an assistant message."""
+        return {"role": "assistant", "content": content}
+
+    @staticmethod
+    def remove_images_from_message(message: dict[str, Any]) -> dict[str, Any]:
+        """
+        Remove image content from a message to save context space.
+
+        Args:
+            message: Message dictionary.
+
+        Returns:
+            Message with images removed.
+        """
+        if isinstance(message.get("content"), list):
+            message["content"] = [
+                item for item in message["content"] if item.get("type") == "text"
+            ]
+        return message
+
+    @staticmethod
+    def build_screen_info(current_app: str, **extra_info) -> str:
+        """
+        Build screen info string for the model.
+
+        Args:
+            current_app: Current app name.
+            **extra_info: Additional info to include.
+
+        Returns:
+            JSON string with screen info.
+        """
+        info = {"current_app": current_app, **extra_info}
+        return json.dumps(info, ensure_ascii=False)

AutoGLM_GUI/agents/glm/parser.py

@@ -0,0 +1,110 @@
+import ast
+from typing import Any
+
+
+class GLMParser:
+    @property
+    def coordinate_scale(self) -> int:
+        return 1000
+
+    def parse(self, raw_response: str) -> dict[str, Any]:
+        action_str = raw_response.strip()
+
+        if action_str.startswith("finish("):
+            return self._parse_finish(action_str)
+        if action_str.startswith("do("):
+            return self._parse_do(action_str)
+        raise ValueError(f"Unknown action format: {action_str}")
+
+    def _parse_finish(self, action_str: str) -> dict[str, Any]:
+        try:
+            params = self._extract_params(action_str, "finish")
+            return {
+                "_metadata": "finish",
+                "message": params.get("message", "Task completed"),
+            }
+        except Exception as e:
+            raise ValueError(f"Failed to parse finish action: {e}") from e
+
+    def _parse_do(self, action_str: str) -> dict[str, Any]:
+        try:
+            params = self._extract_params(action_str, "do")
+            action_name = params.get("action", "")
+
+            result = {
+                "_metadata": "do",
+                "action": action_name,
+            }
+
+            for key, value in params.items():
+                if key != "action":
+                    result[key] = value
+
+            return result
+        except Exception as e:
+            raise ValueError(f"Failed to parse do action: {e}") from e
+
+    def _extract_params(self, action_str: str, function_name: str) -> dict[str, Any]:
+        prefix = f"{function_name}("
+        if not action_str.startswith(prefix):
+            raise ValueError(f"Action does not start with {prefix}")
+
+        params_str = action_str[len(prefix) : -1]
+
+        params: dict[str, Any] = {}
+        current_key = None
+        current_value = ""
+        in_quotes = False
+        quote_char = None
+        bracket_depth = 0
+        i = 0
+
+        while i < len(params_str):
+            char = params_str[i]
+
+            if char in ('"', "'") and (i == 0 or params_str[i - 1] != "\\"):
+                if not in_quotes:
+                    in_quotes = True
+                    quote_char = char
+                elif char == quote_char:
+                    in_quotes = False
+                    quote_char = None
+
+            if not in_quotes:
+                if char in ("[", "{"):
+                    bracket_depth += 1
+                elif char in ("]", "}"):
+                    bracket_depth -= 1
+
+                if char == "=" and bracket_depth == 0:
+                    current_key = current_value.strip()
+                    current_value = ""
+                    i += 1
+                    continue
+
+                if char == "," and bracket_depth == 0:
+                    if current_key:
+                        params[current_key] = self._parse_value(current_value.strip())
+                        current_key = None
+                        current_value = ""
+                    i += 1
+                    continue
+
+            current_value += char
+            i += 1
+
+        if current_key:
+            params[current_key] = self._parse_value(current_value.strip())
+
+        return params
+
+    def _parse_value(self, value_str: str) -> Any:
+        value_str = value_str.strip()
+
+        if not value_str:
+            return ""
+
+        try:
+            return ast.literal_eval(value_str)
+        except (ValueError, SyntaxError):
+            return value_str

AutoGLM_GUI/agents/glm/prompts_en.py

@@ -0,0 +1,77 @@
+from datetime import datetime
+
+today = datetime.today()
+formatted_date = today.strftime("%Y-%m-%d, %A")
+
+SYSTEM_PROMPT = (
+    "The current date: "
+    + formatted_date
+    + """
+# Setup
+You are a professional Android operation agent assistant that can fulfill the user's high-level instructions. Given a screenshot of the Android interface at each step, you first analyze the situation, then plan the best course of action using Python-style pseudo-code.
+
+# More details about the code
+Your response format must be structured as follows:
+
+Think first: Use <think>...</think> to analyze the current screen, identify key elements, and determine the most efficient action.
+Provide the action: Use <answer>...</answer> to return a single line of pseudo-code representing the operation.
+
+Your output should STRICTLY follow the format:
+<think>
+[Your thought]
+</think>
+<answer>
+[Your operation code]
+</answer>
+
+- **Tap**
+  Perform a tap action on a specified screen area. The element is a list of 2 integers, representing the coordinates of the tap point.
+  **Example**:
+  <answer>
+  do(action=\"Tap\", element=[x,y])
+  </answer>
+- **Type**
+  Enter text into the currently focused input field.
+  **Example**:
+  <answer>
+  do(action=\"Type\", text=\"Hello World\")
+  </answer>
+- **Swipe**
+  Perform a swipe action with start point and end point.
+  **Examples**:
+  <answer>
+  do(action=\"Swipe\", start=[x1,y1], end=[x2,y2])
+  </answer>
+- **Long Press**
+  Perform a long press action on a specified screen area.
+  You can add the element to the action to specify the long press area. The element is a list of 2 integers, representing the coordinates of the long press point.
+  **Example**:
+  <answer>
+  do(action=\"Long Press\", element=[x,y])
+  </answer>
+- **Launch**
+  Launch an app. Try to use launch action when you need to launch an app. Check the instruction to choose the right app before you use this action.
+  **Example**:
+  <answer>
+  do(action=\"Launch\", app=\"Settings\")
+  </answer>
+- **Back**
+  Press the Back button to navigate to the previous screen.
+  **Example**:
+  <answer>
+  do(action=\"Back\")
+  </answer>
+- **Finish**
+  Terminate the program and optionally print a message.
+  **Example**:
+  <answer>
+  finish(message=\"Task completed.\")
+  </answer>
+
+
+REMEMBER:
+- Think before you act: Always analyze the current UI and the best course of action before executing any step, and output in <think> part.
+- Only ONE LINE of action in <answer> part per response: Each step must contain exactly one line of executable code.
+- Generate execution code strictly according to format requirements.
+"""
+)

AutoGLM_GUI/agents/glm/prompts_zh.py

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