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

AutoGLM_GUI/agents/stream_runner.py

@@ -1,12 +1,11 @@
 import queue
 import threading
-import typing
 from contextlib import contextmanager
-from typing import Any, Callable, Iterator, Optional
+from typing import Any, Callable, Iterator, Optional, TYPE_CHECKING
 
 from AutoGLM_GUI.agents.events import AgentEvent, AgentEventType
 
-if typing.TYPE_CHECKING:
+if TYPE_CHECKING:
     from AutoGLM_GUI.agents.protocols import BaseAgent
 
 
@@ -76,7 +75,7 @@ class AgentStepStreamer:
     def _start_worker(self) -> None:
         """启动 worker 线程."""
 
-        def worker():
+        def worker() -> None:
             try:
                 # 检查停止事件
                 if self._stop_event.is_set():
@@ -87,7 +86,7 @@ class AgentStepStreamer:
                 # 假设 agent 有 _thinking_callback 属性
                 original_callback = getattr(self._agent, "_thinking_callback", None)
 
-                def on_thinking(chunk: str):
+                def on_thinking(chunk: str) -> None:
                     self._event_queue.put(
                         (AgentEventType.THINKING.value, {"chunk": chunk})
                     )
@@ -99,9 +98,14 @@ class AgentStepStreamer:
 
                 try:
                     # 执行 step 循环
+                    # 使用会话级别的标记，而不是 agent.step_count
+                    # 这样每次新对话开始时，第一步都会传递 task
+                    is_first_in_session = True
                     while not self._stop_event.is_set():
-                        is_first = self._agent.step_count == 0
-                        result = self._agent.step(self._task if is_first else None)
+                        result = self._agent.step(
+                            self._task if is_first_in_session else None
+                        )
+                        is_first_in_session = False
 
                         # 发射 step 事件
                         self._event_queue.put(

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=False
+        )
+        # 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,68 +198,118 @@ 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
-    from AutoGLM_GUI.models.history import ConversationRecord
+    from AutoGLM_GUI.models.history import ConversationRecord, MessageRecord
     from AutoGLM_GUI.phone_agent_manager import PhoneAgentManager
 
     device_id = request.device_id
     manager = PhoneAgentManager.get_instance()
 
-    def event_generator():
+    async def event_generator():
         acquired = False
         start_time = datetime.now()
         final_message = ""
         final_success = False
         final_steps = 0
 
+        # 收集完整对话消息
+        messages: list[MessageRecord] = []
+        # 添加用户消息
+        messages.append(
+            MessageRecord(
+                role="user",
+                content=request.message,
+                timestamp=start_time,
+            )
+        )
+
         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=False,
             )
 
             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
-
-                        if event_type == AgentEventType.DONE.value:
+                        # 收集每个 step 的消息
+                        if event_type == "step":
+                            messages.append(
+                                MessageRecord(
+                                    role="assistant",
+                                    content="",
+                                    timestamp=datetime.now(),
+                                    thinking=event_data_dict.get("thinking"),
+                                    action=event_data_dict.get("action"),
+                                    step=event_data_dict.get("step"),
+                                )
+                            )
+
+                        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)
@@ -263,6 +325,7 @@ def chat_stream(request: ChatRequest):
                         duration_ms=int((end_time - start_time).total_seconds() * 1000),
                         source="chat",
                         error_message=None if final_success else final_message,
+                        messages=messages,
                     )
                     history_manager.add_record(serialno, record)
 
@@ -350,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,
@@ -388,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,
@@ -431,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/history.py

@@ -3,7 +3,11 @@
 from fastapi import APIRouter, HTTPException
 
 from AutoGLM_GUI.history_manager import history_manager
-from AutoGLM_GUI.schemas import HistoryListResponse, HistoryRecordResponse
+from AutoGLM_GUI.schemas import (
+    HistoryListResponse,
+    HistoryRecordResponse,
+    MessageRecordResponse,
+)
 
 router = APIRouter()
 
@@ -34,6 +38,17 @@ def list_history(
                 source=r.source,
                 source_detail=r.source_detail,
                 error_message=r.error_message,
+                messages=[
+                    MessageRecordResponse(
+                        role=m.role,
+                        content=m.content,
+                        timestamp=m.timestamp.isoformat(),
+                        thinking=m.thinking,
+                        action=m.action,
+                        step=m.step,
+                    )
+                    for m in r.messages
+                ],
             )
             for r in records
         ],
@@ -61,6 +76,17 @@ def get_history_record(serialno: str, record_id: str) -> HistoryRecordResponse:
         source=record.source,
         source_detail=record.source_detail,
         error_message=record.error_message,
+        messages=[
+            MessageRecordResponse(
+                role=m.role,
+                content=m.content,
+                timestamp=m.timestamp.isoformat(),
+                thinking=m.thinking,
+                action=m.action,
+                step=m.step,
+            )
+            for m in record.messages
+        ],
     )
 
 

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.