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

AutoGLM_GUI/api/layered_agent.py

@@ -6,9 +6,13 @@ a decision model for planning and autoglm-phone for execution.
 
 import asyncio
 import json
-from typing import Any
+import threading
+from typing import TYPE_CHECKING, Any
 
 from agents import Agent, Runner, SQLiteSession, function_tool
+
+if TYPE_CHECKING:
+    from agents.result import RunResultStreaming
 from agents.models.openai_chatcompletions import OpenAIChatCompletionsModel
 from fastapi import APIRouter
 from fastapi.responses import StreamingResponse
@@ -24,6 +28,11 @@ router = APIRouter()
 # 存储每个 session_id 对应的 SQLiteSession（内存模式）
 _sessions: dict[str, SQLiteSession] = {}
 
+# ==================== 活跃运行管理 ====================
+# 存储每个 session_id 对应的活跃 RunResultStreaming 实例，用于 abort
+_active_runs: dict[str, "RunResultStreaming"] = {}
+_active_runs_lock = threading.Lock()
+
 
 def _get_or_create_session(session_id: str) -> SQLiteSession:
     """获取或创建指定 session_id 的内存 session."""
@@ -146,7 +155,9 @@ def _sync_list_devices() -> str:
         _build_device_response_with_agent(d, agent_manager) for d in managed_devices
     ]
 
-    return json.dumps(devices_with_agents, ensure_ascii=False, indent=2)
+    # Convert DeviceResponse Pydantic models to dicts before JSON serialization
+    devices_dict = [device.model_dump() for device in devices_with_agents]
+    return json.dumps(devices_dict, ensure_ascii=False, indent=2)
 
 
 @function_tool
@@ -307,14 +318,35 @@ def _create_planner_agent(client: AsyncOpenAI) -> Agent[Any]:
 # Global agent instance (lazy initialized)
 _client: AsyncOpenAI | None = None
 _agent: Agent[Any] | None = None
+_cached_config_hash: str | None = None
+
+
+def _compute_config_hash() -> str:
+    import hashlib
+
+    config = config_manager.get_effective_config()
+    config_str = config.model_dump_json()
+    return hashlib.md5(config_str.encode()).hexdigest()
 
 
 def _ensure_agent() -> Agent[Any]:
-    """Ensure the planner agent is initialized."""
-    global _client, _agent
-    if _agent is None:
+    global _client, _agent, _cached_config_hash
+
+    current_hash = _compute_config_hash()
+
+    if _agent is None or _cached_config_hash != current_hash:
+        if _agent is not None and _cached_config_hash != current_hash:
+            logger.info(
+                f"[LayeredAgent] Config changed (hash: {_cached_config_hash} -> {current_hash}), reloading agent..."
+            )
+
         _client = _setup_openai_client()
         _agent = _create_planner_agent(_client)
+        _cached_config_hash = current_hash
+        logger.info(
+            f"[LayeredAgent] Agent initialized/reloaded with config hash: {current_hash}"
+        )
+
     return _agent
 
 
@@ -366,175 +398,182 @@ async def layered_agent_chat(request: LayeredAgentRequest):
                 session=session,
             )
 
+            # 保存活跃运行实例，用于 abort
+            with _active_runs_lock:
+                _active_runs[session_id] = result
+
             current_tool_call: dict[str, Any] | None = None
 
