merge: resolve upstream master conflicts

Author: zouyonghe

astrbot/core/astr_main_agent.py

@@ -229,7 +229,7 @@ async def _apply_kb(
     config: MainAgentBuildConfig,
 ) -> None:
     if not config.kb_agentic_mode:
-        if req.prompt is None:
+        if req.prompt is None or not req.prompt.strip():
             return
         try:
             kb_result = await retrieve_knowledge_base(

astrbot/core/computer/booters/cua.py

@@ -232,6 +232,43 @@ def _has_component_method(root: Any, component_name: str, method_name: str) -> b
     return getattr(component, method_name, None) is not None
 
 
+def _resolve_files_components(sandbox: Any) -> tuple[Any, ...]:
+    components: list[Any] = []
+    seen_ids: set[int] = set()
+    for name in ("files", "filesystem"):
+        component = getattr(sandbox, name, None)
+        if component is None:
+            continue
+        component_id = id(component)
+        if component_id in seen_ids:
+            continue
+        seen_ids.add(component_id)
+        components.append(component)
+    return tuple(components)
+
+
+def _resolve_files_method(
+    components: tuple[Any, ...],
+    method_names: str | tuple[str, ...],
+) -> Any | None:
+    for component in components:
+        method = _resolve_component_method(component, method_names)
+        if method is not None:
+            return method
+    return None
+
+
+def _normalize_native_upload_result(raw: Any, file_name: str) -> dict[str, Any]:
+    payload = _maybe_model_dump(raw)
+    if not payload:
+        return {"success": True, "file_path": file_name}
+    if "file_path" not in payload and "path" not in payload:
+        payload["file_path"] = file_name
+    if "success" not in payload:
+        payload["success"] = not bool(payload.get("error") or payload.get("stderr"))
+    return payload
+
+
 class CuaShellComponent(ShellComponent):
     def __init__(self, sandbox: Any, os_type: str = "linux") -> None:
         self._sandbox = sandbox
@@ -360,7 +397,7 @@ def __init__(
         self, sandbox: Any, os_type: str = CUA_DEFAULT_CONFIG["os_type"]
     ) -> None:
         self._shell = CuaShellComponent(sandbox, os_type=os_type)
-        self._fs = getattr(sandbox, "filesystem", None)
+        self._fs_components = _resolve_files_components(sandbox)
         self._os_type = os_type.lower()
         self._fallback = _PosixShellFileSystem(self._shell, self._os_type)
 
@@ -382,7 +419,9 @@ async def read_file(
         offset: int | None = None,
         limit: int | None = None,
     ) -> dict[str, Any]:
-        read_file = None if self._fs is None else getattr(self._fs, "read_file", None)
+        read_file = _resolve_files_method(
+            self._fs_components, ("read_file", "read_text")
+        )
         if read_file is None:
             return await self._fallback.read_file(path, encoding, offset, limit)
         else:
@@ -405,19 +444,19 @@ async def write_file(
         encoding: str = "utf-8",
     ) -> dict[str, Any]:
         _ = mode
-        write_file = None if self._fs is None else getattr(self._fs, "write_file", None)
+        write_file = _resolve_files_method(
+            self._fs_components, ("write_file", "write_text")
+        )
         if write_file is None:
             return await self._fallback.write_file(path, content, mode, encoding)
         else:
             await _maybe_await(write_file(path, content))
         return {"success": True, "path": path}
 
     async def delete_file(self, path: str) -> dict[str, Any]:
-        delete = None
-        if self._fs is not None:
-            delete = getattr(self._fs, "delete", None) or getattr(
-                self._fs, "delete_file", None
-            )
+        delete = _resolve_files_method(
+            self._fs_components, ("delete", "delete_file", "remove")
+        )
         if delete is None:
             return await self._fallback.delete_file(path)
         else:
@@ -429,7 +468,7 @@ async def list_dir(
         path: str = ".",
         show_hidden: bool = False,
     ) -> dict[str, Any]:
-        list_dir = None if self._fs is None else getattr(self._fs, "list_dir", None)
+        list_dir = _resolve_files_method(self._fs_components, ("list_dir", "list"))
         if list_dir is not None:
             entries = await _maybe_await(list_dir(path))
             return {"success": True, "path": path, "entries": entries}
@@ -802,6 +841,15 @@ async def upload_file(self, path: str, file_name: str) -> dict:
             return _maybe_model_dump(
                 await sandbox.upload_file(str(local_path), file_name)
             )
+        files_components = () if sandbox is None else _resolve_files_components(sandbox)
+        upload = _resolve_files_method(files_components, "upload")
+        if upload is not None:
+            result = await _maybe_await(upload(str(local_path), file_name))
+            return _normalize_native_upload_result(result, file_name)
+        write_bytes = _resolve_files_method(files_components, "write_bytes")
+        if write_bytes is not None:
+            result = await _maybe_await(write_bytes(file_name, local_path.read_bytes()))
+            return _normalize_native_upload_result(result, file_name)
         if not _is_posix_os_type(self.os_type):
             return _non_posix_filesystem_result(file_name, self.os_type)
         result = await _write_base64_via_shell(

astrbot/core/computer/computer_client.py

@@ -1,7 +1,10 @@
+import asyncio
 import json
 import os
 import shutil
+import time
 import uuid
+from dataclasses import dataclass
 from pathlib import Path
 
 from astrbot.api import logger
@@ -20,6 +23,70 @@
 _MANAGED_SKILLS_FILE = ".astrbot_managed_skills.json"
 
 
+@dataclass(slots=True)
+class _CUAIdleState:
+    expires_at: float
+    task: asyncio.Task
+
+
+cua_idle_state: dict[str, _CUAIdleState] = {}
+
+
+def _get_cua_idle_timeout(config: dict) -> float:
+    sandbox_cfg = config.get("provider_settings", {}).get("sandbox", {})
+    value = sandbox_cfg.get("cua_idle_timeout", 0)
+    try:
+        timeout = float(value)
+    except (TypeError, ValueError):
+        return 0.0
+    return max(timeout, 0.0)
+
+
+def _clear_cua_idle_state(session_id: str) -> None:
+    state = cua_idle_state.pop(session_id, None)
+    if state is not None and not state.task.done():
+        state.task.cancel()
+
+
+def _schedule_cua_idle_cleanup(session_id: str, timeout: float) -> None:
+    _clear_cua_idle_state(session_id)
+    if timeout <= 0:
+        return
+    expires_at = time.monotonic() + timeout
+
+    async def _expire_when_idle() -> None:
+        try:
+            remaining = expires_at - time.monotonic()
+            if remaining > 0:
+                await asyncio.sleep(remaining)
+
+            state = cua_idle_state.get(session_id)
+            if state is None or state.expires_at != expires_at:
+                return
+
+            booter = session_booter.get(session_id)
+            if booter is not None:
+                try:
+                    await booter.shutdown()
+                except Exception as shutdown_err:
+                    logger.warning(
+                        "[Computer] Failed to shutdown idle CUA sandbox for session %s: %s",
+                        session_id,
+                        shutdown_err,
+                    )
+                finally:
+                    session_booter.pop(session_id, None)
+        except asyncio.CancelledError:
+            raise
+        finally:
+            state = cua_idle_state.get(session_id)
+            if state is not None and state.expires_at == expires_at:
+                cua_idle_state.pop(session_id, None)
+
+    task = asyncio.create_task(_expire_when_idle())
+    cua_idle_state[session_id] = _CUAIdleState(expires_at=expires_at, task=task)
+
+
 def _list_local_skill_dirs(skills_root: Path) -> list[Path]:
     skills: list[Path] = []
     for entry in sorted(skills_root.iterdir()):
@@ -486,6 +553,7 @@ async def get_booter(
 
     sandbox_cfg = config.get("provider_settings", {}).get("sandbox", {})
     booter_type = sandbox_cfg.get("booter", "shipyard_neo")
+    cua_idle_timeout = _get_cua_idle_timeout(config) if booter_type == "cua" else 0.0
 
     if session_id in session_booter:
         booter = session_booter[session_id]
@@ -506,6 +574,7 @@ async def get_booter(
                     session_id,
                     shutdown_err,
                 )
+            _clear_cua_idle_state(session_id)
             session_booter.pop(session_id, None)
     if session_id not in session_booter:
         uuid_str = uuid.uuid5(uuid.NAMESPACE_DNS, session_id).hex
@@ -579,9 +648,12 @@ async def get_booter(
                     session_id,
                     shutdown_error,
                 )
+            _clear_cua_idle_state(session_id)
             raise e
 
         session_booter[session_id] = client
+    if booter_type == "cua":
+        _schedule_cua_idle_cleanup(session_id, cua_idle_timeout)
     return session_booter[session_id]
 
 

astrbot/core/pipeline/result_decorate/stage.py

@@ -289,7 +289,9 @@ async def process(
                         ),
                     )
                 else:
-                    result.chain.insert(0, Plain(f"🤔 思考: {reasoning_content}\n"))
+                    result.chain.insert(
+                        0, Plain(f"🤔 思考: {reasoning_content}\n\n────\n")
+                    )
 
             if should_tts and tts_provider:
                 new_chain = []

tests/unit/test_astr_main_agent.py

@@ -342,6 +342,23 @@ async def test_apply_kb_no_prompt(self, mock_event, mock_context):
 
         assert req.system_prompt == "System"
 
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize("prompt", ["", "   \n\t"])
+    async def test_apply_kb_blank_prompt(self, prompt, mock_event, mock_context):
+        """Test applying knowledge base when prompt is blank."""
+        module = ama
+        req = ProviderRequest(prompt=prompt, system_prompt="System")
+        config = module.MainAgentBuildConfig(
+            tool_call_timeout=60, kb_agentic_mode=False
+        )
+        retrieve = AsyncMock(return_value="KB result")
+
+        with patch("astrbot.core.astr_main_agent.retrieve_knowledge_base", retrieve):
+            await module._apply_kb(mock_event, req, mock_context, config)
+
+        retrieve.assert_not_awaited()
+        assert req.system_prompt == "System"
+
     @pytest.mark.asyncio
     async def test_apply_kb_no_result(self, mock_event, mock_context):
         """Test applying knowledge base when no result is returned."""