autoglm-gui 1.5.4__tar.gz → 1.5.6__tar.gz

{autoglm_gui-1.5.4 → autoglm_gui-1.5.6}/AutoGLM_GUI/agents/glm/async_agent.py

@@ -8,7 +8,8 @@ from typing import Any, AsyncIterator, Callable
 from openai import AsyncOpenAI
 
 from AutoGLM_GUI.actions import ActionHandler, ActionResult
-from AutoGLM_GUI.config import AgentConfig, ModelConfig, StepResult
+from AutoGLM_GUI.agents.protocols import AsyncAgent
+from AutoGLM_GUI.config import AgentConfig, ModelConfig
 from AutoGLM_GUI.device_protocol import DeviceProtocol
 from AutoGLM_GUI.logger import logger
 from AutoGLM_GUI.prompt_config import get_messages, get_system_prompt
@@ -17,7 +18,7 @@ from .message_builder import MessageBuilder
 from .parser import GLMParser
 
 
-class AsyncGLMAgent:
+class AsyncGLMAgent(AsyncAgent):
     """异步 GLM Agent 实现。
 
     核心特性:
@@ -466,54 +467,6 @@ class AsyncGLMAgent:
                 final_message = event["data"].get("message", "")
         return final_message
 
-    async def step(self, task: str | None = None) -> StepResult:
-        """执行单步（兼容接口）。
-
-        Args:
-            task: 任务描述（首步必需，后续可选）
-
-        Returns:
-            StepResult: 步骤结果
-        """
-        is_first_execution = len(self._context) == 1  # 只有 system message
-        if is_first_execution:
-            if not task:
-                raise ValueError("Task is required for the first step")
-
-            # 首次执行：需要先添加用户输入
-            try:
-                screenshot = await asyncio.to_thread(self.device.get_screenshot)
-                current_app = await asyncio.to_thread(self.device.get_current_app)
-            except Exception as e:
-                logger.error(f"Failed to get device info during initialization: {e}")
-                raise RuntimeError(f"Device error: {e}") from e
-
-            screen_info = MessageBuilder.build_screen_info(current_app)
-            initial_message = f"{task}\n\n** Screen Info **\n\n{screen_info}"
-
-            self._context.append(
-                MessageBuilder.create_user_message(
-                    text=initial_message, image_base64=screenshot.base64_data
-                )
-            )
-
-        # 执行步骤
-        result = None
-        async for event in self._execute_step_async():
-            if event["type"] == "step":
-                result = StepResult(
-                    thinking=event["data"]["thinking"],
-                    action=event["data"]["action"],
-                    success=event["data"]["success"],
-                    finished=event["data"]["finished"],
-                    message=event["data"].get("message"),
-                )
-
-        if result is None:
-            raise RuntimeError("Step execution did not produce a result")
-
-        return result
-
     @property
     def step_count(self) -> int:
         return self._step_count

{autoglm_gui-1.5.4 → autoglm_gui-1.5.6}/AutoGLM_GUI/agents/protocols.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import inspect
-from typing import Any, AsyncIterator, Protocol
+from typing import Any, Protocol
 
 from AutoGLM_GUI.config import AgentConfig, ModelConfig, StepResult
 
@@ -76,19 +76,8 @@ class AsyncAgent(Protocol):
         """
         ...
 
-    async def step(self, task: str | None = None) -> StepResult:
-        """执行单步，返回步骤结果。
-
-        Args:
-            task: 任务描述（首步必需，后续可选）
-
-        Returns:
-            StepResult: 步骤结果
-        """
-        ...
-
-    async def stream(self, task: str) -> AsyncIterator[dict[str, Any]]:
-        """流式执行任务，yield 事件字典。
+    def stream(self, task: str) -> Any:
+        """流式执行任务，返回异步生成器。
 
         这是核心方法，支持:
         - 实时流式输出 (thinking chunks)

{autoglm_gui-1.5.4 → autoglm_gui-1.5.6}/AutoGLM_GUI/api/agents.py

@@ -3,8 +3,8 @@
 import asyncio
 import json
 
-from fastapi import APIRouter, HTTPException
-from fastapi.responses import StreamingResponse
+from fastapi import APIRouter, BackgroundTasks, HTTPException
+from fastapi.responses import JSONResponse, StreamingResponse
 from pydantic import ValidationError
 
 from AutoGLM_GUI.config import AgentConfig, ModelConfig
@@ -203,7 +203,7 @@ async def chat(request: ChatRequest) -> ChatResponse:
 
 
 @router.post("/api/chat/stream")