-            async for event in result.stream_events():
-                if isinstance(event, RawResponsesStreamEvent):
-                    # Raw response chunk - could contain thinking
-                    pass
-
-                elif isinstance(event, RunItemStreamEvent):
-                    item = event.item
-
-                    # Handle different item types
-                    item_type = getattr(item, "type", None)
-
-                    if item_type == "tool_call_item":
-                        # Tool call started - extract name from raw_item
-                        tool_name = "unknown"
-                        tool_args: dict[str, Any] = {}
-
-                        # Try to get from raw_item
-                        if hasattr(item, "raw_item") and item.raw_item:
-                            raw = item.raw_item
-
-                            # Handle dict format (sometimes returned as dict)
-                            if isinstance(raw, dict):
-                                tool_name = raw.get(
-                                    "name",
-                                    raw.get("function", {}).get("name", "unknown"),
-                                )
-                                args_str = raw.get(
-                                    "arguments",
-                                    raw.get("function", {}).get("arguments", "{}"),
-                                )
-                                try:
-                                    tool_args = (
-                                        json.loads(args_str)
-                                        if isinstance(args_str, str)
-                                        else args_str
+            try:
+                async for event in result.stream_events():
+                    if isinstance(event, RawResponsesStreamEvent):
+                        # Raw response chunk - could contain thinking
+                        pass
+
+                    elif isinstance(event, RunItemStreamEvent):
+                        item = event.item
+
+                        # Handle different item types
+                        item_type = getattr(item, "type", None)
+
+                        if item_type == "tool_call_item":
+                            # Tool call started - extract name from raw_item
+                            tool_name = "unknown"
+                            tool_args: dict[str, Any] = {}
+
+                            # Try to get from raw_item
+                            if hasattr(item, "raw_item") and item.raw_item:
+                                raw = item.raw_item
+
+                                # Handle dict format (sometimes returned as dict)
+                                if isinstance(raw, dict):
+                                    tool_name = raw.get(
+                                        "name",
+                                        raw.get("function", {}).get("name", "unknown"),
+                                    )
+                                    args_str = raw.get(
+                                        "arguments",
+                                        raw.get("function", {}).get("arguments", "{}"),
                                     )
-                                except Exception:
-                                    tool_args = {"raw": str(args_str)}
-                            else:
-                                # Chat Completions API format: raw_item.function.name
-                                if hasattr(raw, "function") and raw.function:
-                                    func = raw.function
-                                    if hasattr(func, "name"):
-                                        tool_name = func.name
-                                    if hasattr(func, "arguments"):
-                                        try:
-                                            tool_args = (
-                                                json.loads(func.arguments)
-                                                if isinstance(func.arguments, str)
-                                                else func.arguments
-                                            )
-                                        except Exception:
-                                            tool_args = {"raw": str(func.arguments)}
-                                # Responses API format: raw_item.name directly
-                                elif hasattr(raw, "name") and raw.name:
-                                    tool_name = raw.name
-                                    if hasattr(raw, "arguments"):
-                                        try:
-                                            tool_args = (
-                                                json.loads(raw.arguments)
-                                                if isinstance(raw.arguments, str)
-                                                else raw.arguments
-                                            )
-                                        except Exception:
-                                            tool_args = {"raw": str(raw.arguments)}
-
-                        # Fallback to direct item attributes
-                        if tool_name == "unknown":
-                            if hasattr(item, "name") and item.name:
-                                tool_name = item.name
-                            elif hasattr(item, "call") and item.call:
-                                call = item.call
-                                if hasattr(call, "function") and call.function:
-                                    if hasattr(call.function, "name"):
-                                        tool_name = call.function.name
-                                    if hasattr(call.function, "arguments"):
-                                        try:
-                                            tool_args = (
-                                                json.loads(call.function.arguments)
-                                                if isinstance(
-                                                    call.function.arguments, str
+                                    try:
+                                        tool_args = (
+                                            json.loads(args_str)
+                                            if isinstance(args_str, str)
+                                            else args_str
+                                        )
+                                    except Exception:
+                                        tool_args = {"raw": str(args_str)}
+                                else:
+                                    func = getattr(raw, "function", None)
+                                    if func:
+                                        tool_name = getattr(func, "name", "unknown")
+                                        args_val = getattr(func, "arguments", None)
+                                        if args_val:
+                                            try:
+                                                tool_args = (
+                                                    json.loads(args_val)
+                                                    if isinstance(args_val, str)
+                                                    else args_val
                                                 )
-                                                else call.function.arguments
-                                            )
-                                        except Exception:
-                                            tool_args = {
-                                                "raw": str(call.function.arguments)
-                                            }
-                                elif hasattr(call, "name"):
-                                    tool_name = call.name
-                                    if hasattr(call, "arguments"):
-                                        try:
-                                            tool_args = (
-                                                json.loads(call.arguments)
-                                                if isinstance(call.arguments, str)
-                                                else call.arguments
-                                            )
-                                        except Exception:
-                                            tool_args = {"raw": str(call.arguments)}
-
-                        logger.info(
-                            f"[LayeredAgent] Tool call: {tool_name}, args keys: {list(tool_args.keys()) if isinstance(tool_args, dict) else 'not dict'}"
-                        )
-
-                        current_tool_call = {
-                            "name": tool_name,
-                            "args": tool_args,
-                        }
-
-                        event_data = {
-                            "type": "tool_call",
-                            "tool_name": tool_name,
-                            "tool_args": tool_args,
-                        }
-                        yield f"data: {json.dumps(event_data, ensure_ascii=False)}\n\n"
-
-                    elif item_type == "tool_call_output_item":
-                        # Tool call result
-                        output = getattr(item, "output", "")
-
-                        # Get tool name from current_tool_call or try to extract from item
-                        tool_name = (
-                            current_tool_call["name"]
-                            if current_tool_call
-                            else "unknown"
-                        )
-
-                        # Try to get tool name from raw_item if available
-                        if (
-                            tool_name == "unknown"
-                            and hasattr(item, "raw_item")
-                            and item.raw_item
-                        ):
-                            if hasattr(item.raw_item, "name"):
-                                tool_name = item.raw_item.name
-
-                        logger.info(
-                            f"[LayeredAgent] Tool result for {tool_name}: {str(output)[:100] if output else 'empty'}..."
-                        )
-
-                        event_data = {
-                            "type": "tool_result",
-                            "tool_name": tool_name,
-                            "result": output,
-                        }
-                        yield f"data: {json.dumps(event_data, ensure_ascii=False)}\n\n"
-                        current_tool_call = None
-
-                    elif item_type == "message_output_item":
-                        # Final message
-                        content = ""
-                        if hasattr(item, "raw_item") and item.raw_item:
-                            if (
-                                hasattr(item.raw_item, "content")
-                                and item.raw_item.content
-                            ):
-                                for c in item.raw_item.content:
-                                    if hasattr(c, "text"):
-                                        content += c.text
-
-                        if content:
+                                            except Exception:
+                                                tool_args = {"raw": str(args_val)}
+                                    else:
+                                        name_val = getattr(raw, "name", None)
+                                        if name_val:
+                                            tool_name = name_val
+                                            args_val = getattr(raw, "arguments", None)
+                                            if args_val:
+                                                try:
+                                                    tool_args = (
+                                                        json.loads(args_val)
+                                                        if isinstance(args_val, str)
+                                                        else args_val
+                                                    )
+                                                except Exception:
+                                                    tool_args = {"raw": str(args_val)}
+
+                            # Fallback to direct item attributes
+                            if tool_name == "unknown":
+                                if hasattr(item, "name") and item.name:
+                                    tool_name = item.name
+                                elif hasattr(item, "call") and item.call:
+                                    call = item.call
+                                    if hasattr(call, "function") and call.function:
+                                        if hasattr(call.function, "name"):
+                                            tool_name = call.function.name
+                                        if hasattr(call.function, "arguments"):
+                                            try:
+                                                tool_args = (
+                                                    json.loads(call.function.arguments)
+                                                    if isinstance(
+                                                        call.function.arguments, str
+                                                    )
+                                                    else call.function.arguments
+                                                )
+                                            except Exception:
+                                                tool_args = {
+                                                    "raw": str(call.function.arguments)
+                                                }
+                                    elif hasattr(call, "name"):
+                                        tool_name = call.name
+                                        if hasattr(call, "arguments"):
+                                            try:
+                                                tool_args = (
+                                                    json.loads(call.arguments)
+                                                    if isinstance(call.arguments, str)
+                                                    else call.arguments
+                                                )
+                                            except Exception:
+                                                tool_args = {"raw": str(call.arguments)}
+
+                            logger.info(
+                                f"[LayeredAgent] Tool call: {tool_name}, args keys: {list(tool_args.keys()) if isinstance(tool_args, dict) else 'not dict'}"
+                            )
+
+                            current_tool_call = {
+                                "name": tool_name,
+                                "args": tool_args,
+                            }
+
                             event_data = {
-                                "type": "message",
-                                "content": content,
+                                "type": "tool_call",
+                                "tool_name": tool_name,
+                                "tool_args": tool_args,
                             }
                             yield f"data: {json.dumps(event_data, ensure_ascii=False)}\n\n"
 
+                        elif item_type == "tool_call_output_item":
+                            # Tool call result
+                            output = getattr(item, "output", "")
+
+                            # Get tool name from current_tool_call or try to extract from item
+                            tool_name = (
+                                current_tool_call["name"]
+                                if current_tool_call
+                                else "unknown"
+                            )
+
+                            raw_item = getattr(item, "raw_item", None)
+                            if tool_name == "unknown" and raw_item:
+                                name_val = getattr(raw_item, "name", None)
+                                if name_val:
+                                    tool_name = name_val
+
+                            logger.info(
+                                f"[LayeredAgent] Tool result for {tool_name}: {str(output)[:100] if output else 'empty'}..."
+                            )
+
+                            event_data = {
+                                "type": "tool_result",
+                                "tool_name": tool_name,
+                                "result": output,
+                            }
+                            yield f"data: {json.dumps(event_data, ensure_ascii=False)}\n\n"
+                            current_tool_call = None
+
+                        elif item_type == "message_output_item":
+                            content = ""
+                            raw_item = getattr(item, "raw_item", None)
+                            if raw_item:
+                                raw_content = getattr(raw_item, "content", None)
+                                if raw_content:
+                                    for c in raw_content:
+                                        text_val = getattr(c, "text", None)
+                                        if text_val:
+                                            content += text_val
+
+                            if content:
+                                event_data = {
+                                    "type": "message",
+                                    "content": content,
+                                }
+                                yield f"data: {json.dumps(event_data, ensure_ascii=False)}\n\n"
+
+            finally:
+                # 清理活跃运行实例
+                with _active_runs_lock:
+                    _active_runs.pop(session_id, None)
+
             # Final result
             final_output = (
                 result.final_output if hasattr(result, "final_output") else ""
@@ -565,6 +604,40 @@ async def layered_agent_chat(request: LayeredAgentRequest):
     )
 
 
+class AbortSessionRequest(BaseModel):
+    """Request for aborting a running session."""
+
+    session_id: str
+
+
+@router.post("/api/layered-agent/abort")
+def abort_session(request: AbortSessionRequest):
+    """
+    Abort a running layered agent session.
+
+    Uses the OpenAI agents SDK's native cancel() method to stop execution.
+    """
+    session_id = request.session_id
+
+    with _active_runs_lock:
+        if session_id in _active_runs:
+            result = _active_runs[session_id]
+            result.cancel(mode="immediate")
+            logger.info(f"[LayeredAgent] Aborted session: {session_id}")
+            return {
+                "success": True,
+                "message": f"Session {session_id} abort signal sent",
+            }
+        else:
+            logger.warning(
+                f"[LayeredAgent] No active run found for session: {session_id}"
+            )
+            return {
+                "success": False,
+                "message": f"No active run found for session {session_id}",
+            }
+
+
 class ResetSessionRequest(BaseModel):
     """Request for resetting a session."""
 

AutoGLM_GUI/api/mcp.py

@@ -1,11 +1,19 @@
 """MCP (Model Context Protocol) tools for AutoGLM-GUI."""
 
-from typing import Any, Dict, List
+from typing_extensions import TypedDict
 
 from fastmcp import FastMCP
 
 from AutoGLM_GUI.logger import logger
 from AutoGLM_GUI.prompts import MCP_SYSTEM_PROMPT_ZH
+from AutoGLM_GUI.schemas import DeviceResponse
+
+
+class ChatResult(TypedDict):
+    result: str
+    steps: int
+    success: bool
+
 
 # 创建 MCP 服务器实例
 mcp = FastMCP("AutoGLM-GUI MCP Server")
@@ -15,7 +23,7 @@ MCP_MAX_STEPS = 5
 
 
 @mcp.tool()
-def chat(device_id: str, message: str) -> Dict[str, Any]:
+def chat(device_id: str, message: str) -> ChatResult:
     """
     Send a task to the AutoGLM Phone Agent for execution.
 
@@ -26,13 +34,6 @@ def chat(device_id: str, message: str) -> Dict[str, Any]:
     Args:
         device_id: Device identifier (e.g., "192.168.1.100:5555" or serial)
         message: Natural language task (e.g., "打开微信", "发送消息")
-
-    Returns:
-        {
-            "result": str,    # Task execution result
-            "steps": int,     # Number of steps taken
-            "success": bool   # Success flag
-        }
     """
     from AutoGLM_GUI.exceptions import DeviceBusyError
     from AutoGLM_GUI.phone_agent_manager import PhoneAgentManager
@@ -84,7 +85,7 @@ def chat(device_id: str, message: str) -> Dict[str, Any]:
 
 
 @mcp.tool()
-def list_devices() -> List[Dict[str, Any]]:
+def list_devices() -> list[DeviceResponse]:
     """
     List all connected ADB devices and their agent status.
 

AutoGLM_GUI/api/version.py

@@ -3,8 +3,9 @@
 import json
 import re
 import time
+import urllib.error
 import urllib.request
-from typing import Any
+from typing_extensions import TypedDict
 
 from fastapi import APIRouter
 
@@ -12,13 +13,30 @@ from AutoGLM_GUI.logger import logger
 from AutoGLM_GUI.schemas import VersionCheckResponse
 from AutoGLM_GUI.version import APP_VERSION
 
+
+class GitHubRelease(TypedDict, total=False):
+    """GitHub Release API response structure."""
+
+    tag_name: str
+    html_url: str
+    published_at: str
+
+
+class _VersionCache(TypedDict):
+    """Internal cache structure for version checking."""
+
+    data: VersionCheckResponse | None
+    timestamp: float
+    ttl: int
+
+
 router = APIRouter()
 
 # In-memory cache for version check results
-_version_cache: dict[str, Any] = {
+_version_cache: _VersionCache = {
     "data": None,
     "timestamp": 0,
-    "ttl": 3600,  # 1 hour cache TTL
+    "ttl": 3600,
 }
 
 # GitHub repository information
@@ -74,13 +92,8 @@ def compare_versions(current: str, latest: str) -> bool:
     return latest_tuple > current_tuple
 
 
-def fetch_latest_release() -> dict[str, Any] | None:
-    """
-    Fetch latest release information from GitHub API.
-
-    Returns:
-        Release data dict with 'tag_name', 'html_url', 'published_at' or None on error
-    """
+def fetch_latest_release() -> GitHubRelease | None:
+    """Fetch latest release information from GitHub API."""
     try:
         # Create request with User-Agent header (required by GitHub API)
         req = urllib.request.Request(

AutoGLM_GUI/api/workflows.py

@@ -17,7 +17,8 @@ def list_workflows() -> WorkflowListResponse:
     """获取所有 workflows."""
     from AutoGLM_GUI.workflow_manager import workflow_manager
 
-    workflows = workflow_manager.list_workflows()
+    workflow_dicts = workflow_manager.list_workflows()
+    workflows = [WorkflowResponse(**wf) for wf in workflow_dicts]
     return WorkflowListResponse(workflows=workflows)