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

AutoGLM_GUI/api/__init__.py

@@ -7,6 +7,8 @@ from contextlib import asynccontextmanager
 from importlib.resources import files
 from pathlib import Path
 
+from typing import AsyncGenerator
+
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse
@@ -82,7 +84,7 @@ def create_app() -> FastAPI:
 
     # Define combined lifespan
     @asynccontextmanager
-    async def combined_lifespan(app: FastAPI):
+    async def combined_lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
         """Combine app startup logic with MCP lifespan."""
         # App startup
         asyncio.create_task(qr_pairing_manager.cleanup_expired_sessions())

AutoGLM_GUI/api/agents.py

@@ -1,12 +1,12 @@
 """Agent lifecycle and chat routes."""
 
+import asyncio
 import json
 
 from fastapi import APIRouter, HTTPException
 from fastapi.responses import StreamingResponse
 from pydantic import ValidationError
 
-from AutoGLM_GUI.agents.events import AgentEventType
 from AutoGLM_GUI.config import AgentConfig, ModelConfig
 from AutoGLM_GUI.logger import logger
 from AutoGLM_GUI.schemas import (
@@ -154,8 +154,8 @@ def init_agent(request: InitRequest) -> dict:
 
 
 @router.post("/api/chat", response_model=ChatResponse)
-def chat(request: ChatRequest) -> ChatResponse:
-    """发送任务给 Agent 并执行。
+async def chat(request: ChatRequest) -> ChatResponse:
+    """发送任务给 Agent 并执行（支持 AsyncAgent）。
 
     Agent 会在首次使用时自动初始化，无需手动调用 /api/init。
     """
@@ -165,15 +165,27 @@ def chat(request: ChatRequest) -> ChatResponse:
     device_id = request.device_id
     manager = PhoneAgentManager.get_instance()
 
-    # use_agent 默认 auto_initialize=True，会自动初始化 Agent
+    acquired = False
     try:
-        with manager.use_agent(device_id, timeout=None) as agent:
-            result = agent.run(request.message)
-            steps = agent.step_count
-            agent.reset()
-            return ChatResponse(result=result, steps=steps, success=True)
+        acquired = await asyncio.to_thread(
+            manager.acquire_device, device_id, timeout=None, auto_initialize=True
+        )
+        # Use chat context with async agent
+        agent = await asyncio.to_thread(
+            manager.get_agent_with_context,
+            device_id,
+            context="chat",
+            agent_type="glm-async",
+        )
+
+        # AsyncAgent is always used for chat context
+        result = await agent.run(request.message)  # type: ignore[misc]
+
+        steps = agent.step_count
+        agent.reset()
+        return ChatResponse(result=result, steps=steps, success=True)  # type: ignore[arg-type]
+
     except AgentInitializationError as e:
-        # 配置错误或初始化失败
         logger.error(f"Failed to initialize agent for {device_id}: {e}")
         raise HTTPException(
             status_code=500,
@@ -186,17 +198,21 @@ def chat(request: ChatRequest) -> ChatResponse:
     except Exception as e:
         logger.exception(f"Unexpected error in chat for {device_id}")
         return ChatResponse(result=str(e), steps=0, success=False)
+    finally:
+        if acquired:
+            await asyncio.to_thread(manager.release_device, device_id)
 
 
 @router.post("/api/chat/stream")
-def chat_stream(request: ChatRequest):
+async def chat_stream(request: ChatRequest):
     """发送任务给 Agent 并实时推送执行进度（SSE，多设备支持）。
 
     Agent 会在首次使用时自动初始化，无需手动调用 /api/init。
+
+    Chat API 使用 AsyncAgent 实现原生 async streaming 和立即取消。
     """
     from datetime import datetime
 
-    from AutoGLM_GUI.agents.stream_runner import AgentStepStreamer
     from AutoGLM_GUI.device_manager import DeviceManager
     from AutoGLM_GUI.exceptions import AgentInitializationError, DeviceBusyError
     from AutoGLM_GUI.history_manager import history_manager
@@ -206,7 +222,7 @@ def chat_stream(request: ChatRequest):
     device_id = request.device_id
     manager = PhoneAgentManager.get_instance()
 
-    def event_generator():
+    async def event_generator():
         acquired = False
         start_time = datetime.now()
         final_message = ""
@@ -225,29 +241,42 @@ def chat_stream(request: ChatRequest):
         )
 
         try:
-            acquired = manager.acquire_device(
-                device_id, timeout=0, raise_on_timeout=True, auto_initialize=True
+            # 获取设备锁（在线程池中执行）
+            acquired = await asyncio.to_thread(
+                manager.acquire_device,
+                device_id,
+                timeout=0,
+                raise_on_timeout=True,
+                auto_initialize=True,
             )
 
             try:
-                agent = manager.get_agent(device_id)
-                streamer = AgentStepStreamer(agent=agent, task=request.message)
-
-                with streamer.stream_context() as abort_fn:
-                    manager.register_abort_handler(device_id, abort_fn)
-
-                    for event in streamer:
+                # 使用 chat context 获取 AsyncAgent
+                agent = await asyncio.to_thread(
+                    manager.get_agent_with_context,
+                    device_id,
+                    context="chat",
+                    agent_type="glm-async",
+                )
+
+                logger.info(f"Using AsyncAgent for device {device_id}")
+
+                # 注册异步取消处理器
+                async def cancel_handler():
+                    await agent.cancel()  # type: ignore[union-attr]
+
+                await asyncio.to_thread(
+                    manager.register_abort_handler, device_id, cancel_handler
+                )
+
+                try:
+                    # 直接使用 agent.stream()
+                    async for event in agent.stream(request.message):  # type: ignore[union-attr]
                         event_type = event["type"]
                         event_data_dict = event["data"]
 
-                        if (
-                            event_type == AgentEventType.STEP.value
-                            and event_data_dict.get("step") == -1
-                        ):
-                            continue
-
                         # 收集每个 step 的消息
-                        if event_type == AgentEventType.STEP.value:
+                        if event_type == "step":
                             messages.append(
                                 MessageRecord(
                                     role="assistant",
@@ -259,19 +288,28 @@ def chat_stream(request: ChatRequest):
                                 )
                             )
 
-                        if event_type == AgentEventType.DONE.value:
+                        if event_type == "done":
                             final_message = event_data_dict.get("message", "")
                             final_success = event_data_dict.get("success", False)
                             final_steps = event_data_dict.get("steps", 0)
 
-                        event_data = _create_sse_event(event_type, event_data_dict)
-
+                        # 发送 SSE 事件
+                        sse_event = _create_sse_event(event_type, event_data_dict)
                         yield f"event: {event_type}\n"
-                        yield f"data: {json.dumps(event_data, ensure_ascii=False)}\n\n"
+                        yield f"data: {json.dumps(sse_event, ensure_ascii=False)}\n\n"
+
+                except asyncio.CancelledError:
+                    logger.info(f"AsyncAgent task cancelled for device {device_id}")
+                    yield "event: cancelled\n"
+                    yield f"data: {json.dumps({'message': 'Task cancelled by user'})}\n\n"
+                    raise
+
+                finally:
+                    await asyncio.to_thread(manager.unregister_abort_handler, device_id)
 
             finally:
                 if acquired:
-                    manager.release_device(device_id)
+                    await asyncio.to_thread(manager.release_device, device_id)
 
                 device_manager = DeviceManager.get_instance()
                 serialno = device_manager.get_serial_by_device_id(device_id)
@@ -375,14 +413,15 @@ def reset_agent(request: ResetRequest) -> dict:
 
 
 @router.post("/api/chat/abort")
-def abort_chat(request: AbortRequest) -> dict:
-    """中断正在进行的对话流。"""
+async def abort_chat(request: AbortRequest) -> dict:
+    """中断正在进行的对话流 (支持 AsyncAgent)。"""
     from AutoGLM_GUI.phone_agent_manager import PhoneAgentManager
 
     device_id = request.device_id
     manager = PhoneAgentManager.get_instance()
 
-    success = manager.abort_streaming_chat(device_id)
+    # 使用异步方法 (支持 AsyncAgent 和 BaseAgent)
+    success = await manager.abort_streaming_chat_async(device_id)
 
     return {
         "success": success,
@@ -413,6 +452,7 @@ def get_config_endpoint() -> ConfigResponse:
         agent_type=effective_config.agent_type,
         agent_config_params=effective_config.agent_config_params,
         default_max_steps=effective_config.default_max_steps,
+        layered_max_turns=effective_config.layered_max_turns,
         decision_base_url=effective_config.decision_base_url,
         decision_model_name=effective_config.decision_model_name,
         decision_api_key=effective_config.decision_api_key,
@@ -456,6 +496,7 @@ def save_config_endpoint(request: ConfigSaveRequest) -> dict:
             agent_type=request.agent_type,
             agent_config_params=request.agent_config_params,
             default_max_steps=request.default_max_steps,
+            layered_max_turns=request.layered_max_turns,
             decision_base_url=request.decision_base_url,
             decision_model_name=request.decision_model_name,
             decision_api_key=request.decision_api_key,

AutoGLM_GUI/api/devices.py

@@ -15,6 +15,8 @@ from AutoGLM_GUI.logger import logger
 
 from AutoGLM_GUI.schemas import (
     DeviceListResponse,
+    DeviceNameResponse,
+    DeviceNameUpdateRequest,
     DeviceResponse,
     MdnsDeviceResponse,
     MdnsDiscoverResponse,
@@ -454,3 +456,73 @@ def remove_remote_device(
         message=message,
         error=None if success else "remove_failed",
     )
+
+
+@router.put("/api/devices/{serial}/name", response_model=DeviceNameResponse)
+def update_device_name(
+    serial: str, request: DeviceNameUpdateRequest
+) -> DeviceNameResponse:
+    """Update or clear device display name.
+
+    Args:
+        serial: Device hardware serial number
+        request: Contains display_name (str or None to clear)
+
+    Returns:
+        DeviceNameResponse with updated name or error
+    """
+    from AutoGLM_GUI.device_manager import DeviceManager
+
+    try:
+        device_manager = DeviceManager.get_instance()
+        device_manager.set_device_display_name(serial, request.display_name)
+
+        return DeviceNameResponse(
+            success=True,
+            serial=serial,
+            display_name=request.display_name,
+        )
+    except ValueError as e:
+        logger.warning(f"Failed to update device name for {serial}: {e}")
+        return DeviceNameResponse(
+            success=False,
+            serial=serial,
+            error=str(e),
+        )
+    except Exception as e:
+        logger.exception(f"Unexpected error updating device name for {serial}")
+        return DeviceNameResponse(
+            success=False,
+            serial=serial,
+            error=f"Internal error: {str(e)}",
+        )
+
+
+@router.get("/api/devices/{serial}/name", response_model=DeviceNameResponse)
+def get_device_name(serial: str) -> DeviceNameResponse:
+    """Get device display name.
+
+    Args:
+        serial: Device hardware serial number
+
+    Returns:
+        DeviceNameResponse with current display name or None if not set
+    """
+    from AutoGLM_GUI.device_manager import DeviceManager
+
+    try:
+        device_manager = DeviceManager.get_instance()
+        display_name = device_manager.get_device_display_name(serial)
+
+        return DeviceNameResponse(
+            success=True,
+            serial=serial,
+            display_name=display_name,
+        )
+    except Exception as e:
+        logger.exception(f"Unexpected error getting device name for {serial}")
+        return DeviceNameResponse(
+            success=False,
+            serial=serial,
+            error=f"Internal error: {str(e)}",
+        )

AutoGLM_GUI/api/layered_agent.py

@@ -7,7 +7,7 @@ a decision model for planning and autoglm-phone for execution.
 import asyncio
 import json
 import threading
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, AsyncGenerator
 
 from agents import Agent, Runner, SQLiteSession, function_tool
 
@@ -216,7 +216,7 @@ def _sync_chat(device_id: str, message: str) -> str:
                 # 重置 agent 确保干净状态
                 agent.reset()
 
-                result = agent.run(message)
+                result = agent.run(message)  # type: ignore[misc]
                 steps = agent.step_count
 
                 # 检查是否达到步数限制
@@ -384,7 +384,7 @@ class LayeredAgentRequest(BaseModel):
 
 
 @router.post("/api/layered-agent/chat")
-async def layered_agent_chat(request: LayeredAgentRequest):
+async def layered_agent_chat(request: LayeredAgentRequest) -> StreamingResponse:
     """
     Layered agent chat API with streaming execution steps.
 
@@ -407,7 +407,7 @@ async def layered_agent_chat(request: LayeredAgentRequest):
     from AutoGLM_GUI.history_manager import history_manager
     from AutoGLM_GUI.models.history import ConversationRecord
 
-    async def event_generator():
+    async def event_generator() -> AsyncGenerator[str, None]:
         start_time = datetime.now()
         final_output = ""
         final_success = False
@@ -418,11 +418,12 @@ async def layered_agent_chat(request: LayeredAgentRequest):
             session_id = request.session_id or request.device_id or "default"
             session = _get_or_create_session(session_id)
 
-            # Run the agent with streaming and session for memory
+            effective_config = config_manager.get_effective_config()
+
             result = Runner.run_streamed(
                 agent,
                 request.message,
-                max_turns=50,
+                max_turns=effective_config.layered_max_turns,
                 session=session,
             )
 
@@ -663,7 +664,7 @@ class AbortSessionRequest(BaseModel):
 
 
 @router.post("/api/layered-agent/abort")
-def abort_session(request: AbortSessionRequest):
+def abort_session(request: AbortSessionRequest) -> dict[str, Any]:
     """
     Abort a running layered agent session.
 
@@ -697,7 +698,7 @@ class ResetSessionRequest(BaseModel):
 
 
 @router.post("/api/layered-agent/reset")
-def reset_session(request: ResetSessionRequest):
+def reset_session(request: ResetSessionRequest) -> dict[str, Any]:
     """
     Reset/clear a session to forget conversation history.
 

AutoGLM_GUI/api/mcp.py

@@ -1,5 +1,7 @@
 """MCP (Model Context Protocol) tools for AutoGLM-GUI."""
 
+from typing import Any
+
 from typing_extensions import TypedDict
 
 from fastmcp import FastMCP
@@ -56,12 +58,12 @@ def chat(device_id: str, message: str) -> ChatResult:
                 # Reset agent before each chat to ensure clean state
                 agent.reset()
 
-                result = agent.run(message)
+                result = agent.run(message)  # type: ignore[misc]
                 steps = agent.step_count
 
                 # Check if MCP step limit was reached
                 if steps >= MCP_MAX_STEPS and result == "Max steps reached":
-                    return {
+                    return {  # type: ignore[return-value]
                         "result": (
                             f"已达到 MCP 最大步数限制（{MCP_MAX_STEPS}步）。任务可能未完成，"
                             "建议将任务拆分为更小的子任务。"
@@ -70,7 +72,7 @@ def chat(device_id: str, message: str) -> ChatResult:
                         "success": False,
                     }
 
-                return {"result": result, "steps": steps, "success": True}
+                return {"result": result, "steps": steps, "success": True}  # type: ignore[return-value]
 
             finally:
                 # Restore original config
@@ -123,7 +125,7 @@ def list_devices() -> list[DeviceResponse]:
     return devices_with_agents
 
 
-def get_mcp_asgi_app():
+def get_mcp_asgi_app() -> Any:
     """
     Get the MCP server's ASGI app for mounting in FastAPI.
 

AutoGLM_GUI/config_manager.py

@@ -23,6 +23,10 @@ from pydantic import BaseModel, field_validator
 from AutoGLM_GUI.logger import logger
 
 
+LAYERED_MAX_TURNS_DEFAULT = 50
+LAYERED_MAX_TURNS_MIN = 1
+
+
 # ==================== 配置源枚举 ====================
 
 
@@ -53,12 +57,14 @@ class ConfigModel(BaseModel):
     api_key: str = "EMPTY"
 
     # Agent 类型配置
-    agent_type: str = "glm"  # Agent type (e.g., "glm", "mai")
+    agent_type: str = "glm"  # Agent type (e.g., "glm", "mai", "glm-sync")
     agent_config_params: dict | None = None  # Agent-specific configuration
 
     # Agent 执行配置
     default_max_steps: int = 100  # 单次任务最大执行步数
 
+    layered_max_turns: int = LAYERED_MAX_TURNS_DEFAULT
+
     # 决策模型配置（用于分层代理）
     decision_base_url: str | None = None
     decision_model_name: str | None = None
@@ -110,6 +116,13 @@ class ConfigModel(BaseModel):
             raise ValueError("decision_model_name cannot be empty string")
         return v.strip() if v else v
 
+    @field_validator("layered_max_turns")
+    @classmethod
+    def validate_layered_max_turns(cls, v: int) -> int:
+        if v < LAYERED_MAX_TURNS_MIN:
+            raise ValueError(f"layered_max_turns must be >= {LAYERED_MAX_TURNS_MIN}")
+        return v
+
 
 # ==================== 配置层数据类 ====================
 
@@ -126,6 +139,7 @@ class ConfigLayer:
     agent_config_params: Optional[dict] = None
     # Agent 执行配置
     default_max_steps: Optional[int] = None
+    layered_max_turns: Optional[int] = None
     # 决策模型配置
     decision_base_url: Optional[str] = None
     decision_model_name: Optional[str] = None
@@ -160,6 +174,7 @@ class ConfigLayer:
                 "agent_type": self.agent_type,
                 "agent_config_params": self.agent_config_params,
                 "default_max_steps": self.default_max_steps,
+                "layered_max_turns": self.layered_max_turns,
                 "decision_base_url": self.decision_base_url,
                 "decision_model_name": self.decision_model_name,
                 "decision_api_key": self.decision_api_key,
@@ -225,6 +240,7 @@ class UnifiedConfigManager:
             agent_type="glm",
             agent_config_params=None,
             default_max_steps=100,
+            layered_max_turns=LAYERED_MAX_TURNS_DEFAULT,
             decision_base_url=None,
             decision_model_name=None,
             decision_api_key=None,
@@ -248,6 +264,7 @@ class UnifiedConfigManager:
         base_url: Optional[str] = None,
         model_name: Optional[str] = None,
         api_key: Optional[str] = None,
+        layered_max_turns: Optional[int] = None,
     ) -> None:
         """
         设置 CLI 参数配置（最高优先级）.
@@ -256,11 +273,13 @@ class UnifiedConfigManager:
             base_url: 从 --base-url 获取的值
             model_name: 从 --model 获取的值
             api_key: 从 --apikey 获取的值
+            layered_max_turns: 从 --layered-max-turns 获取的值
         """
         self._cli_layer = ConfigLayer(
             base_url=base_url,
             model_name=model_name,
             api_key=api_key,
+            layered_max_turns=layered_max_turns,
             source=ConfigSource.CLI,
         )
         self._effective_config = None  # 清除缓存
@@ -277,6 +296,7 @@ class UnifiedConfigManager:
         - AUTOGLM_DECISION_BASE_URL
         - AUTOGLM_DECISION_MODEL_NAME
         - AUTOGLM_DECISION_API_KEY
+        - AUTOGLM_LAYERED_MAX_TURNS
         """
         base_url = os.getenv("AUTOGLM_BASE_URL")
         model_name = os.getenv("AUTOGLM_MODEL_NAME")
@@ -287,10 +307,19 @@ class UnifiedConfigManager:
         decision_model_name = os.getenv("AUTOGLM_DECISION_MODEL_NAME")
         decision_api_key = os.getenv("AUTOGLM_DECISION_API_KEY")
 
+        layered_max_turns_str = os.getenv("AUTOGLM_LAYERED_MAX_TURNS")
+        layered_max_turns = None
+        if layered_max_turns_str:
+            try:
+                layered_max_turns = int(layered_max_turns_str)
+            except ValueError:
+                logger.warning("AUTOGLM_LAYERED_MAX_TURNS must be an integer")
+
         self._env_layer = ConfigLayer(
             base_url=base_url if base_url else None,
             model_name=model_name if model_name else None,
             api_key=api_key if api_key else None,
+            layered_max_turns=layered_max_turns,
             decision_base_url=decision_base_url if decision_base_url else None,
             decision_model_name=decision_model_name if decision_model_name else None,
             decision_api_key=decision_api_key if decision_api_key else None,
@@ -352,6 +381,7 @@ class UnifiedConfigManager:
                 ),  # 默认 'glm'，兼容旧配置
                 agent_config_params=config_data.get("agent_config_params"),
                 default_max_steps=config_data.get("default_max_steps"),
+                layered_max_turns=config_data.get("layered_max_turns"),
                 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"),
@@ -385,6 +415,7 @@ class UnifiedConfigManager:
         agent_type: Optional[str] = None,
         agent_config_params: Optional[dict] = None,
         default_max_steps: Optional[int] = None,
+        layered_max_turns: Optional[int] = None,
         decision_base_url: Optional[str] = None,
         decision_model_name: Optional[str] = None,
         decision_api_key: Optional[str] = None,
@@ -400,6 +431,7 @@ class UnifiedConfigManager:
             agent_type: Agent 类型（可选，如 "glm", "mai"）
             agent_config_params: Agent 特定配置参数（可选）
             default_max_steps: 默认最大执行步数（可选）
+            layered_max_turns: 分层代理最大轮数（可选）
             decision_base_url: 决策模型 Base URL（可选）
             decision_model_name: 决策模型名称（可选）
             decision_api_key: 决策模型 API Key（可选）
@@ -426,6 +458,8 @@ class UnifiedConfigManager:
                 new_config["agent_config_params"] = agent_config_params
             if default_max_steps is not None:
                 new_config["default_max_steps"] = default_max_steps
+            if layered_max_turns is not None:
+                new_config["layered_max_turns"] = layered_max_turns
 
             # 决策模型配置
             if decision_base_url is not None:
@@ -447,6 +481,7 @@ class UnifiedConfigManager:
                         "agent_type",
                         "agent_config_params",
                         "default_max_steps",
+                        "layered_max_turns",
                         "decision_base_url",
                         "decision_model_name",
                         "decision_api_key",
@@ -540,6 +575,7 @@ class UnifiedConfigManager:
             "decision_base_url",
             "decision_model_name",
             "decision_api_key",
+            "layered_max_turns",
         ]
 
         for key in config_keys:
@@ -708,6 +744,7 @@ class UnifiedConfigManager:
             "decision_base_url": config.decision_base_url,
             "decision_model_name": config.decision_model_name,
             "decision_api_key": config.decision_api_key,
+            "layered_max_turns": config.layered_max_turns,
         }
 
 

AutoGLM_GUI/device_manager.py

@@ -89,6 +89,7 @@ class ManagedDevice:
 
     # Device metadata
     model: Optional[str] = None
+    display_name: Optional[str] = None  # User-defined custom name
 
     # Device-level state
     state: DeviceState = DeviceState.ONLINE
@@ -144,6 +145,7 @@ class ManagedDevice:
             "id": self.primary_device_id,
             "serial": self.serial,
             "model": self.model or "Unknown",
+            "display_name": self.display_name,
             "status": self.status,
             "connection_type": self.connection_type.value,
             "state": self.state.value,
@@ -178,24 +180,20 @@ def _create_managed_device(
         for d in device_infos
     ]
 
-    # Extract model (prefer device with model info)
     model = None
     for device_info in device_infos:
         if device_info.model:
             model = device_info.model
             break
 
-    # Create managed device
     managed = ManagedDevice(
         serial=serial,
         connections=connections,
         model=model,
     )
 
-    # Select primary connection
     managed.select_primary_connection()
 
-    # Set state
     managed.state = (
         DeviceState.ONLINE if managed.status == "device" else DeviceState.OFFLINE
     )
@@ -249,6 +247,10 @@ class DeviceManager:
         self._remote_devices: dict[str, "DeviceProtocol"] = {}
         self._remote_device_configs: dict[str, dict] = {}
 
+        from AutoGLM_GUI.device_metadata_manager import DeviceMetadataManager
+
+        self._metadata_manager = DeviceMetadataManager.get_instance()
+
     @classmethod
     def get_instance(cls, adb_path: str = "adb") -> DeviceManager:
         """Get singleton instance (thread-safe)."""
@@ -449,6 +451,11 @@ class DeviceManager:
             for serial in added_serials:
                 device_infos = grouped_by_serial[serial]
                 managed = _create_managed_device(serial, device_infos)
+
+                display_name = self._metadata_manager.get_display_name(serial)
+                if display_name:
+                    managed.display_name = display_name
+
                 self._devices[serial] = managed
 
                 # Update reverse mapping
@@ -977,3 +984,20 @@ class DeviceManager:
                 from AutoGLM_GUI.devices.adb_device import ADBDevice
 
                 return ADBDevice(managed.primary_device_id)
+
+    def set_device_display_name(self, serial: str, display_name: Optional[str]) -> None:
+        """Set custom display name for device."""
+        self._metadata_manager.set_display_name(serial, display_name)
+
+        with self._devices_lock:
+            if serial in self._devices:
+                self._devices[serial].display_name = display_name
+                logger.debug(f"Updated display name in memory for {serial}")
+
+    def get_device_display_name(self, serial: str) -> Optional[str]:
+        """Get custom display name for device."""
+        with self._devices_lock:
+            if serial in self._devices and self._devices[serial].display_name:
+                return self._devices[serial].display_name
+
+        return self._metadata_manager.get_display_name(serial)