-async def chat_stream(request: ChatRequest):
+async def chat_stream(request: ChatRequest, background_tasks: BackgroundTasks):
     """发送任务给 Agent 并实时推送执行进度（SSE，多设备支持）。
 
     Agent 会在首次使用时自动初始化，无需手动调用 /api/init。
@@ -221,8 +221,53 @@ async def chat_stream(request: ChatRequest):
     device_id = request.device_id
     manager = PhoneAgentManager.get_instance()
 
+    # ===== 在外层获取设备锁 =====
+    acquired = False
+    try:
+        acquired = await asyncio.to_thread(
+            manager.acquire_device,
+            device_id,
+            timeout=0,
+            raise_on_timeout=True,
+            auto_initialize=True,
+        )
+    except DeviceBusyError:
+        logger.warning(f"Device {device_id} is busy, returning 409")
+        return JSONResponse(
+            status_code=409,
+            content={"detail": f"Device {device_id} is busy. Please wait."},
+        )
+    except AgentInitializationError as e:
+        logger.error(f"Failed to initialize agent for {device_id}: {e}")
+        return JSONResponse(
+            status_code=500,
+            content={
+                "detail": f"初始化失败: {str(e)}. 请检查全局配置 (base_url, api_key, model_name)"
+            },
+        )
+
+    logger.info(f"Device lock acquired for {device_id}")
+
+    # ===== 定义清理函数 =====
+    async def cleanup():
+        """Background task: 清理资源"""
+        try:
+            await asyncio.to_thread(manager.unregister_abort_handler, device_id)
+            logger.debug(f"Abort handler unregistered for {device_id}")
+        except Exception as e:
+            logger.warning(f"Failed to unregister abort handler for {device_id}: {e}")
+
+        if acquired:
+            try:
+                await asyncio.to_thread(manager.release_device, device_id)
+                logger.info(f"Device lock released for {device_id} (background task)")
+            except Exception as e:
+                logger.error(f"Failed to release device lock for {device_id}: {e}")
+
+    # ===== 注册 background task =====
+    background_tasks.add_task(cleanup)
+
     async def event_generator():
-        acquired = False
         start_time = datetime.now()
         final_message = ""
         final_success = False
@@ -240,93 +285,57 @@ async def chat_stream(request: ChatRequest):
         )
 
         try:
-            # 获取设备锁（在线程池中执行）
-            acquired = await asyncio.to_thread(
-                manager.acquire_device,
+            # 使用 chat context 获取 AsyncAgent
+            agent = await asyncio.to_thread(
+                manager.get_agent_with_context,
                 device_id,
-                timeout=0,
-                raise_on_timeout=True,
-                auto_initialize=True,
+                context="chat",
+                agent_type="glm-async",
             )
 
-            try:
-                # 使用 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"]
-
-                        # 收集每个 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)
-
-                        # 发送 SSE 事件
-                        sse_event = _create_sse_event(event_type, event_data_dict)
-                        yield f"event: {event_type}\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:
-                    await asyncio.to_thread(manager.release_device, device_id)
-
-                device_manager = DeviceManager.get_instance()
-                serialno = device_manager.get_serial_by_device_id(device_id)
-                if serialno and final_message:
-                    end_time = datetime.now()
-                    record = ConversationRecord(
-                        task_text=request.message,
-                        final_message=final_message,
-                        success=final_success,
-                        steps=final_steps,
-                        start_time=start_time,
-                        end_time=end_time,
-                        duration_ms=int((end_time - start_time).total_seconds() * 1000),
-                        source="chat",
-                        error_message=None if final_success else final_message,
-                        messages=messages,
+            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
+            )
+
+            # 直接使用 agent.stream()
+            async for event in agent.stream(request.message):  # type: ignore[union-attr]
+                event_type = event["type"]
+                event_data_dict = event["data"]
+
+                # 收集每个 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"),
+                        )
                     )
-                    history_manager.add_record(serialno, record)
+
+                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)
+
+                # 发送 SSE 事件
+                sse_event = _create_sse_event(event_type, event_data_dict)
+                yield f"event: {event_type}\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，让 generator 正常结束
 
         except AgentInitializationError as e:
             logger.error(f"Failed to initialize agent for {device_id}: {e}")
@@ -339,17 +348,33 @@ async def chat_stream(request: ChatRequest):
             )
             yield "event: error\n"
             yield f"data: {json.dumps(error_data, ensure_ascii=False)}\n\n"
-        except DeviceBusyError:
-            error_data = _create_sse_event("error", {"message": "Device is busy"})
-            yield "event: error\n"
-            yield f"data: {json.dumps(error_data, ensure_ascii=False)}\n\n"
+
         except Exception as e:
             logger.exception(f"Error in streaming chat for {device_id}")
             error_data = _create_sse_event("error", {"message": str(e)})
             yield "event: error\n"
             yield f"data: {json.dumps(error_data, ensure_ascii=False)}\n\n"
-        finally:
-            manager.unregister_abort_handler(device_id)
+
+        # ===== 保存历史记录 =====
+        device_manager = DeviceManager.get_instance()
+        serialno = device_manager.get_serial_by_device_id(device_id)
+        if serialno and final_message:
+            end_time = datetime.now()
+            record = ConversationRecord(
+                task_text=request.message,
+                final_message=final_message,
+                success=final_success,
+                steps=final_steps,
+                start_time=start_time,
+                end_time=end_time,
+                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)
+
+        # Generator 正常结束，cleanup 会在 background task 中执行
 
     return StreamingResponse(
         event_generator(),

{autoglm_gui-1.5.4 → autoglm_gui-1.5.6}/AutoGLM_GUI/api/devices.py

@@ -14,6 +14,13 @@ from AutoGLM_GUI.adb_plus.qr_pair import qr_pairing_manager
 from AutoGLM_GUI.logger import logger
 
 from AutoGLM_GUI.schemas import (
+    DeviceGroupAssignRequest,
+    DeviceGroupCreateRequest,
+    DeviceGroupListResponse,
+    DeviceGroupOperationResponse,
+    DeviceGroupReorderRequest,
+    DeviceGroupResponse,
+    DeviceGroupUpdateRequest,
     DeviceListResponse,
     DeviceNameResponse,
     DeviceNameUpdateRequest,
@@ -49,9 +56,13 @@ def _build_device_response_with_agent(
     API 层负责协调 DeviceManager 和 PhoneAgentManager，
     通过遍历设备的所有连接来查找已初始化的 Agent。
     """
+    from AutoGLM_GUI.device_group_manager import device_group_manager
 
     response = device.to_dict()
 
+    # 添加分组信息
+    response["group_id"] = device_group_manager.get_device_group(device.serial)
+
     # 遍历设备的所有连接，查找已初始化的 Agent
     # 使用 device.connections 公开属性（ManagedDevice 提供）
     for conn in device.connections:
@@ -526,3 +537,169 @@ def get_device_name(serial: str) -> DeviceNameResponse:
             serial=serial,
             error=f"Internal error: {str(e)}",
         )
+
+
+# Device Group Routes
+
+
+@router.get("/api/device-groups", response_model=DeviceGroupListResponse)
+def list_device_groups() -> DeviceGroupListResponse:
+    """列出所有设备分组."""
+    from AutoGLM_GUI.device_group_manager import device_group_manager
+    from AutoGLM_GUI.device_manager import DeviceManager
+
+    groups = device_group_manager.list_groups()
+    device_manager = DeviceManager.get_instance()
+
+    # 获取当前所有设备的 serial 列表
+    managed_devices = device_manager.get_devices()
+    device_serials = {d.serial for d in managed_devices}
+
+    # 计算每个分组的设备数量
+    assignments = device_group_manager.get_all_assignments()
+
+    group_responses = []
+    for group in groups:
+        # 统计分配到该分组的设备数量（只计算当前在线/已知的设备）
+        if group.id == "default":
+            # 默认分组：包含未显式分配的设备
+            assigned_to_other = {
+                serial for serial, gid in assignments.items() if gid != "default"
+            }
+            device_count = len(device_serials - assigned_to_other)
+        else:
+            device_count = sum(
+                1
+                for serial, gid in assignments.items()
+                if gid == group.id and serial in device_serials
+            )
+
+        group_responses.append(
+            DeviceGroupResponse(
+                id=group.id,
+                name=group.name,
+                order=group.order,
+                created_at=group.created_at.isoformat(),
+                updated_at=group.updated_at.isoformat(),
+                is_default=group.is_default,
+                device_count=device_count,
+            )
+        )
+
+    return DeviceGroupListResponse(groups=group_responses)
+
+
+@router.post("/api/device-groups", response_model=DeviceGroupResponse)
+def create_device_group(request: DeviceGroupCreateRequest) -> DeviceGroupResponse:
+    """创建新的设备分组."""
+    from AutoGLM_GUI.device_group_manager import device_group_manager
+
+    group = device_group_manager.create_group(request.name)
+
+    return DeviceGroupResponse(
+        id=group.id,
+        name=group.name,
+        order=group.order,
+        created_at=group.created_at.isoformat(),
+        updated_at=group.updated_at.isoformat(),
+        is_default=group.is_default,
+        device_count=0,
+    )
+
+
+@router.put("/api/device-groups/{group_id}", response_model=DeviceGroupResponse)
+def update_device_group(
+    group_id: str, request: DeviceGroupUpdateRequest
+) -> DeviceGroupResponse:
+    """更新设备分组名称."""
+    from fastapi import HTTPException
+
+    from AutoGLM_GUI.device_group_manager import device_group_manager
+
+    group = device_group_manager.update_group(group_id, request.name)
+    if not group:
+        raise HTTPException(status_code=404, detail="Group not found")
+
+    return DeviceGroupResponse(
+        id=group.id,
+        name=group.name,
+        order=group.order,
+        created_at=group.created_at.isoformat(),
+        updated_at=group.updated_at.isoformat(),
+        is_default=group.is_default,
+        device_count=0,  # 不重新计算，前端可以刷新列表获取
+    )
+
+
+@router.delete(
+    "/api/device-groups/{group_id}", response_model=DeviceGroupOperationResponse
+)
+def delete_device_group(group_id: str) -> DeviceGroupOperationResponse:
+    """删除设备分组（设备移回默认分组）."""
+    from AutoGLM_GUI.device_group_manager import device_group_manager
+    from AutoGLM_GUI.models.device_group import DEFAULT_GROUP_ID
+
+    if group_id == DEFAULT_GROUP_ID:
+        return DeviceGroupOperationResponse(
+            success=False,
+            message="Cannot delete default group",
+            error="cannot_delete_default",
+        )
+
+    success = device_group_manager.delete_group(group_id)
+
+    if success:
+        return DeviceGroupOperationResponse(
+            success=True,
+            message="Group deleted, devices moved to default group",
+        )
+    else:
+        return DeviceGroupOperationResponse(
+            success=False,
+            message="Group not found",
+            error="group_not_found",
+        )
+
+
+@router.put("/api/device-groups/reorder", response_model=DeviceGroupOperationResponse)
+def reorder_device_groups(
+    request: DeviceGroupReorderRequest,
+) -> DeviceGroupOperationResponse:
+    """调整设备分组顺序."""
+    from AutoGLM_GUI.device_group_manager import device_group_manager
+
+    success = device_group_manager.reorder_groups(request.group_ids)
+
+    if success:
+        return DeviceGroupOperationResponse(
+            success=True,
+            message="Groups reordered successfully",
+        )
+    else:
+        return DeviceGroupOperationResponse(
+            success=False,
+            message="Failed to reorder groups",
+            error="reorder_failed",
+        )
+
+
+@router.put("/api/devices/{serial}/group", response_model=DeviceGroupOperationResponse)
+def assign_device_to_group(
+    serial: str, request: DeviceGroupAssignRequest
+) -> DeviceGroupOperationResponse:
+    """分配设备到指定分组."""
+    from AutoGLM_GUI.device_group_manager import device_group_manager
+
+    success = device_group_manager.assign_device(serial, request.group_id)
+
+    if success:
+        return DeviceGroupOperationResponse(
+            success=True,
+            message=f"Device assigned to group {request.group_id}",
+        )
+    else:
+        return DeviceGroupOperationResponse(
+            success=False,
+            message="Failed to assign device to group",
+            error="assignment_failed",
+        )

{autoglm_gui-1.5.4 → autoglm_gui-1.5.6}/AutoGLM_GUI/api/scheduled_tasks.py

@@ -19,13 +19,17 @@ def _task_to_response(task) -> ScheduledTaskResponse:
         id=task.id,
         name=task.name,
         workflow_uuid=task.workflow_uuid,
-        device_serialno=task.device_serialno,
+        device_serialnos=task.device_serialnos,
+        device_group_id=task.device_group_id,
         cron_expression=task.cron_expression,
         enabled=task.enabled,
         created_at=task.created_at.isoformat(),
         updated_at=task.updated_at.isoformat(),
         last_run_time=task.last_run_time.isoformat() if task.last_run_time else None,
         last_run_success=task.last_run_success,
+        last_run_status=task.last_run_status,
+        last_run_success_count=task.last_run_success_count,
+        last_run_total_count=task.last_run_total_count,
         last_run_message=task.last_run_message,
         next_run_time=next_run.isoformat() if next_run else None,
     )
@@ -48,7 +52,8 @@ def create_scheduled_task(request: ScheduledTaskCreate) -> ScheduledTaskResponse
     task = scheduler_manager.create_task(
         name=request.name,
         workflow_uuid=request.workflow_uuid,
-        device_serialno=request.device_serialno,
+        device_serialnos=request.device_serialnos,
+        device_group_id=request.device_group_id,
         cron_expression=request.cron_expression,
         enabled=request.enabled,
     )