From fcf1b08455b6f904bb40205ea62042ab39350df1 Mon Sep 17 00:00:00 2001 From: Soulter <905617992@qq.com> Date: Tue, 7 Apr 2026 01:20:26 +0800 Subject: [PATCH 01/20] feat: filesystem grep, read, edit file --- astrbot/core/astr_agent_tool_exec.py | 9 + astrbot/core/astr_main_agent.py | 9 + astrbot/core/astr_main_agent_resources.py | 6 + astrbot/core/computer/booters/boxlite.py | 12 +- astrbot/core/computer/booters/local.py | 105 +++- astrbot/core/computer/booters/shipyard.py | 81 ++- astrbot/core/computer/booters/shipyard_neo.py | 93 +++- .../booters/shipyard_search_file_util.py | 119 ++++ astrbot/core/computer/olayer/filesystem.py | 30 +- astrbot/core/computer/tools/__init__.py | 5 +- astrbot/core/computer/tools/fs.py | 512 +++++++++++++++--- astrbot/core/utils/astrbot_path.py | 6 + pyproject.toml | 1 + requirements.txt | 3 +- 14 files changed, 883 insertions(+), 108 deletions(-) create mode 100644 astrbot/core/computer/booters/shipyard_search_file_util.py diff --git a/astrbot/core/astr_agent_tool_exec.py b/astrbot/core/astr_agent_tool_exec.py index 1fb4b03368..9d8977410e 100644 --- a/astrbot/core/astr_agent_tool_exec.py +++ b/astrbot/core/astr_agent_tool_exec.py @@ -21,10 +21,13 @@ BACKGROUND_TASK_RESULT_WOKE_SYSTEM_PROMPT, EXECUTE_SHELL_TOOL, FILE_DOWNLOAD_TOOL, + FILE_EDIT_TOOL, FILE_UPLOAD_TOOL, + GREP_TOOL, LOCAL_EXECUTE_SHELL_TOOL, LOCAL_PYTHON_TOOL, PYTHON_TOOL, + READ_FILE_TOOL, SEND_MESSAGE_TO_USER_TOOL, ) from astrbot.core.cron.events import CronMessageEvent @@ -184,11 +187,17 @@ def _get_runtime_computer_tools(cls, runtime: str) -> dict[str, FunctionTool]: PYTHON_TOOL.name: PYTHON_TOOL, FILE_UPLOAD_TOOL.name: FILE_UPLOAD_TOOL, FILE_DOWNLOAD_TOOL.name: FILE_DOWNLOAD_TOOL, + READ_FILE_TOOL.name: READ_FILE_TOOL, + FILE_EDIT_TOOL.name: FILE_EDIT_TOOL, + GREP_TOOL.name: GREP_TOOL, } if runtime == "local": return { LOCAL_EXECUTE_SHELL_TOOL.name: LOCAL_EXECUTE_SHELL_TOOL, LOCAL_PYTHON_TOOL.name: LOCAL_PYTHON_TOOL, + READ_FILE_TOOL.name: READ_FILE_TOOL, + FILE_EDIT_TOOL.name: FILE_EDIT_TOOL, + GREP_TOOL.name: GREP_TOOL, } return {} diff --git a/astrbot/core/astr_main_agent.py b/astrbot/core/astr_main_agent.py index 9861e669c4..507cbff8e5 100644 --- a/astrbot/core/astr_main_agent.py +++ b/astrbot/core/astr_main_agent.py @@ -29,9 +29,11 @@ EVALUATE_SKILL_CANDIDATE_TOOL, EXECUTE_SHELL_TOOL, FILE_DOWNLOAD_TOOL, + FILE_EDIT_TOOL, FILE_UPLOAD_TOOL, GET_EXECUTION_HISTORY_TOOL, GET_SKILL_PAYLOAD_TOOL, + GREP_TOOL, KNOWLEDGE_BASE_QUERY_TOOL, LIST_SKILL_CANDIDATES_TOOL, LIST_SKILL_RELEASES_TOOL, @@ -41,6 +43,7 @@ LOCAL_PYTHON_TOOL, PROMOTE_SKILL_CANDIDATE_TOOL, PYTHON_TOOL, + READ_FILE_TOOL, ROLLBACK_SKILL_RELEASE_TOOL, RUN_BROWSER_SKILL_TOOL, SANDBOX_MODE_PROMPT, @@ -285,6 +288,9 @@ def _apply_local_env_tools(req: ProviderRequest) -> None: req.func_tool = ToolSet() req.func_tool.add_tool(LOCAL_EXECUTE_SHELL_TOOL) req.func_tool.add_tool(LOCAL_PYTHON_TOOL) + req.func_tool.add_tool(READ_FILE_TOOL) + req.func_tool.add_tool(FILE_EDIT_TOOL) + req.func_tool.add_tool(GREP_TOOL) req.system_prompt = f"{req.system_prompt or ''}\n{_build_local_mode_prompt()}\n" @@ -991,6 +997,9 @@ def _apply_sandbox_tools( req.func_tool.add_tool(PYTHON_TOOL) req.func_tool.add_tool(FILE_UPLOAD_TOOL) req.func_tool.add_tool(FILE_DOWNLOAD_TOOL) + req.func_tool.add_tool(READ_FILE_TOOL) + req.func_tool.add_tool(FILE_EDIT_TOOL) + req.func_tool.add_tool(GREP_TOOL) if booter == "shipyard_neo": # Neo-specific path rule: filesystem tools operate relative to sandbox # workspace root. Do not prepend "/workspace". diff --git a/astrbot/core/astr_main_agent_resources.py b/astrbot/core/astr_main_agent_resources.py index 09e77b4cbe..8e74535fdd 100644 --- a/astrbot/core/astr_main_agent_resources.py +++ b/astrbot/core/astr_main_agent_resources.py @@ -21,14 +21,17 @@ EvaluateSkillCandidateTool, ExecuteShellTool, FileDownloadTool, + FileEditTool, FileUploadTool, GetExecutionHistoryTool, GetSkillPayloadTool, + GrepTool, ListSkillCandidatesTool, ListSkillReleasesTool, LocalPythonTool, PromoteSkillCandidateTool, PythonTool, + ReadFileTool, RollbackSkillReleaseTool, RunBrowserSkillTool, SyncSkillReleaseTool, @@ -500,6 +503,9 @@ async def retrieve_knowledge_base( LOCAL_PYTHON_TOOL = LocalPythonTool() FILE_UPLOAD_TOOL = FileUploadTool() FILE_DOWNLOAD_TOOL = FileDownloadTool() +READ_FILE_TOOL = ReadFileTool() +FILE_EDIT_TOOL = FileEditTool() +GREP_TOOL = GrepTool() BROWSER_EXEC_TOOL = BrowserExecTool() BROWSER_BATCH_EXEC_TOOL = BrowserBatchExecTool() RUN_BROWSER_SKILL_TOOL = RunBrowserSkillTool() diff --git a/astrbot/core/computer/booters/boxlite.py b/astrbot/core/computer/booters/boxlite.py index 70064fdd48..aa3ca59761 100644 --- a/astrbot/core/computer/booters/boxlite.py +++ b/astrbot/core/computer/booters/boxlite.py @@ -4,7 +4,7 @@ import aiohttp import boxlite -from shipyard.filesystem import FileSystemComponent as ShipyardFileSystemComponent +from shipyard import FileSystemComponent as ShipyardFileSystemComponent from shipyard.python import PythonComponent as ShipyardPythonComponent from shipyard.shell import ShellComponent as ShipyardShellComponent @@ -12,6 +12,7 @@ from ..olayer import FileSystemComponent, PythonComponent, ShellComponent from .base import ComputerBooter +from .shipyard import ShipyardFileSystemWrapper class MockShipyardSandboxClient: @@ -150,21 +151,24 @@ async def boot(self, session_id: str) -> None: self.mocked = MockShipyardSandboxClient( sb_url=f"http://127.0.0.1:{random_port}" ) - self._fs = ShipyardFileSystemComponent( + self._python = ShipyardPythonComponent( client=self.mocked, # type: ignore ship_id=self.box.id, session_id=session_id, ) - self._python = ShipyardPythonComponent( + self._shell = ShipyardShellComponent( client=self.mocked, # type: ignore ship_id=self.box.id, session_id=session_id, ) - self._shell = ShipyardShellComponent( + self._ship_fs = ShipyardFileSystemComponent( client=self.mocked, # type: ignore ship_id=self.box.id, session_id=session_id, ) + self._fs = ShipyardFileSystemWrapper( + _shipyard_fs=self._ship_fs, _shipyard_shell=self._shell + ) await self.mocked.wait_healthy(self.box.id, session_id) diff --git a/astrbot/core/computer/booters/local.py b/astrbot/core/computer/booters/local.py index f11bc329fa..e8b6f6db32 100644 --- a/astrbot/core/computer/booters/local.py +++ b/astrbot/core/computer/booters/local.py @@ -9,12 +9,10 @@ from dataclasses import dataclass from typing import Any +from python_ripgrep import search + from astrbot.api import logger -from astrbot.core.utils.astrbot_path import ( - get_astrbot_data_path, - get_astrbot_root, - get_astrbot_temp_path, -) +from astrbot.core.utils.astrbot_path import get_astrbot_root from ..olayer import FileSystemComponent, PythonComponent, ShellComponent from .base import ComputerBooter @@ -41,18 +39,6 @@ def _is_safe_command(command: str) -> bool: return not any(pat in cmd for pat in _BLOCKED_COMMAND_PATTERNS) -def _ensure_safe_path(path: str) -> str: - abs_path = os.path.abspath(path) - allowed_roots = [ - os.path.abspath(get_astrbot_root()), - os.path.abspath(get_astrbot_data_path()), - os.path.abspath(get_astrbot_temp_path()), - ] - if not any(abs_path.startswith(root) for root in allowed_roots): - raise PermissionError("Path is outside the allowed computer roots.") - return abs_path - - def _decode_bytes_with_fallback( output: bytes | None, *, @@ -110,7 +96,7 @@ def _run() -> dict[str, Any]: run_env = os.environ.copy() if env: run_env.update({str(k): str(v) for k, v in env.items()}) - working_dir = _ensure_safe_path(cwd) if cwd else get_astrbot_root() + working_dir = os.path.abspath(cwd) if cwd else get_astrbot_root() if background: # `command` is intentionally executed through the current shell so # local computer-use behavior matches existing tool semantics. @@ -186,7 +172,7 @@ async def create_file( self, path: str, content: str = "", mode: int = 0o644 ) -> dict[str, Any]: def _run() -> dict[str, Any]: - abs_path = _ensure_safe_path(path) + abs_path = os.path.abspath(path) os.makedirs(os.path.dirname(abs_path), exist_ok=True) with open(abs_path, "w", encoding="utf-8") as f: f.write(content) @@ -195,16 +181,85 @@ def _run() -> dict[str, Any]: return await asyncio.to_thread(_run) - async def read_file(self, path: str, encoding: str = "utf-8") -> dict[str, Any]: + async def read_file( + self, + path: str, + encoding: str = "utf-8", + offset: int | None = None, + limit: int | None = None, + ) -> dict[str, Any]: def _run() -> dict[str, Any]: - abs_path = _ensure_safe_path(path) + abs_path = os.path.abspath(path) with open(abs_path, "rb") as f: raw_content = f.read() content = _decode_bytes_with_fallback( raw_content, preferred_encoding=encoding, ) - return {"success": True, "content": content} + start = 0 if offset is None else offset + content_slice = ( + content[start:] if limit is None else content[start : start + limit] + ) + return { + "success": True, + "content": content_slice, + } + + return await asyncio.to_thread(_run) + + async def search_files( + self, + pattern: str, + path: str | None = None, + glob: str | None = None, + after_context: int | None = None, + before_context: int | None = None, + ) -> dict[str, Any]: + def _run() -> dict[str, Any]: + results = search( + patterns=[pattern], + paths=[path] if path else None, + globs=[glob] if glob else None, + after_context=after_context, + before_context=before_context, + line_number=True, + ) + return {"success": True, "content": "".join(results)} + + return await asyncio.to_thread(_run) + + async def edit_file( + self, + path: str, + old_string: str, + new_string: str, + replace_all: bool = False, + encoding: str = "utf-8", + ) -> dict[str, Any]: + def _run() -> dict[str, Any]: + abs_path = os.path.abspath(path) + with open(abs_path, encoding=encoding) as f: + content = f.read() + occurrences = content.count(old_string) + if occurrences == 0: + return { + "success": False, + "error": "old string not found in file", + "replacements": 0, + } + if replace_all: + updated = content.replace(old_string, new_string) + replacements = occurrences + else: + updated = content.replace(old_string, new_string, 1) + replacements = 1 + with open(abs_path, "w", encoding=encoding) as f: + f.write(updated) + return { + "success": True, + "path": abs_path, + "replacements": replacements, + } return await asyncio.to_thread(_run) @@ -212,7 +267,7 @@ async def write_file( self, path: str, content: str, mode: str = "w", encoding: str = "utf-8" ) -> dict[str, Any]: def _run() -> dict[str, Any]: - abs_path = _ensure_safe_path(path) + abs_path = os.path.abspath(path) os.makedirs(os.path.dirname(abs_path), exist_ok=True) with open(abs_path, mode, encoding=encoding) as f: f.write(content) @@ -222,7 +277,7 @@ def _run() -> dict[str, Any]: async def delete_file(self, path: str) -> dict[str, Any]: def _run() -> dict[str, Any]: - abs_path = _ensure_safe_path(path) + abs_path = os.path.abspath(path) if os.path.isdir(abs_path): shutil.rmtree(abs_path) else: @@ -235,7 +290,7 @@ async def list_dir( self, path: str = ".", show_hidden: bool = False ) -> dict[str, Any]: def _run() -> dict[str, Any]: - abs_path = _ensure_safe_path(path) + abs_path = os.path.abspath(path) entries = os.listdir(abs_path) if not show_hidden: entries = [e for e in entries if not e.startswith(".")] diff --git a/astrbot/core/computer/booters/shipyard.py b/astrbot/core/computer/booters/shipyard.py index 6379d1e48b..bed1b06531 100644 --- a/astrbot/core/computer/booters/shipyard.py +++ b/astrbot/core/computer/booters/shipyard.py @@ -1,9 +1,87 @@ +from __future__ import annotations + +from typing import Any + +from shipyard import FileSystemComponent as ShipyardFileSystemComponent from shipyard import ShipyardClient, Spec from astrbot.api import logger from ..olayer import FileSystemComponent, PythonComponent, ShellComponent from .base import ComputerBooter +from .shipyard_search_file_util import search_files_via_shell + + +class ShipyardFileSystemWrapper: + def __init__( + self, _shipyard_fs: ShipyardFileSystemComponent, _shipyard_shell: ShellComponent + ): + self._fs = _shipyard_fs + self._shell = _shipyard_shell + + async def create_file( + self, path: str, content: str = "", mode: int = 420 + ) -> dict[str, Any]: + return await self._fs.create_file(path=path, content=content, mode=mode) + + async def read_file( + self, + path: str, + encoding: str = "utf-8", + offset: int | None = None, + limit: int | None = None, + ) -> dict[str, Any]: + return await self._fs.read_file( + path=path, encoding=encoding, offset=offset, limit=limit + ) + + async def write_file( + self, path: str, content: str, mode: str = "w", encoding: str = "utf-8" + ) -> dict[str, Any]: + return await self._fs.write_file( + path=path, content=content, mode=mode, encoding=encoding + ) + + async def list_dir( + self, path: str = ".", show_hidden: bool = False + ) -> dict[str, Any]: + return await self._fs.list_dir(path=path, show_hidden=show_hidden) + + async def delete_file(self, path: str) -> dict[str, Any]: + return await self._fs.delete_file(path=path) + + async def search_files( + self, + pattern: str, + path: str | None = None, + glob: str | None = None, + after_context: int | None = None, + before_context: int | None = None, + ) -> dict[str, Any]: + return await search_files_via_shell( + self._shell, + pattern=pattern, + path=path, + glob=glob, + after_context=after_context, + before_context=before_context, + ) + + async def edit_file( + self, + path: str, + old_string: str, + new_string: str, + replace_all: bool = False, + encoding: str = "utf-8", + ) -> dict[str, Any]: + return await self._fs.edit_file( + path=path, + old_string=old_string, + new_string=new_string, + replace_all=replace_all, + encoding=encoding, + ) class ShipyardBooter(ComputerBooter): @@ -29,13 +107,14 @@ async def boot(self, session_id: str) -> None: ) logger.info(f"Got sandbox ship: {ship.id} for session: {session_id}") self._ship = ship + self._fs = ShipyardFileSystemWrapper(self._ship.fs, self._ship.shell) async def shutdown(self) -> None: logger.info("[Computer] Shipyard booter shutdown.") @property def fs(self) -> FileSystemComponent: - return self._ship.fs + return self._fs @property def python(self) -> PythonComponent: diff --git a/astrbot/core/computer/booters/shipyard_neo.py b/astrbot/core/computer/booters/shipyard_neo.py index 6304696ad2..1ac71c78e5 100644 --- a/astrbot/core/computer/booters/shipyard_neo.py +++ b/astrbot/core/computer/booters/shipyard_neo.py @@ -13,6 +13,15 @@ ShellComponent, ) from .base import ComputerBooter +from .shipyard_search_file_util import search_files_via_shell + +try: + from shipyard_neo import BayClient + from shipyard_neo.sandbox import Sandbox +except ImportError: + logger.warning( + "shipyard_neo_sdk is not installed. ShipyardNeoBooter will not work without it." + ) def _maybe_model_dump(value: Any) -> dict[str, Any]: @@ -26,7 +35,7 @@ def _maybe_model_dump(value: Any) -> dict[str, Any]: class NeoPythonComponent(PythonComponent): - def __init__(self, sandbox: Any) -> None: + def __init__(self, sandbox: Sandbox) -> None: self._sandbox = sandbox async def exec( @@ -67,7 +76,7 @@ async def exec( class NeoShellComponent(ShellComponent): - def __init__(self, sandbox: Any) -> None: + def __init__(self, sandbox: Sandbox) -> None: self._sandbox = sandbox async def exec( @@ -136,8 +145,9 @@ async def exec( class NeoFileSystemComponent(FileSystemComponent): - def __init__(self, sandbox: Any) -> None: + def __init__(self, sandbox: Sandbox, shell: ShellComponent) -> None: self._sandbox = sandbox + self._shell = shell async def create_file( self, @@ -149,10 +159,71 @@ async def create_file( await self._sandbox.filesystem.write_file(path, content) return {"success": True, "path": path} - async def read_file(self, path: str, encoding: str = "utf-8") -> dict[str, Any]: + async def read_file( + self, + path: str, + encoding: str = "utf-8", + offset: int | None = None, + limit: int | None = None, + ) -> dict[str, Any]: _ = encoding content = await self._sandbox.filesystem.read_file(path) - return {"success": True, "path": path, "content": content} + start = 0 if offset is None else offset + content_slice = ( + content[start:] if limit is None else content[start : start + limit] + ) + return { + "success": True, + "path": path, + "content": content_slice, + } + + async def search_files( + self, + pattern: str, + path: str | None = None, + glob: str | None = None, + after_context: int | None = None, + before_context: int | None = None, + ) -> dict[str, Any]: + return await search_files_via_shell( + self._shell, + pattern=pattern, + path=path, + glob=glob, + after_context=after_context, + before_context=before_context, + ) + + async def edit_file( + self, + path: str, + old_string: str, + new_string: str, + replace_all: bool = False, + encoding: str = "utf-8", + ) -> dict[str, Any]: + _ = encoding + content = await self._sandbox.filesystem.read_file(path) + occurrences = content.count(old_string) + if occurrences == 0: + return { + "success": False, + "error": "old string not found in file", + "replacements": 0, + } + if replace_all: + updated = content.replace(old_string, new_string) + replacements = occurrences + else: + updated = content.replace(old_string, new_string, 1) + replacements = 1 + await self._sandbox.filesystem.write_file(path, updated) + return { + "success": True, + "path": path, + "replacements": replacements, + } async def write_file( self, @@ -186,7 +257,7 @@ async def list_dir( class NeoBrowserComponent(BrowserComponent): - def __init__(self, sandbox: Any) -> None: + def __init__(self, sandbox: Sandbox) -> None: self._sandbox = sandbox async def exec( @@ -271,8 +342,8 @@ def __init__( self._access_token = access_token self._profile = profile self._ttl = ttl - self._client: Any = None - self._sandbox: Any = None + self._client: BayClient | None = None + self._sandbox: Sandbox | None = None self._bay_manager: Any = None # BayContainerManager when auto-started self._fs: FileSystemComponent | None = None self._python: PythonComponent | None = None @@ -336,8 +407,6 @@ async def boot(self, session_id: str) -> None: "or ensure Bay's credentials.json is accessible for auto-discovery." ) - from shipyard_neo import BayClient - self._client = BayClient( endpoint_url=self._endpoint_url, access_token=self._access_token, @@ -352,9 +421,9 @@ async def boot(self, session_id: str) -> None: ttl=self._ttl, ) - self._fs = NeoFileSystemComponent(self._sandbox) - self._python = NeoPythonComponent(self._sandbox) self._shell = NeoShellComponent(self._sandbox) + self._fs = NeoFileSystemComponent(self._sandbox, self._shell) + self._python = NeoPythonComponent(self._sandbox) caps = self.capabilities or () self._browser = ( diff --git a/astrbot/core/computer/booters/shipyard_search_file_util.py b/astrbot/core/computer/booters/shipyard_search_file_util.py new file mode 100644 index 0000000000..a85998f985 --- /dev/null +++ b/astrbot/core/computer/booters/shipyard_search_file_util.py @@ -0,0 +1,119 @@ +from __future__ import annotations + +import shlex +from typing import Any + +from ..olayer import ShellComponent + + +def _build_rg_command( + *, + pattern: str, + path: str, + glob: str | None, + after_context: int | None, + before_context: int | None, +) -> list[str]: + command = ["rg", "--color=never", "-n", "-e", pattern] + if glob: + command.extend(["-g", glob]) + if after_context is not None: + command.extend(["-A", str(after_context)]) + if before_context is not None: + command.extend(["-B", str(before_context)]) + command.extend(["--", path]) + return command + + +def _build_grep_command( + *, + pattern: str, + path: str, + glob: str | None, + after_context: int | None, + before_context: int | None, +) -> list[str]: + command = ["grep", "-R", "-H", "-n", "-e", pattern] + if glob: + command.append(f"--include={glob}") + if after_context is not None: + command.extend(["-A", str(after_context)]) + if before_context is not None: + command.extend(["-B", str(before_context)]) + command.extend(["--", path]) + return command + + +def _quote_command(command: list[str]) -> str: + return " ".join(shlex.quote(part) for part in command) + + +def build_search_command( + *, + pattern: str, + path: str, + glob: str | None, + after_context: int | None, + before_context: int | None, +) -> str: + rg_command = _quote_command( + _build_rg_command( + pattern=pattern, + path=path, + glob=glob, + after_context=after_context, + before_context=before_context, + ) + ) + grep_command = _quote_command( + _build_grep_command( + pattern=pattern, + path=path, + glob=glob, + after_context=after_context, + before_context=before_context, + ) + ) + return ( + "if command -v rg >/dev/null 2>&1; then " + f"{rg_command}; " + "elif command -v grep >/dev/null 2>&1; then " + f"{grep_command}; " + "else " + "echo 'Neither rg nor grep is available in the sandbox.' >&2; " + "exit 127; " + "fi" + ) + + +async def search_files_via_shell( + shell: ShellComponent, + *, + pattern: str, + path: str | None = None, + glob: str | None = None, + after_context: int | None = None, + before_context: int | None = None, + timeout: int = 30, +) -> dict[str, Any]: + command = build_search_command( + pattern=pattern, + path=path or ".", + glob=glob, + after_context=after_context, + before_context=before_context, + ) + result = await shell.exec(command, timeout=timeout) + stdout = str(result.get("stdout", "") or "") + stderr = str(result.get("stderr", "") or "") + exit_code = result.get("exit_code") + if exit_code in (0, None): + return {"success": True, "content": stdout} + if exit_code == 1: + return {"success": True, "content": ""} + return { + "success": False, + "content": "", + "error": stderr or f"command exited with code {exit_code}", + "exit_code": exit_code, + } diff --git a/astrbot/core/computer/olayer/filesystem.py b/astrbot/core/computer/olayer/filesystem.py index 21f36d1110..0646cd46d1 100644 --- a/astrbot/core/computer/olayer/filesystem.py +++ b/astrbot/core/computer/olayer/filesystem.py @@ -12,10 +12,38 @@ async def create_file( """Create a file with the specified content""" ... - async def read_file(self, path: str, encoding: str = "utf-8") -> dict[str, Any]: + async def read_file( + self, + path: str, + encoding: str = "utf-8", + offset: int | None = None, + limit: int | None = None, + ) -> dict[str, Any]: """Read file content""" ... + async def search_files( + self, + pattern: str, + path: str | None = None, + glob: str | None = None, + after_context: int | None = None, + before_context: int | None = None, + ) -> dict[str, Any]: + """Search file contents""" + ... + + async def edit_file( + self, + path: str, + old_string: str, + new_string: str, + replace_all: bool = False, + encoding: str = "utf-8", + ) -> dict[str, Any]: + """Edit file content by string replacement""" + ... + async def write_file( self, path: str, content: str, mode: str = "w", encoding: str = "utf-8" ) -> dict[str, Any]: diff --git a/astrbot/core/computer/tools/__init__.py b/astrbot/core/computer/tools/__init__.py index 598abbb6ea..e97a84cce6 100644 --- a/astrbot/core/computer/tools/__init__.py +++ b/astrbot/core/computer/tools/__init__.py @@ -1,5 +1,5 @@ from .browser import BrowserBatchExecTool, BrowserExecTool, RunBrowserSkillTool -from .fs import FileDownloadTool, FileUploadTool +from .fs import FileDownloadTool, FileEditTool, FileUploadTool, GrepTool, ReadFileTool from .neo_skills import ( AnnotateExecutionTool, CreateSkillCandidateTool, @@ -32,6 +32,9 @@ "RollbackSkillReleaseTool", "SyncSkillReleaseTool", "FileUploadTool", + "FileEditTool", + "GrepTool", + "ReadFileTool", "PythonTool", "LocalPythonTool", "ExecuteShellTool", diff --git a/astrbot/core/computer/tools/fs.py b/astrbot/core/computer/tools/fs.py index f2a698f763..cdd36c813a 100644 --- a/astrbot/core/computer/tools/fs.py +++ b/astrbot/core/computer/tools/fs.py @@ -1,6 +1,34 @@ +"""Filesystem tool audit. + +Tool exposure from the main agent: +- Local runtime exposes `astrbot_read_file_tool`, `astrbot_file_edit_tool`, + and `astrbot_grep_tool`. +- Sandbox runtime exposes `astrbot_upload_file`, `astrbot_download_file`, + `astrbot_read_file_tool`, `astrbot_file_edit_tool`, and `astrbot_grep_tool`. + +Behavior when `provider_settings.computer_use_require_admin=True`: +- Admin + local: read/edit/grep are not path-restricted by this module; access + depends on the local runtime implementation and host OS permissions. Upload + and download tools are defined here, but `LocalBooter` does not implement + them and the main agent does not expose them in local mode. +- Member + local: read/edit/grep are restricted to `data/skills`, + `data/workspaces/{normalized_umo}`, and `/tmp/.astrbot`. Upload/download are + denied by `check_admin_permission` if invoked. +- Admin + sandbox: read/edit/grep are not path-restricted by this module; + sandbox filesystem boundaries are enforced by the sandbox runtime. Upload and + download are allowed. +- Member + sandbox: read/edit/grep are also not path-restricted by this module. + Upload/download are denied by `check_admin_permission` if invoked. + +When `computer_use_require_admin=False`, member behavior in this module matches +admin behavior. +""" + import os +import re import uuid from dataclasses import dataclass, field +from pathlib import Path from astrbot.api import FunctionTool, logger from astrbot.api.event import MessageChain @@ -8,73 +36,431 @@ from astrbot.core.agent.tool import ToolExecResult from astrbot.core.astr_agent_context import AstrAgentContext from astrbot.core.message.components import File -from astrbot.core.utils.astrbot_path import get_astrbot_temp_path +from astrbot.core.utils.astrbot_path import ( + get_astrbot_skills_path, + get_astrbot_temp_path, + get_astrbot_workspaces_path, +) from ..computer_client import get_booter from .permissions import check_admin_permission -# @dataclass -# class CreateFileTool(FunctionTool): -# name: str = "astrbot_create_file" -# description: str = "Create a new file in the sandbox." -# parameters: dict = field( -# default_factory=lambda: { -# "type": "object", -# "properties": { -# "path": { -# "path": "string", -# "description": "The path where the file should be created, relative to the sandbox root. Must not use absolute paths or traverse outside the sandbox.", -# }, -# "content": { -# "type": "string", -# "description": "The content to write into the file.", -# }, -# }, -# "required": ["path", "content"], -# } -# ) - -# async def call( -# self, context: ContextWrapper[AstrAgentContext], path: str, content: str -# ) -> ToolExecResult: -# sb = await get_booter( -# context.context.context, -# context.context.event.unified_msg_origin, -# ) -# try: -# result = await sb.fs.create_file(path, content) -# return json.dumps(result) -# except Exception as e: -# return f"Error creating file: {str(e)}" - - -# @dataclass -# class ReadFileTool(FunctionTool): -# name: str = "astrbot_read_file" -# description: str = "Read the content of a file in the sandbox." -# parameters: dict = field( -# default_factory=lambda: { -# "type": "object", -# "properties": { -# "path": { -# "type": "string", -# "description": "The path of the file to read, relative to the sandbox root. Must not use absolute paths or traverse outside the sandbox.", -# }, -# }, -# "required": ["path"], -# } -# ) - -# async def call(self, context: ContextWrapper[AstrAgentContext], path: str): -# sb = await get_booter( -# context.context.context, -# context.context.event.unified_msg_origin, -# ) -# try: -# result = await sb.fs.read_file(path) -# return result -# except Exception as e: -# return f"Error reading file: {str(e)}" + +def _normalize_umo_for_workspace(umo: str) -> str: + normalized = re.sub(r"[^A-Za-z0-9._-]+", "_", umo.strip()) + return normalized or "unknown" + + +def _restricted_env_path_labels(umo: str) -> list[str]: + """Labels for the allowed directories in a local(not sandbox) and restricted(not admin) environment""" + normalized_umo = _normalize_umo_for_workspace(umo) + return [ + "data/skills", + f"data/workspaces/{normalized_umo}", + "/tmp/.astrbot", + ] + + +def _read_allowed_roots(umo: str) -> tuple[Path, ...]: + """Non-admin users can only read files within these directories (and their subdirectories)""" + normalized_umo = _normalize_umo_for_workspace(umo) + return ( + Path(get_astrbot_skills_path()).resolve(strict=False), + (Path(get_astrbot_workspaces_path()) / normalized_umo).resolve(strict=False), + Path("/tmp/.astrbot").resolve(strict=False), + ) + + +def _is_restricted_env(context: ContextWrapper[AstrAgentContext]) -> bool: + cfg = context.context.context.get_config( + umo=context.context.event.unified_msg_origin + ) + provider_settings = cfg.get("provider_settings", {}) + runtime = str(provider_settings.get("computer_use_runtime", "local")) + if runtime != "local": + return False + require_admin = provider_settings.get("computer_use_require_admin", True) + return require_admin and context.context.event.role != "admin" + + +def _resolve_user_path(path: str) -> Path: + candidate = Path(path).expanduser() + if candidate.is_absolute(): + return candidate.resolve(strict=False) + return (Path.cwd() / candidate).resolve(strict=False) + + +def _is_path_within_allowed_roots(path: str, umo: str) -> bool: + resolved = _resolve_user_path(path) + return any( + resolved == allowed_root or resolved.is_relative_to(allowed_root) + for allowed_root in _read_allowed_roots(umo) + ) + + +def _normalize_search_paths( + path: str | None, + *, + restricted: bool, + umo: str, +) -> list[str]: + normalized = [path] if path else [] + if not normalized: + return _restricted_env_path_labels(umo) if restricted else ["."] + + if restricted: + disallowed = [ + path for path in normalized if not _is_path_within_allowed_roots(path, umo) + ] + if disallowed: + allowed = ", ".join(_restricted_env_path_labels(umo)) + blocked = ", ".join(disallowed) + raise PermissionError( + "Read access is restricted for this user. " + f"Allowed directories: {allowed}. Blocked paths: {blocked}." + ) + + return normalized + + +def _normalize_read_path( + path: str, + *, + restricted: bool, + umo: str, +) -> str: + normalized_path = path.strip() + if not normalized_path: + raise ValueError("`path` must be a non-empty string.") + if restricted and not _is_path_within_allowed_roots(normalized_path, umo): + allowed = ", ".join(_restricted_env_path_labels(umo)) + raise PermissionError( + "Read access is restricted for this user. " + f"Allowed directories: {allowed}. Blocked path: {normalized_path}." + ) + return normalized_path + + +def _resolve_context_options( + after_context: int | None, + before_context: int | None, + context: int | None, +) -> tuple[int | None, int | None]: + if context is not None and context < 0: + raise ValueError("`-C` must be greater than or equal to 0.") + if after_context is not None and after_context < 0: + raise ValueError("`-A` must be greater than or equal to 0.") + if before_context is not None and before_context < 0: + raise ValueError("`-B` must be greater than or equal to 0.") + + resolved_after = context if after_context is None else after_context + resolved_before = context if before_context is None else before_context + return resolved_after, resolved_before + + +def _split_output_groups(output: str, *, has_context: bool) -> list[str]: + if not output.strip(): + return [] + + if not has_context: + return [f"{line}\n" for line in output.splitlines() if line.strip()] + + groups: list[str] = [] + current: list[str] = [] + + for line in output.splitlines(keepends=True): + if line.strip() == "--": + if current: + groups.append("".join(current)) + current = [] + continue + if not line.strip(): + continue + current.append(line) + + if current: + groups.append("".join(current)) + return groups + + +def _apply_result_limit( + output: str, + *, + result_limit: int, + has_context: bool, +) -> str: + if result_limit < 1: + raise ValueError("`result_limit` must be greater than or equal to 1.") + + groups = _split_output_groups(output, has_context=has_context) + if len(groups) <= result_limit: + return output if output.strip() else "No matches found." + + limited_output = "".join(groups[:result_limit]).rstrip() + return f"{limited_output}\n\n[Truncated to first {result_limit} result groups.]" + + +def _validate_read_window( + offset: int | None, + limit: int | None, +) -> tuple[int | None, int | None]: + if offset is not None and offset < 0: + raise ValueError("`offset` must be greater than or equal to 0.") + if limit is not None and limit < 1: + raise ValueError("`limit` must be greater than or equal to 1.") + return offset, limit + + +@dataclass +class ReadFileTool(FunctionTool): + name: str = "astrbot_read_file_tool" + description: str = "read file content." + parameters: dict = field( + default_factory=lambda: { + "type": "object", + "properties": { + "path": { + "type": "string", + "description": "Path of the file to read.", + }, + "offset": { + "type": "integer", + "description": "Character offset to start reading from. Defaults to 0.", + "minimum": 0, + }, + "limit": { + "type": "integer", + "description": "Maximum number of characters to read. Defaults to 4000.", + "minimum": 1, + }, + }, + "required": ["path"], + } + ) + + async def call( + self, + context: ContextWrapper[AstrAgentContext], + path: str, + offset: int | None = None, + limit: int | None = None, + ) -> ToolExecResult: + restricted = _is_restricted_env(context) + try: + normalized_path = _normalize_read_path( + path, + restricted=restricted, + umo=context.context.event.unified_msg_origin, + ) + offset, limit = _validate_read_window(offset, limit) + sb = await get_booter( + context.context.context, + context.context.event.unified_msg_origin, + ) + result = await sb.fs.read_file( + path=normalized_path, + encoding="utf-8", + offset=offset, + limit=limit, + ) + if not result.get("success", False): + error_detail = str(result.get("error", "") or "").strip() + return ( + "Error reading file: " + f"{error_detail or 'unknown filesystem read error'}" + ) + + content = str(result.get("content", "") or "") + if not content: + return "No content found at the requested offset." + return content or "" + except PermissionError as exc: + return f"Error: {exc}" + except Exception as exc: + logger.error(f"Error reading file: {exc}") + return f"Error reading file: {exc}" + + +@dataclass +class FileEditTool(FunctionTool): + name: str = "astrbot_file_edit_tool" + description: str = "Editing files." + parameters: dict = field( + default_factory=lambda: { + "type": "object", + "properties": { + "path": { + "type": "string", + "description": "Path of the file to edit.", + }, + "old": { + "type": "string", + "description": "The exact old text to replace.", + }, + "new": { + "type": "string", + "description": "The replacement text.", + }, + "replace_all": { + "type": "boolean", + "description": "Whether to replace all matches. Defaults to false.", + }, + }, + "required": ["path", "old", "new"], + } + ) + + async def call( + self, + context: ContextWrapper[AstrAgentContext], + path: str, + old: str, + new: str, + replace_all: bool = False, + ) -> ToolExecResult: + umo = str(context.context.event.unified_msg_origin) + restricted = _is_restricted_env(context) + try: + normalized_path = _normalize_read_path( + path, + restricted=restricted, + umo=umo, + ) + sb = await get_booter( + context.context.context, + context.context.event.unified_msg_origin, + ) + result = await sb.fs.edit_file( + path=normalized_path, + old_string=old, + new_string=new, + replace_all=replace_all, + encoding="utf-8", + ) + if not result.get("success", False): + error_detail = str(result.get("error", "") or "").strip() + return ( + "Error editing file: " + f"{error_detail or 'unknown filesystem edit error'}" + ) + replacements = int(result.get("replacements", 0) or 0) + mode_text = "all matches" if replace_all else "first match" + return ( + f"Edited {normalized_path}. " + f"Replaced {replacements} occurrence(s) using {mode_text} mode." + ) + except PermissionError as exc: + return f"Error: {exc}" + except Exception as exc: + logger.error(f"Error editing file: {exc}") + return f"Error editing file: {exc}" + + +@dataclass +class GrepTool(FunctionTool): + name: str = "astrbot_grep_tool" + description: str = "Search and read file contents using ripgrep." + parameters: dict = field( + default_factory=lambda: { + "type": "object", + "properties": { + "pattern": { + "type": "string", + "description": "The expression pattern to search for in file contents.", + }, + "path": { + "type": "string", + "description": "File or directory to search in (rg PATH).", + }, + "glob": { + "type": "string", + "description": "Optional glob filter such as `*.py`, `*.{ts,tsx}`.", + }, + "-A": { + "type": "integer", + "description": "Number of trailing context lines to include after each match.", + "minimum": 0, + }, + "-B": { + "type": "integer", + "description": "Number of leading context lines to include before each match.", + "minimum": 0, + }, + "-C": { + "type": "integer", + "description": "Number of leading and trailing context lines to include around each match.", + "minimum": 0, + }, + "result_limit": { + "type": "integer", + "description": "Maximum number of result groups returned by the tool. Defaults to 50.", + "minimum": 1, + }, + }, + "required": ["pattern"], + } + ) + + async def call( + self, + context: ContextWrapper[AstrAgentContext], + pattern: str, + path: str | None = None, + glob: str | None = None, + result_limit: int = 50, + **kwargs, + ) -> ToolExecResult: + normalized_pattern = pattern.strip() + if not normalized_pattern: + return "Error: `pattern` must be a non-empty string." + + restricted = _is_restricted_env(context) + try: + search_paths = _normalize_search_paths( + path, + restricted=restricted, + umo=context.context.event.unified_msg_origin, + ) + after_context, before_context = _resolve_context_options( + kwargs.get("-A"), + kwargs.get("-B"), + kwargs.get("-C"), + ) + has_context = (after_context or 0) > 0 or (before_context or 0) > 0 + sb = await get_booter( + context.context.context, + context.context.event.unified_msg_origin, + ) + contents: list[str] = [] + for search_path in search_paths: + result = await sb.fs.search_files( + pattern=normalized_pattern, + path=search_path, + glob=glob, + after_context=after_context, + before_context=before_context, + ) + if not result.get("success", False): + error_detail = str(result.get("error", "") or "").strip() + logger.error("GrepTool search failed: %s", error_detail) + return ( + "Error searching files: " + f"{error_detail or 'unknown filesystem search error'}" + ) + content = str(result.get("content", "") or "") + if content: + contents.append(content) + + return _apply_result_limit( + "".join(contents), + result_limit=result_limit, + has_context=has_context, + ) + except PermissionError as exc: + return f"Error: {exc}" + except Exception as exc: + logger.error(f"Error searching files: {exc}") + return f"Error searching files: {exc}" @dataclass diff --git a/astrbot/core/utils/astrbot_path.py b/astrbot/core/utils/astrbot_path.py index 987ce110a5..f7aea403f3 100644 --- a/astrbot/core/utils/astrbot_path.py +++ b/astrbot/core/utils/astrbot_path.py @@ -10,6 +10,7 @@ WebChat 数据目录路径：固定为数据目录下的 webchat 目录 临时文件目录路径：固定为数据目录下的 temp 目录 Skills 目录路径：固定为数据目录下的 skills 目录 +Workspaces 目录路径：固定为数据目录下的 workspaces 目录 第三方依赖目录路径：固定为数据目录下的 site-packages 目录 """ @@ -74,6 +75,11 @@ def get_astrbot_skills_path() -> str: return os.path.realpath(os.path.join(get_astrbot_data_path(), "skills")) +def get_astrbot_workspaces_path() -> str: + """获取Astrbot Workspaces 目录路径""" + return os.path.realpath(os.path.join(get_astrbot_data_path(), "workspaces")) + + def get_astrbot_site_packages_path() -> str: """获取Astrbot第三方依赖目录路径""" return os.path.realpath(os.path.join(get_astrbot_data_path(), "site-packages")) diff --git a/pyproject.toml b/pyproject.toml index ed14adb4a8..a6d589b8d1 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -68,6 +68,7 @@ dependencies = [ "python-socks>=2.8.0", "pysocks>=1.7.1", "packaging>=24.2", + "python-ripgrep==0.0.9", ] [dependency-groups] diff --git a/requirements.txt b/requirements.txt index 04ac5265d8..ff316c2043 100644 --- a/requirements.txt +++ b/requirements.txt @@ -56,4 +56,5 @@ tenacity>=9.1.2 shipyard-python-sdk>=0.2.4 shipyard-neo-sdk>=0.2.0 packaging>=24.2 -qrcode>=8.2 \ No newline at end of file +qrcode>=8.2 +python-ripgrep==0.0.9 \ No newline at end of file From 8e7d995fec5e3597c0a3e59f0a4cb5f21571f0d5 Mon Sep 17 00:00:00 2001 From: Soulter <905617992@qq.com> Date: Tue, 7 Apr 2026 20:45:40 +0800 Subject: [PATCH 02/20] feat: add file write tool and enhance file read functionality --- astrbot/core/astr_agent_tool_exec.py | 3 + astrbot/core/astr_main_agent.py | 8 + astrbot/core/astr_main_agent_resources.py | 6 +- astrbot/core/computer/booters/local.py | 22 +- astrbot/core/computer/booters/shipyard_neo.py | 22 +- astrbot/core/computer/olayer/filesystem.py | 2 +- astrbot/core/computer/tools/__init__.py | 12 +- astrbot/core/computer/tools/fs.py | 405 ++++++++++++------ 8 files changed, 328 insertions(+), 152 deletions(-) diff --git a/astrbot/core/astr_agent_tool_exec.py b/astrbot/core/astr_agent_tool_exec.py index 9d8977410e..76d5961772 100644 --- a/astrbot/core/astr_agent_tool_exec.py +++ b/astrbot/core/astr_agent_tool_exec.py @@ -23,6 +23,7 @@ FILE_DOWNLOAD_TOOL, FILE_EDIT_TOOL, FILE_UPLOAD_TOOL, + FILE_WRITE_TOOL, GREP_TOOL, LOCAL_EXECUTE_SHELL_TOOL, LOCAL_PYTHON_TOOL, @@ -188,6 +189,7 @@ def _get_runtime_computer_tools(cls, runtime: str) -> dict[str, FunctionTool]: FILE_UPLOAD_TOOL.name: FILE_UPLOAD_TOOL, FILE_DOWNLOAD_TOOL.name: FILE_DOWNLOAD_TOOL, READ_FILE_TOOL.name: READ_FILE_TOOL, + FILE_WRITE_TOOL.name: FILE_WRITE_TOOL, FILE_EDIT_TOOL.name: FILE_EDIT_TOOL, GREP_TOOL.name: GREP_TOOL, } @@ -196,6 +198,7 @@ def _get_runtime_computer_tools(cls, runtime: str) -> dict[str, FunctionTool]: LOCAL_EXECUTE_SHELL_TOOL.name: LOCAL_EXECUTE_SHELL_TOOL, LOCAL_PYTHON_TOOL.name: LOCAL_PYTHON_TOOL, READ_FILE_TOOL.name: READ_FILE_TOOL, + FILE_WRITE_TOOL.name: FILE_WRITE_TOOL, FILE_EDIT_TOOL.name: FILE_EDIT_TOOL, GREP_TOOL.name: GREP_TOOL, } diff --git a/astrbot/core/astr_main_agent.py b/astrbot/core/astr_main_agent.py index 507cbff8e5..5de8f38d4d 100644 --- a/astrbot/core/astr_main_agent.py +++ b/astrbot/core/astr_main_agent.py @@ -31,6 +31,7 @@ FILE_DOWNLOAD_TOOL, FILE_EDIT_TOOL, FILE_UPLOAD_TOOL, + FILE_WRITE_TOOL, GET_EXECUTION_HISTORY_TOOL, GET_SKILL_PAYLOAD_TOOL, GREP_TOOL, @@ -70,6 +71,7 @@ DELETE_CRON_JOB_TOOL, LIST_CRON_JOBS_TOOL, ) +from astrbot.core.utils.astrbot_path import get_astrbot_workspaces_path from astrbot.core.utils.file_extract import extract_file_moonshotai from astrbot.core.utils.llm_metadata import LLM_METADATAS from astrbot.core.utils.media_utils import ( @@ -289,6 +291,7 @@ def _apply_local_env_tools(req: ProviderRequest) -> None: req.func_tool.add_tool(LOCAL_EXECUTE_SHELL_TOOL) req.func_tool.add_tool(LOCAL_PYTHON_TOOL) req.func_tool.add_tool(READ_FILE_TOOL) + req.func_tool.add_tool(FILE_WRITE_TOOL) req.func_tool.add_tool(FILE_EDIT_TOOL) req.func_tool.add_tool(GREP_TOOL) req.system_prompt = f"{req.system_prompt or ''}\n{_build_local_mode_prompt()}\n" @@ -998,6 +1001,7 @@ def _apply_sandbox_tools( req.func_tool.add_tool(FILE_UPLOAD_TOOL) req.func_tool.add_tool(FILE_DOWNLOAD_TOOL) req.func_tool.add_tool(READ_FILE_TOOL) + req.func_tool.add_tool(FILE_WRITE_TOOL) req.func_tool.add_tool(FILE_EDIT_TOOL) req.func_tool.add_tool(GREP_TOOL) if booter == "shipyard_neo": @@ -1344,6 +1348,10 @@ async def build_main_agent( if config.tool_schema_mode == "full" else TOOL_CALL_PROMPT_SKILLS_LIKE_MODE ) + + if config.computer_use_runtime == "local": + tool_prompt += f"Current workspace you can use: `{os.path.join(get_astrbot_workspaces_path(), event.unified_msg_origin)}`\n" + req.system_prompt += f"\n{tool_prompt}\n" action_type = event.get_extra("action_type") diff --git a/astrbot/core/astr_main_agent_resources.py b/astrbot/core/astr_main_agent_resources.py index 8e74535fdd..7512aaab86 100644 --- a/astrbot/core/astr_main_agent_resources.py +++ b/astrbot/core/astr_main_agent_resources.py @@ -22,7 +22,9 @@ ExecuteShellTool, FileDownloadTool, FileEditTool, + FileReadTool, FileUploadTool, + FileWriteTool, GetExecutionHistoryTool, GetSkillPayloadTool, GrepTool, @@ -31,7 +33,6 @@ LocalPythonTool, PromoteSkillCandidateTool, PythonTool, - ReadFileTool, RollbackSkillReleaseTool, RunBrowserSkillTool, SyncSkillReleaseTool, @@ -503,7 +504,8 @@ async def retrieve_knowledge_base( LOCAL_PYTHON_TOOL = LocalPythonTool() FILE_UPLOAD_TOOL = FileUploadTool() FILE_DOWNLOAD_TOOL = FileDownloadTool() -READ_FILE_TOOL = ReadFileTool() +READ_FILE_TOOL = FileReadTool() +FILE_WRITE_TOOL = FileWriteTool() FILE_EDIT_TOOL = FileEditTool() GREP_TOOL = GrepTool() BROWSER_EXEC_TOOL = BrowserExecTool() diff --git a/astrbot/core/computer/booters/local.py b/astrbot/core/computer/booters/local.py index e8b6f6db32..212f0129c5 100644 --- a/astrbot/core/computer/booters/local.py +++ b/astrbot/core/computer/booters/local.py @@ -34,6 +34,18 @@ ] +def _slice_content_by_lines( + content: str, + *, + offset: int | None = None, + limit: int | None = None, +) -> str: + lines = content.splitlines(keepends=True) + start = 0 if offset is None else offset + selected = lines[start:] if limit is None else lines[start : start + limit] + return "".join(selected) + + def _is_safe_command(command: str) -> bool: cmd = f" {command.strip().lower()} " return not any(pat in cmd for pat in _BLOCKED_COMMAND_PATTERNS) @@ -196,13 +208,13 @@ def _run() -> dict[str, Any]: raw_content, preferred_encoding=encoding, ) - start = 0 if offset is None else offset - content_slice = ( - content[start:] if limit is None else content[start : start + limit] - ) return { "success": True, - "content": content_slice, + "content": _slice_content_by_lines( + content, + offset=offset, + limit=limit, + ), } return await asyncio.to_thread(_run) diff --git a/astrbot/core/computer/booters/shipyard_neo.py b/astrbot/core/computer/booters/shipyard_neo.py index 1ac71c78e5..f3bb7e7b53 100644 --- a/astrbot/core/computer/booters/shipyard_neo.py +++ b/astrbot/core/computer/booters/shipyard_neo.py @@ -34,6 +34,18 @@ def _maybe_model_dump(value: Any) -> dict[str, Any]: return {} +def _slice_content_by_lines( + content: str, + *, + offset: int | None = None, + limit: int | None = None, +) -> str: + lines = content.splitlines(keepends=True) + start = 0 if offset is None else offset + selected = lines[start:] if limit is None else lines[start : start + limit] + return "".join(selected) + + class NeoPythonComponent(PythonComponent): def __init__(self, sandbox: Sandbox) -> None: self._sandbox = sandbox @@ -168,14 +180,14 @@ async def read_file( ) -> dict[str, Any]: _ = encoding content = await self._sandbox.filesystem.read_file(path) - start = 0 if offset is None else offset - content_slice = ( - content[start:] if limit is None else content[start : start + limit] - ) return { "success": True, "path": path, - "content": content_slice, + "content": _slice_content_by_lines( + content, + offset=offset, + limit=limit, + ), } async def search_files( diff --git a/astrbot/core/computer/olayer/filesystem.py b/astrbot/core/computer/olayer/filesystem.py index 0646cd46d1..04df566b1f 100644 --- a/astrbot/core/computer/olayer/filesystem.py +++ b/astrbot/core/computer/olayer/filesystem.py @@ -19,7 +19,7 @@ async def read_file( offset: int | None = None, limit: int | None = None, ) -> dict[str, Any]: - """Read file content""" + """Read file content by line window""" ... async def search_files( diff --git a/astrbot/core/computer/tools/__init__.py b/astrbot/core/computer/tools/__init__.py index e97a84cce6..ec34388e1d 100644 --- a/astrbot/core/computer/tools/__init__.py +++ b/astrbot/core/computer/tools/__init__.py @@ -1,5 +1,12 @@ from .browser import BrowserBatchExecTool, BrowserExecTool, RunBrowserSkillTool -from .fs import FileDownloadTool, FileEditTool, FileUploadTool, GrepTool, ReadFileTool +from .fs import ( + FileDownloadTool, + FileEditTool, + FileReadTool, + FileUploadTool, + FileWriteTool, + GrepTool, +) from .neo_skills import ( AnnotateExecutionTool, CreateSkillCandidateTool, @@ -32,9 +39,10 @@ "RollbackSkillReleaseTool", "SyncSkillReleaseTool", "FileUploadTool", + "FileWriteTool", "FileEditTool", "GrepTool", - "ReadFileTool", + "FileReadTool", "PythonTool", "LocalPythonTool", "ExecuteShellTool", diff --git a/astrbot/core/computer/tools/fs.py b/astrbot/core/computer/tools/fs.py index cdd36c813a..18940769c2 100644 --- a/astrbot/core/computer/tools/fs.py +++ b/astrbot/core/computer/tools/fs.py @@ -1,27 +1,34 @@ """Filesystem tool audit. Tool exposure from the main agent: -- Local runtime exposes `astrbot_read_file_tool`, `astrbot_file_edit_tool`, - and `astrbot_grep_tool`. +- Local runtime exposes `astrbot_read_file_tool`, `astrbot_file_write_tool`, + `astrbot_file_edit_tool`, and `astrbot_grep_tool`. - Sandbox runtime exposes `astrbot_upload_file`, `astrbot_download_file`, - `astrbot_read_file_tool`, `astrbot_file_edit_tool`, and `astrbot_grep_tool`. + `astrbot_read_file_tool`, `astrbot_file_write_tool`, + `astrbot_file_edit_tool`, and `astrbot_grep_tool`. Behavior when `provider_settings.computer_use_require_admin=True`: -- Admin + local: read/edit/grep are not path-restricted by this module; access - depends on the local runtime implementation and host OS permissions. Upload - and download tools are defined here, but `LocalBooter` does not implement - them and the main agent does not expose them in local mode. -- Member + local: read/edit/grep are restricted to `data/skills`, +- Admin + local: read/write/edit/grep are not path-restricted by this module; + access depends on the local runtime implementation and host OS permissions. + Upload and download tools are defined here, but `LocalBooter` does not + implement them and the main agent does not expose them in local mode. +- Member + local: read/write/edit/grep are restricted to `data/skills`, `data/workspaces/{normalized_umo}`, and `/tmp/.astrbot`. Upload/download are denied by `check_admin_permission` if invoked. -- Admin + sandbox: read/edit/grep are not path-restricted by this module; +- Admin + sandbox: read/write/edit/grep are not path-restricted by this + module; sandbox filesystem boundaries are enforced by the sandbox runtime. Upload and download are allowed. -- Member + sandbox: read/edit/grep are also not path-restricted by this module. - Upload/download are denied by `check_admin_permission` if invoked. +- Member + sandbox: read/write/edit/grep are also not path-restricted by this + module. Upload/download are denied by `check_admin_permission` if invoked. When `computer_use_require_admin=False`, member behavior in this module matches admin behavior. + +Local path resolution rule: +- In local runtime, relative paths are resolved under + `data/workspaces/{normalized_umo}`. +- In sandbox runtime, relative paths are passed through unchanged. """ import os @@ -61,75 +68,78 @@ def _restricted_env_path_labels(umo: str) -> list[str]: ] +def _workspace_root(umo: str) -> Path: + """Root directory for relative paths in local runtime""" + normalized_umo = _normalize_umo_for_workspace(umo) + return (Path(get_astrbot_workspaces_path()) / normalized_umo).resolve(strict=False) + + def _read_allowed_roots(umo: str) -> tuple[Path, ...]: """Non-admin users can only read files within these directories (and their subdirectories)""" - normalized_umo = _normalize_umo_for_workspace(umo) return ( Path(get_astrbot_skills_path()).resolve(strict=False), - (Path(get_astrbot_workspaces_path()) / normalized_umo).resolve(strict=False), + _workspace_root(umo), Path("/tmp/.astrbot").resolve(strict=False), ) -def _is_restricted_env(context: ContextWrapper[AstrAgentContext]) -> bool: +def _is_local_runtime(context: ContextWrapper[AstrAgentContext]) -> bool: cfg = context.context.context.get_config( umo=context.context.event.unified_msg_origin ) provider_settings = cfg.get("provider_settings", {}) runtime = str(provider_settings.get("computer_use_runtime", "local")) - if runtime != "local": + return runtime == "local" + + +def _is_restricted_env(context: ContextWrapper[AstrAgentContext]) -> bool: + if not _is_local_runtime(context): return False + cfg = context.context.context.get_config( + umo=context.context.event.unified_msg_origin + ) + provider_settings = cfg.get("provider_settings", {}) require_admin = provider_settings.get("computer_use_require_admin", True) return require_admin and context.context.event.role != "admin" -def _resolve_user_path(path: str) -> Path: +def _resolve_tool_path(path: str, *, local_env: bool, umo: str) -> str: + normalized_path = path.strip() + if not normalized_path: + return normalized_path + candidate = Path(normalized_path).expanduser() + if candidate.is_absolute(): + return str(candidate.resolve(strict=False)) + if local_env: + return str((_workspace_root(umo) / candidate).resolve(strict=False)) + return normalized_path + + +def _resolve_user_path(path: str, *, local_env: bool, umo: str) -> Path: candidate = Path(path).expanduser() if candidate.is_absolute(): return candidate.resolve(strict=False) + if local_env: + return (_workspace_root(umo) / candidate).resolve(strict=False) return (Path.cwd() / candidate).resolve(strict=False) def _is_path_within_allowed_roots(path: str, umo: str) -> bool: - resolved = _resolve_user_path(path) + resolved = _resolve_user_path(path, local_env=True, umo=umo) return any( resolved == allowed_root or resolved.is_relative_to(allowed_root) for allowed_root in _read_allowed_roots(umo) ) -def _normalize_search_paths( - path: str | None, - *, - restricted: bool, - umo: str, -) -> list[str]: - normalized = [path] if path else [] - if not normalized: - return _restricted_env_path_labels(umo) if restricted else ["."] - - if restricted: - disallowed = [ - path for path in normalized if not _is_path_within_allowed_roots(path, umo) - ] - if disallowed: - allowed = ", ".join(_restricted_env_path_labels(umo)) - blocked = ", ".join(disallowed) - raise PermissionError( - "Read access is restricted for this user. " - f"Allowed directories: {allowed}. Blocked paths: {blocked}." - ) - - return normalized - - -def _normalize_read_path( +def _normalize_rw_path( path: str, *, restricted: bool, + local_env: bool, umo: str, ) -> str: - normalized_path = path.strip() + normalized_path = _resolve_tool_path(path, local_env=local_env, umo=umo) if not normalized_path: raise ValueError("`path` must be a non-empty string.") if restricted and not _is_path_within_allowed_roots(normalized_path, umo): @@ -141,79 +151,9 @@ def _normalize_read_path( return normalized_path -def _resolve_context_options( - after_context: int | None, - before_context: int | None, - context: int | None, -) -> tuple[int | None, int | None]: - if context is not None and context < 0: - raise ValueError("`-C` must be greater than or equal to 0.") - if after_context is not None and after_context < 0: - raise ValueError("`-A` must be greater than or equal to 0.") - if before_context is not None and before_context < 0: - raise ValueError("`-B` must be greater than or equal to 0.") - - resolved_after = context if after_context is None else after_context - resolved_before = context if before_context is None else before_context - return resolved_after, resolved_before - - -def _split_output_groups(output: str, *, has_context: bool) -> list[str]: - if not output.strip(): - return [] - - if not has_context: - return [f"{line}\n" for line in output.splitlines() if line.strip()] - - groups: list[str] = [] - current: list[str] = [] - - for line in output.splitlines(keepends=True): - if line.strip() == "--": - if current: - groups.append("".join(current)) - current = [] - continue - if not line.strip(): - continue - current.append(line) - - if current: - groups.append("".join(current)) - return groups - - -def _apply_result_limit( - output: str, - *, - result_limit: int, - has_context: bool, -) -> str: - if result_limit < 1: - raise ValueError("`result_limit` must be greater than or equal to 1.") - - groups = _split_output_groups(output, has_context=has_context) - if len(groups) <= result_limit: - return output if output.strip() else "No matches found." - - limited_output = "".join(groups[:result_limit]).rstrip() - return f"{limited_output}\n\n[Truncated to first {result_limit} result groups.]" - - -def _validate_read_window( - offset: int | None, - limit: int | None, -) -> tuple[int | None, int | None]: - if offset is not None and offset < 0: - raise ValueError("`offset` must be greater than or equal to 0.") - if limit is not None and limit < 1: - raise ValueError("`limit` must be greater than or equal to 1.") - return offset, limit - - @dataclass -class ReadFileTool(FunctionTool): - name: str = "astrbot_read_file_tool" +class FileReadTool(FunctionTool): + name: str = "astrbot_file_read_tool" description: str = "read file content." parameters: dict = field( default_factory=lambda: { @@ -221,16 +161,16 @@ class ReadFileTool(FunctionTool): "properties": { "path": { "type": "string", - "description": "Path of the file to read.", + "description": "Path of the file to read. If relative, will be in workspace root.", }, "offset": { "type": "integer", - "description": "Character offset to start reading from. Defaults to 0.", + "description": "Line offset to start reading from. Defaults to 0.", "minimum": 0, }, "limit": { "type": "integer", - "description": "Maximum number of characters to read. Defaults to 4000.", + "description": "Maximum number of lines to read. Defaults to 4000.", "minimum": 1, }, }, @@ -238,6 +178,17 @@ class ReadFileTool(FunctionTool): } ) + def _validate_read_window( + self, + offset: int | None, + limit: int | None, + ) -> tuple[int | None, int | None]: + if offset is not None and offset < 0: + raise ValueError("`offset` must be greater than or equal to 0.") + if limit is not None and limit < 1: + raise ValueError("`limit` must be greater than or equal to 1.") + return offset, limit + async def call( self, context: ContextWrapper[AstrAgentContext], @@ -245,14 +196,22 @@ async def call( offset: int | None = None, limit: int | None = None, ) -> ToolExecResult: + local_env = _is_local_runtime(context) restricted = _is_restricted_env(context) try: - normalized_path = _normalize_read_path( - path, - restricted=restricted, - umo=context.context.event.unified_msg_origin, + normalized_path = ( + _normalize_rw_path( + path, + restricted=restricted, + local_env=local_env, + umo=context.context.event.unified_msg_origin, + ) + if local_env + else path.strip() ) - offset, limit = _validate_read_window(offset, limit) + if not normalized_path: + raise ValueError("`path` must be a non-empty string.") + offset, limit = self._validate_read_window(offset, limit) sb = await get_booter( context.context.context, context.context.event.unified_msg_origin, @@ -272,7 +231,7 @@ async def call( content = str(result.get("content", "") or "") if not content: - return "No content found at the requested offset." + return "No content found at the requested line offset." return content or "" except PermissionError as exc: return f"Error: {exc}" @@ -281,6 +240,72 @@ async def call( return f"Error reading file: {exc}" +@dataclass +class FileWriteTool(FunctionTool): + name: str = "astrbot_file_write_tool" + description: str = "Write UTF-8 text content to a file." + parameters: dict = field( + default_factory=lambda: { + "type": "object", + "properties": { + "path": { + "type": "string", + "description": "Path of the file to write. If relative, will be in workspace root.", + }, + "content": { + "type": "string", + "description": "The content to write to the file", + }, + }, + "required": ["path", "content"], + } + ) + + async def call( + self, + context: ContextWrapper[AstrAgentContext], + path: str, + content: str, + ) -> ToolExecResult: + local_env = _is_local_runtime(context) + restricted = _is_restricted_env(context) + try: + normalized_path = ( + _normalize_rw_path( + path, + restricted=restricted, + local_env=local_env, + umo=context.context.event.unified_msg_origin, + ) + if local_env + else path.strip() + ) + if not normalized_path: + raise ValueError("`path` must be a non-empty string.") + sb = await get_booter( + context.context.context, + context.context.event.unified_msg_origin, + ) + result = await sb.fs.write_file( + path=normalized_path, + content=content, + mode="w", + encoding="utf-8", + ) + if not result.get("success", False): + error_detail = str(result.get("error", "") or "").strip() + return ( + "Error writing file: " + f"{error_detail or 'unknown filesystem write error'}" + ) + return f"File written successfully: {normalized_path}" + except PermissionError as exc: + return f"Error: {exc}" + except Exception as exc: + logger.error(f"Error writing file: {exc}") + return f"Error writing file: {exc}" + + @dataclass class FileEditTool(FunctionTool): name: str = "astrbot_file_edit_tool" @@ -291,7 +316,7 @@ class FileEditTool(FunctionTool): "properties": { "path": { "type": "string", - "description": "Path of the file to edit.", + "description": "Path of the file to edit. If relative, will be in workspace root.", }, "old": { "type": "string", @@ -319,13 +344,21 @@ async def call( replace_all: bool = False, ) -> ToolExecResult: umo = str(context.context.event.unified_msg_origin) + local_env = _is_local_runtime(context) restricted = _is_restricted_env(context) try: - normalized_path = _normalize_read_path( - path, - restricted=restricted, - umo=umo, + normalized_path = ( + _normalize_rw_path( + path, + restricted=restricted, + local_env=local_env, + umo=umo, + ) + if local_env + else path.strip() ) + if not normalized_path: + raise ValueError("`path` must be a non-empty string.") sb = await get_booter( context.context.context, context.context.event.unified_msg_origin, @@ -370,7 +403,7 @@ class GrepTool(FunctionTool): }, "path": { "type": "string", - "description": "File or directory to search in (rg PATH).", + "description": "File or directory to search in (rg PATH). If relative, will be in workspace root.", }, "glob": { "type": "string", @@ -401,6 +434,98 @@ class GrepTool(FunctionTool): } ) + def _resolve_context_options( + self, + after_context: int | None, + before_context: int | None, + context: int | None, + ) -> tuple[int | None, int | None]: + if context is not None and context < 0: + raise ValueError("`-C` must be greater than or equal to 0.") + if after_context is not None and after_context < 0: + raise ValueError("`-A` must be greater than or equal to 0.") + if before_context is not None and before_context < 0: + raise ValueError("`-B` must be greater than or equal to 0.") + + resolved_after = context if after_context is None else after_context + resolved_before = context if before_context is None else before_context + return resolved_after, resolved_before + + def _split_output_groups(self, output: str, *, has_context: bool) -> list[str]: + if not output.strip(): + return [] + + if not has_context: + return [f"{line}\n" for line in output.splitlines() if line.strip()] + + groups: list[str] = [] + current: list[str] = [] + + for line in output.splitlines(keepends=True): + if line.strip() == "--": + if current: + groups.append("".join(current)) + current = [] + continue + if not line.strip(): + continue + current.append(line) + + if current: + groups.append("".join(current)) + return groups + + def _apply_result_limit( + self, + output: str, + *, + result_limit: int, + has_context: bool, + ) -> str: + if result_limit < 1: + raise ValueError("`result_limit` must be greater than or equal to 1.") + + groups = self._split_output_groups(output, has_context=has_context) + if len(groups) <= result_limit: + return output if output.strip() else "No matches found." + + limited_output = "".join(groups[:result_limit]).rstrip() + return f"{limited_output}\n\n[Truncated to first {result_limit} result groups.]" + + def _normalize_search_paths( + self, + path: str | None, + *, + restricted: bool, + local_env: bool, + umo: str, + ) -> list[str]: + normalized = ( + [_resolve_tool_path(path, local_env=local_env, umo=umo)] if path else [] + ) + if not normalized: + if restricted: + return [str(root) for root in _read_allowed_roots(umo)] + if local_env: + return [str(_workspace_root(umo))] + return ["."] + + if restricted: + disallowed = [ + path + for path in normalized + if not _is_path_within_allowed_roots(path, umo) + ] + if disallowed: + allowed = ", ".join(_restricted_env_path_labels(umo)) + blocked = ", ".join(disallowed) + raise PermissionError( + "Read access is restricted for this user. " + f"Allowed directories: {allowed}. Blocked paths: {blocked}." + ) + + return normalized + async def call( self, context: ContextWrapper[AstrAgentContext], @@ -414,14 +539,20 @@ async def call( if not normalized_pattern: return "Error: `pattern` must be a non-empty string." + local_env = _is_local_runtime(context) restricted = _is_restricted_env(context) try: - search_paths = _normalize_search_paths( - path, - restricted=restricted, - umo=context.context.event.unified_msg_origin, + search_paths = ( + self._normalize_search_paths( + path, + restricted=restricted, + local_env=local_env, + umo=context.context.event.unified_msg_origin, + ) + if local_env + else ([path.strip()] if path and path.strip() else ["."]) ) - after_context, before_context = _resolve_context_options( + after_context, before_context = self._resolve_context_options( kwargs.get("-A"), kwargs.get("-B"), kwargs.get("-C"), @@ -451,7 +582,7 @@ async def call( if content: contents.append(content) - return _apply_result_limit( + return self._apply_result_limit( "".join(contents), result_limit=result_limit, has_context=has_context, From 11282c769f93e53a02f4f33e2e14e9da899385ad Mon Sep 17 00:00:00 2001 From: Soulter <905617992@qq.com> Date: Tue, 7 Apr 2026 21:32:11 +0800 Subject: [PATCH 03/20] feat: enhance tool prompt formatting and add escaped text decoding for file editing --- astrbot/core/astr_main_agent.py | 2 +- astrbot/core/computer/tools/fs.py | 16 ++++++++++++++-- 2 files changed, 15 insertions(+), 3 deletions(-) diff --git a/astrbot/core/astr_main_agent.py b/astrbot/core/astr_main_agent.py index 5de8f38d4d..18383394f2 100644 --- a/astrbot/core/astr_main_agent.py +++ b/astrbot/core/astr_main_agent.py @@ -1350,7 +1350,7 @@ async def build_main_agent( ) if config.computer_use_runtime == "local": - tool_prompt += f"Current workspace you can use: `{os.path.join(get_astrbot_workspaces_path(), event.unified_msg_origin)}`\n" + tool_prompt += f"\nCurrent workspace you can use: `{os.path.join(get_astrbot_workspaces_path(), event.unified_msg_origin)}`\n" req.system_prompt += f"\n{tool_prompt}\n" diff --git a/astrbot/core/computer/tools/fs.py b/astrbot/core/computer/tools/fs.py index 18940769c2..0d21d0d68b 100644 --- a/astrbot/core/computer/tools/fs.py +++ b/astrbot/core/computer/tools/fs.py @@ -151,6 +151,16 @@ def _normalize_rw_path( return normalized_path +def _decode_escaped_text(value: str) -> str: + """Decode common escaped control sequences used in tool arguments.""" + return ( + value.replace("\\r\\n", "\n") + .replace("\\n", "\n") + .replace("\\r", "\r") + .replace("\\t", "\t") + ) + + @dataclass class FileReadTool(FunctionTool): name: str = "astrbot_file_read_tool" @@ -359,14 +369,16 @@ async def call( ) if not normalized_path: raise ValueError("`path` must be a non-empty string.") + normalized_old = _decode_escaped_text(old) + normalized_new = _decode_escaped_text(new) sb = await get_booter( context.context.context, context.context.event.unified_msg_origin, ) result = await sb.fs.edit_file( path=normalized_path, - old_string=old, - new_string=new, + old_string=normalized_old, + new_string=normalized_new, replace_all=replace_all, encoding="utf-8", ) From a539deec912c2010eece11721169978411e7d6e2 Mon Sep 17 00:00:00 2001 From: Soulter <905617992@qq.com> Date: Tue, 7 Apr 2026 21:44:34 +0800 Subject: [PATCH 04/20] feat: remove redundant safe path tests from security restrictions --- tests/unit/test_computer.py | 47 ------------------------------------- 1 file changed, 47 deletions(-) diff --git a/tests/unit/test_computer.py b/tests/unit/test_computer.py index 8c07bd0784..6083b3c695 100644 --- a/tests/unit/test_computer.py +++ b/tests/unit/test_computer.py @@ -15,7 +15,6 @@ LocalFileSystemComponent, LocalPythonComponent, LocalShellComponent, - _ensure_safe_path, _is_safe_command, ) @@ -126,52 +125,6 @@ def test_is_safe_command_blocked(self): for cmd in blocked_commands: assert _is_safe_command(cmd) is False, f"Command '{cmd}' should be blocked" - def test_ensure_safe_path_allowed(self, tmp_path): - """Test paths within allowed roots are accepted.""" - # Create a test directory structure - test_file = tmp_path / "test.txt" - test_file.write_text("test") - - # Mock get_astrbot_root, get_astrbot_data_path, get_astrbot_temp_path - with ( - patch( - "astrbot.core.computer.booters.local.get_astrbot_root", - return_value=str(tmp_path), - ), - patch( - "astrbot.core.computer.booters.local.get_astrbot_data_path", - return_value=str(tmp_path), - ), - patch( - "astrbot.core.computer.booters.local.get_astrbot_temp_path", - return_value=str(tmp_path), - ), - ): - result = _ensure_safe_path(str(test_file)) - assert result == str(test_file) - - def test_ensure_safe_path_blocked(self, tmp_path): - """Test paths outside allowed roots raise PermissionError.""" - with ( - patch( - "astrbot.core.computer.booters.local.get_astrbot_root", - return_value=str(tmp_path), - ), - patch( - "astrbot.core.computer.booters.local.get_astrbot_data_path", - return_value=str(tmp_path), - ), - patch( - "astrbot.core.computer.booters.local.get_astrbot_temp_path", - return_value=str(tmp_path), - ), - ): - # Try to access a path outside the allowed roots - with pytest.raises(PermissionError) as exc_info: - _ensure_safe_path("/etc/passwd") - assert "Path is outside the allowed computer roots" in str(exc_info.value) - - class TestLocalShellComponent: """Tests for LocalShellComponent.""" From 20fed8ab624aa19a003cb1d2043693a634b6c178 Mon Sep 17 00:00:00 2001 From: Soulter <905617992@qq.com> Date: Tue, 7 Apr 2026 23:52:23 +0800 Subject: [PATCH 05/20] feat: implement file read tool with support for text and image files, including validation for large files --- astrbot/core/astr_main_agent.py | 10 +- astrbot/core/computer/booters/local.py | 3 +- .../booters/shipyard_search_file_util.py | 33 +- astrbot/core/computer/tools/fs.py | 24 +- .../computer/tools/tool_utils/file_read.py | 458 ++++++++++++++++++ tests/test_computer_fs_tools.py | 215 ++++++++ 6 files changed, 722 insertions(+), 21 deletions(-) create mode 100644 astrbot/core/computer/tools/tool_utils/file_read.py create mode 100644 tests/test_computer_fs_tools.py diff --git a/astrbot/core/astr_main_agent.py b/astrbot/core/astr_main_agent.py index 18383394f2..266499e3de 100644 --- a/astrbot/core/astr_main_agent.py +++ b/astrbot/core/astr_main_agent.py @@ -1350,7 +1350,15 @@ async def build_main_agent( ) if config.computer_use_runtime == "local": - tool_prompt += f"\nCurrent workspace you can use: `{os.path.join(get_astrbot_workspaces_path(), event.unified_msg_origin)}`\n" + from astrbot.core.computer.tools.fs import _normalize_umo_for_workspace + + normalized_umo = _normalize_umo_for_workspace(event.unified_msg_origin) + tool_prompt += ( + f"\nCurrent workspace you can use: " + f"`{os.path.join(get_astrbot_workspaces_path(), normalized_umo)}`\n" + "Unless the user explicitly specifies a different directory, " + "perform all file-related operations in this workspace.\n" + ) req.system_prompt += f"\n{tool_prompt}\n" diff --git a/astrbot/core/computer/booters/local.py b/astrbot/core/computer/booters/local.py index 212f0129c5..875a0f7e77 100644 --- a/astrbot/core/computer/booters/local.py +++ b/astrbot/core/computer/booters/local.py @@ -16,6 +16,7 @@ from ..olayer import FileSystemComponent, PythonComponent, ShellComponent from .base import ComputerBooter +from .shipyard_search_file_util import _truncate_long_lines _BLOCKED_COMMAND_PATTERNS = [ " rm -rf ", @@ -236,7 +237,7 @@ def _run() -> dict[str, Any]: before_context=before_context, line_number=True, ) - return {"success": True, "content": "".join(results)} + return {"success": True, "content": _truncate_long_lines("".join(results))} return await asyncio.to_thread(_run) diff --git a/astrbot/core/computer/booters/shipyard_search_file_util.py b/astrbot/core/computer/booters/shipyard_search_file_util.py index a85998f985..1227244de3 100644 --- a/astrbot/core/computer/booters/shipyard_search_file_util.py +++ b/astrbot/core/computer/booters/shipyard_search_file_util.py @@ -5,6 +5,27 @@ from ..olayer import ShellComponent +_MAX_SEARCH_LINE_COLUMNS = 1000 + + +def _truncate_long_lines(text: str) -> str: + output_lines: list[str] = [] + for line in text.splitlines(keepends=True): + line_ending = "" + line_body = line + if line.endswith("\r\n"): + line_body = line[:-2] + line_ending = "\r\n" + elif line.endswith("\n") or line.endswith("\r"): + line_body = line[:-1] + line_ending = line[-1] + + if len(line_body) > _MAX_SEARCH_LINE_COLUMNS: + line_body = line_body[:_MAX_SEARCH_LINE_COLUMNS] + + output_lines.append(f"{line_body}{line_ending}") + return "".join(output_lines) + def _build_rg_command( *, @@ -14,7 +35,15 @@ def _build_rg_command( after_context: int | None, before_context: int | None, ) -> list[str]: - command = ["rg", "--color=never", "-n", "-e", pattern] + command = [ + "rg", + "--color=never", + "-n", + "--max-columns", + str(_MAX_SEARCH_LINE_COLUMNS), + "-e", + pattern, + ] if glob: command.extend(["-g", glob]) if after_context is not None: @@ -104,7 +133,7 @@ async def search_files_via_shell( before_context=before_context, ) result = await shell.exec(command, timeout=timeout) - stdout = str(result.get("stdout", "") or "") + stdout = _truncate_long_lines(str(result.get("stdout", "") or "")) stderr = str(result.get("stderr", "") or "") exit_code = result.get("exit_code") if exit_code in (0, None): diff --git a/astrbot/core/computer/tools/fs.py b/astrbot/core/computer/tools/fs.py index 0d21d0d68b..7595e543cf 100644 --- a/astrbot/core/computer/tools/fs.py +++ b/astrbot/core/computer/tools/fs.py @@ -51,6 +51,7 @@ from ..computer_client import get_booter from .permissions import check_admin_permission +from .tool_utils.file_read import read_file_tool_result def _normalize_umo_for_workspace(umo: str) -> str: @@ -175,12 +176,12 @@ class FileReadTool(FunctionTool): }, "offset": { "type": "integer", - "description": "Line offset to start reading from. Defaults to 0.", + "description": "Optional line offset to start reading from. 0-based index.", "minimum": 0, }, "limit": { "type": "integer", - "description": "Maximum number of lines to read. Defaults to 4000.", + "description": "Optional maximum number of lines to read.", "minimum": 1, }, }, @@ -226,23 +227,12 @@ async def call( context.context.context, context.context.event.unified_msg_origin, ) - result = await sb.fs.read_file( + return await read_file_tool_result( + sb, path=normalized_path, - encoding="utf-8", offset=offset, limit=limit, ) - if not result.get("success", False): - error_detail = str(result.get("error", "") or "").strip() - return ( - "Error reading file: " - f"{error_detail or 'unknown filesystem read error'}" - ) - - content = str(result.get("content", "") or "") - if not content: - return "No content found at the requested line offset." - return content or "" except PermissionError as exc: return f"Error: {exc}" except Exception as exc: @@ -438,7 +428,7 @@ class GrepTool(FunctionTool): }, "result_limit": { "type": "integer", - "description": "Maximum number of result groups returned by the tool. Defaults to 50.", + "description": "Maximum number of result groups returned by the tool. Defaults to 100.", "minimum": 1, }, }, @@ -544,7 +534,7 @@ async def call( pattern: str, path: str | None = None, glob: str | None = None, - result_limit: int = 50, + result_limit: int = 100, **kwargs, ) -> ToolExecResult: normalized_pattern = pattern.strip() diff --git a/astrbot/core/computer/tools/tool_utils/file_read.py b/astrbot/core/computer/tools/tool_utils/file_read.py new file mode 100644 index 0000000000..e0a6f21420 --- /dev/null +++ b/astrbot/core/computer/tools/tool_utils/file_read.py @@ -0,0 +1,458 @@ +from __future__ import annotations + +import base64 +import json +from asyncio import to_thread +from dataclasses import dataclass +from pathlib import Path +from typing import Literal + +import mcp + +from astrbot.core.agent.context.token_counter import EstimateTokenCounter +from astrbot.core.agent.message import Message +from astrbot.core.agent.tool import ToolExecResult +from astrbot.core.computer.booters.base import ComputerBooter +from astrbot.core.computer.booters.local import LocalBooter +from astrbot.core.utils.astrbot_path import get_astrbot_temp_path +from astrbot.core.utils.media_utils import ( + IMAGE_COMPRESS_DEFAULT_MAX_SIZE, + IMAGE_COMPRESS_DEFAULT_OPTIMIZE, + IMAGE_COMPRESS_DEFAULT_QUALITY, + _compress_image_sync, +) + +_MAX_FILE_READ_BYTES = 128 * 1024 +_MAX_FILE_READ_TOKENS = 25_000 +_MAX_TEXT_FILE_FULL_READ_BYTES = 256 * 1024 +_FILE_SNIFF_BYTES = 512 +_TOKEN_COUNTER = EstimateTokenCounter() +_TEXT_ENCODINGS = ( + "utf-8-sig", + "utf-8", + "gb18030", + "utf-16", + "utf-16-le", + "utf-16-be", + "utf-32", + "utf-32-le", + "utf-32-be", +) +_UTF_BOMS = ( + b"\xef\xbb\xbf", + b"\xff\xfe", + b"\xfe\xff", + b"\xff\xfe\x00\x00", + b"\x00\x00\xfe\xff", +) +_BINARY_MAGIC_PREFIXES = ( + b"%PDF-", + b"PK\x03\x04", + b"PK\x05\x06", + b"PK\x07\x08", + b"\x1f\x8b", + b"7z\xbc\xaf\x27\x1c", + b"Rar!\x1a\x07", + b"\x7fELF", + b"MZ", +) + + +@dataclass(frozen=True) +class FileProbe: + kind: Literal["text", "image", "binary"] + encoding: str | None + mime_type: str | None + size_bytes: int + + +def _build_probe_script(path: str) -> str: + return f""" +import base64 +import json +from pathlib import Path + +path = Path({path!r}) +with path.open("rb") as file_obj: + sample = file_obj.read({_FILE_SNIFF_BYTES}) +print( + json.dumps( + {{ + "size_bytes": path.stat().st_size, + "sample_b64": base64.b64encode(sample).decode("ascii"), + }} + ) +) +""".strip() + + +def _build_text_read_script( + path: str, + *, + encoding: str, + offset: int | None, + limit: int | None, +) -> str: + start_expr = "0" if offset is None else str(offset) + limit_expr = "None" if limit is None else str(limit) + return f""" +import json +from pathlib import Path + +path = Path({path!r}) +start = {start_expr} +limit = {limit_expr} +end = None if limit is None else start + limit +lines = [] +with path.open("r", encoding={encoding!r}, newline="") as file_obj: + for index, line in enumerate(file_obj): + if index < start: + continue + if end is not None and index >= end: + break + lines.append(line) +content = "".join(lines) +print(json.dumps({{"content": content}}, ensure_ascii=False)) +""".strip() + + +def _build_image_read_script(path: str) -> str: + return f""" +import base64 +import json +from pathlib import Path + +path = Path({path!r}) +data = path.read_bytes() +print( + json.dumps( + {{ + "size_bytes": len(data), + "base64": base64.b64encode(data).decode("ascii"), + }} + ) +) +""".strip() + + +async def _exec_python_json( + booter: ComputerBooter, + script: str, + *, + action: str, +) -> dict: + result = await booter.python.exec(script) + data = result.get("data") if isinstance(result.get("data"), dict) else {} + if not isinstance(data, dict): + raise RuntimeError(f"{action} failed: invalid result format") + output = data.get("output") if isinstance(data.get("output"), dict) else {} + if not isinstance(output, dict): + raise RuntimeError(f"{action} failed: invalid output format") + error_text = str(data.get("error", "") or result.get("error", "") or "").strip() + if error_text: + raise RuntimeError(f"{action} failed: {error_text}") + + text = str(output.get("text", "") or "").strip() + if not text: + raise RuntimeError(f"{action} failed: empty output") + + try: + payload = json.loads(text) + except json.JSONDecodeError as exc: + raise RuntimeError(f"{action} failed: invalid JSON output") from exc + + if not isinstance(payload, dict): + raise RuntimeError(f"{action} failed: invalid JSON payload") + return payload + + +async def _probe_local_file(path: str) -> dict[str, str | int]: + def _run() -> dict[str, str | int]: + file_path = Path(path) + with file_path.open("rb") as file_obj: + sample = file_obj.read(_FILE_SNIFF_BYTES) + return { + "size_bytes": file_path.stat().st_size, + "sample_b64": base64.b64encode(sample).decode("ascii"), + } + + return await to_thread(_run) + + +async def _read_local_text_range( + path: str, + *, + encoding: str, + offset: int | None, + limit: int | None, +) -> str: + def _run() -> str: + lines: list[str] = [] + start = 0 if offset is None else offset + end = None if limit is None else start + limit + with Path(path).open("r", encoding=encoding, newline="") as file_obj: + for index, line in enumerate(file_obj): + if index < start: + continue + if end is not None and index >= end: + break + lines.append(line) + return "".join(lines) + + return await to_thread(_run) + + +async def _read_local_image_base64(path: str) -> dict[str, str | int]: + def _run() -> dict[str, str | int]: + data = Path(path).read_bytes() + return { + "size_bytes": len(data), + "base64": base64.b64encode(data).decode("ascii"), + } + + return await to_thread(_run) + + +async def _compress_image_bytes_to_base64(data: bytes) -> dict[str, str | int]: + def _run() -> dict[str, str | int]: + temp_dir = Path(get_astrbot_temp_path()) + temp_dir.mkdir(parents=True, exist_ok=True) + compressed_path = Path( + _compress_image_sync( + data, + temp_dir, + IMAGE_COMPRESS_DEFAULT_MAX_SIZE, + IMAGE_COMPRESS_DEFAULT_QUALITY, + IMAGE_COMPRESS_DEFAULT_OPTIMIZE, + ) + ) + try: + compressed_bytes = compressed_path.read_bytes() + finally: + compressed_path.unlink(missing_ok=True) + + return { + "size_bytes": len(compressed_bytes), + "base64": base64.b64encode(compressed_bytes).decode("ascii"), + "mime_type": "image/jpeg", + } + + return await to_thread(_run) + + +def _detect_image_mime(sample: bytes) -> str | None: + if sample.startswith(b"\x89PNG\r\n\x1a\n"): + return "image/png" + if sample.startswith(b"\xff\xd8\xff"): + return "image/jpeg" + if sample.startswith((b"GIF87a", b"GIF89a")): + return "image/gif" + if sample.startswith(b"BM"): + return "image/bmp" + if sample.startswith((b"II*\x00", b"MM\x00*")): + return "image/tiff" + if sample.startswith(b"\x00\x00\x01\x00"): + return "image/x-icon" + if len(sample) >= 12 and sample[:4] == b"RIFF" and sample[8:12] == b"WEBP": + return "image/webp" + if len(sample) >= 12 and sample[4:12] in (b"ftypavif", b"ftypavis"): + return "image/avif" + return None + + +def _looks_like_known_binary(sample: bytes) -> bool: + return any(sample.startswith(prefix) for prefix in _BINARY_MAGIC_PREFIXES) + + +def _looks_like_text(decoded: str) -> bool: + if not decoded: + return True + + disallowed = 0 + printable = 0 + for char in decoded: + if char in "\n\r\t\f\b": + printable += 1 + continue + if char.isprintable(): + printable += 1 + code = ord(char) + if (0 <= code < 32) or (127 <= code < 160): + disallowed += 1 + + total = max(len(decoded), 1) + return disallowed / total <= 0.02 and printable / total >= 0.85 + + +def _detect_text_encoding(sample: bytes) -> str | None: + if not sample: + return "utf-8" + + if b"\x00" in sample and not sample.startswith(_UTF_BOMS): + odd_bytes = sample[1::2] + even_bytes = sample[0::2] + odd_zero_ratio = odd_bytes.count(0) / max(len(odd_bytes), 1) + even_zero_ratio = even_bytes.count(0) / max(len(even_bytes), 1) + if odd_zero_ratio < 0.8 and even_zero_ratio < 0.8: + return None + + for encoding in _TEXT_ENCODINGS: + try: + decoded = sample.decode(encoding) + except UnicodeDecodeError: + continue + if _looks_like_text(decoded): + return encoding + + return None + + +def _probe_file(sample: bytes, *, size_bytes: int) -> FileProbe: + if image_mime := _detect_image_mime(sample): + return FileProbe( + kind="image", + encoding=None, + mime_type=image_mime, + size_bytes=size_bytes, + ) + + if _looks_like_known_binary(sample): + return FileProbe( + kind="binary", + encoding=None, + mime_type=None, + size_bytes=size_bytes, + ) + + if encoding := _detect_text_encoding(sample): + return FileProbe( + kind="text", + encoding=encoding, + mime_type="text/plain", + size_bytes=size_bytes, + ) + + return FileProbe( + kind="binary", + encoding=None, + mime_type=None, + size_bytes=size_bytes, + ) + + +def _validate_text_output(content: str) -> str | None: + content_bytes = len(content.encode("utf-8")) + if content_bytes > _MAX_FILE_READ_BYTES: + return ( + "Error reading file: " + f"output exceeds {_MAX_FILE_READ_BYTES} bytes " + f"({content_bytes} bytes). Use `offset`, `limit` to narrow the read window." + ) + + content_tokens = _TOKEN_COUNTER.count_tokens( + [Message(role="user", content=content)] + ) + if content_tokens > _MAX_FILE_READ_TOKENS: + return ( + "Error reading file: " + f"output exceeds {_MAX_FILE_READ_TOKENS} tokens " + f"({content_tokens} tokens). Use `offset`, `limit` to narrow the read window." + ) + + return None + + +def _validate_full_text_read_request(probe: FileProbe) -> str | None: + if probe.size_bytes > _MAX_TEXT_FILE_FULL_READ_BYTES: + return ( + "Error reading file: " + f"text file exceeds {_MAX_TEXT_FILE_FULL_READ_BYTES} bytes " + f"({probe.size_bytes} bytes). Use `offset` and `limit` to narrow the read window." + ) + return None + + +async def read_file_tool_result( + booter: ComputerBooter, + *, + path: str, + offset: int | None, + limit: int | None, +) -> ToolExecResult: + if isinstance(booter, LocalBooter): + probe_payload = await _probe_local_file(path) + else: + probe_payload = await _exec_python_json( + booter, + _build_probe_script(path), + action="file probe", + ) + sample_b64 = str(probe_payload.get("sample_b64", "") or "") + sample = base64.b64decode(sample_b64) if sample_b64 else b"" + size_bytes = int(probe_payload.get("size_bytes", 0) or 0) + probe = _probe_file(sample, size_bytes=size_bytes) + + if probe.kind == "binary": + return "Error reading file: binary files are not supported by this tool." + + if probe.kind == "image": + if isinstance(booter, LocalBooter): + image_payload = await _read_local_image_base64(path) + else: + image_payload = await _exec_python_json( + booter, + _build_image_read_script(path), + action="image read", + ) + raw_base64_data = str(image_payload.get("base64", "") or "") + if not raw_base64_data: + return "Error reading file: image payload is empty." + raw_bytes = base64.b64decode(raw_base64_data) + compressed_payload = await _compress_image_bytes_to_base64(raw_bytes) + base64_data = str(compressed_payload.get("base64", "") or "") + if not base64_data: + return "Error reading file: compressed image payload is empty." + return mcp.types.CallToolResult( + content=[ + mcp.types.ImageContent( + type="image", + data=base64_data, + mimeType=str( + compressed_payload.get("mime_type", "") or "image/jpeg" + ), + ) + ] + ) + + if isinstance(booter, LocalBooter): + if offset is None and limit is None: + if validation_error := _validate_full_text_read_request(probe): + return validation_error + content = await _read_local_text_range( + path, + encoding=probe.encoding or "utf-8", + offset=offset, + limit=limit, + ) + else: + if offset is None and limit is None: + if validation_error := _validate_full_text_read_request(probe): + return validation_error + text_payload = await _exec_python_json( + booter, + _build_text_read_script( + path, + encoding=probe.encoding or "utf-8", + offset=offset, + limit=limit, + ), + action="text read", + ) + content = str(text_payload.get("content", "") or "") + if not content: + return "No content found at the requested line offset." + + if validation_error := _validate_text_output(content): + return validation_error + + return content diff --git a/tests/test_computer_fs_tools.py b/tests/test_computer_fs_tools.py new file mode 100644 index 0000000000..857c73ff0b --- /dev/null +++ b/tests/test_computer_fs_tools.py @@ -0,0 +1,215 @@ +from __future__ import annotations + +import base64 +from types import SimpleNamespace +from typing import Any + +import pytest +from mcp.types import CallToolResult, ImageContent +from PIL import Image + +from astrbot.core.agent.run_context import ContextWrapper +from astrbot.core.computer.booters.local import LocalBooter +from astrbot.core.computer.tools import fs as fs_tools +from astrbot.core.computer.tools.tool_utils import file_read as file_read_utils + + +def _make_context( + *, + require_admin: bool = True, + role: str = "admin", + runtime: str = "local", + umo: str = "qq:friend:user-1", +) -> ContextWrapper: + config_holder = SimpleNamespace( + get_config=lambda umo=None: { + "provider_settings": { + "computer_use_require_admin": require_admin, + "computer_use_runtime": runtime, + } + } + ) + event = SimpleNamespace( + role=role, + unified_msg_origin=umo, + get_sender_id=lambda: "user-1", + ) + astr_ctx = SimpleNamespace(context=config_holder, event=event) + return ContextWrapper(context=astr_ctx) + + +def _setup_local_fs_tools( + monkeypatch: pytest.MonkeyPatch, + tmp_path, + *, + umo: str = "qq:friend:user-1", +) -> Any: + workspaces_root = tmp_path / "workspaces" + skills_root = tmp_path / "skills" + temp_root = tmp_path / "temp" + workspaces_root.mkdir() + skills_root.mkdir() + temp_root.mkdir() + + monkeypatch.setattr( + fs_tools, + "get_astrbot_workspaces_path", + lambda: str(workspaces_root), + ) + monkeypatch.setattr( + fs_tools, + "get_astrbot_skills_path", + lambda: str(skills_root), + ) + monkeypatch.setattr( + fs_tools, + "get_astrbot_temp_path", + lambda: str(temp_root), + ) + monkeypatch.setattr( + file_read_utils, + "get_astrbot_temp_path", + lambda: str(temp_root), + ) + + booter = LocalBooter() + + async def _fake_get_booter(_ctx, _umo): + return booter + + monkeypatch.setattr(fs_tools, "get_booter", _fake_get_booter) + + normalized_umo = fs_tools._normalize_umo_for_workspace(umo) + workspace = workspaces_root / normalized_umo + workspace.mkdir(parents=True, exist_ok=True) + return workspace + + +def _make_large_text() -> str: + return "".join(f"line-{index:05d}-{'x' * 48}\n" for index in range(6000)) + + +@pytest.mark.asyncio +async def test_file_read_tool_rejects_large_full_text_read_before_local_stream_read( + monkeypatch: pytest.MonkeyPatch, + tmp_path, +): + workspace = _setup_local_fs_tools(monkeypatch, tmp_path) + large_file = workspace / "large.txt" + large_file.write_text(_make_large_text(), encoding="utf-8") + + async def _unexpected_read(*args, **kwargs): + raise AssertionError("full file read should be rejected before streaming") + + monkeypatch.setattr(file_read_utils, "_read_local_text_range", _unexpected_read) + + result = await fs_tools.FileReadTool().call( + _make_context(), + path="large.txt", + ) + + assert "text file exceeds 262144 bytes" in result + assert "Use `offset` and `limit`" in result + + +@pytest.mark.asyncio +async def test_file_read_tool_allows_partial_read_for_large_text_file( + monkeypatch: pytest.MonkeyPatch, + tmp_path, +): + workspace = _setup_local_fs_tools(monkeypatch, tmp_path) + large_file = workspace / "large.txt" + lines = [f"line-{index:05d}\n" for index in range(50000)] + large_file.write_text("".join(lines), encoding="utf-8") + + result = await fs_tools.FileReadTool().call( + _make_context(), + path="large.txt", + offset=1000, + limit=3, + ) + + assert result == "".join(lines[1000:1003]) + + +@pytest.mark.asyncio +async def test_file_read_tool_returns_image_call_tool_result_for_images( + monkeypatch: pytest.MonkeyPatch, + tmp_path, +): + workspace = _setup_local_fs_tools(monkeypatch, tmp_path) + image_path = workspace / "sample.png" + Image.new("RGB", (32, 16), color=(255, 0, 0)).save(image_path, format="PNG") + + result = await fs_tools.FileReadTool().call( + _make_context(), + path="sample.png", + ) + + assert isinstance(result, CallToolResult) + assert len(result.content) == 1 + assert isinstance(result.content[0], ImageContent) + assert result.content[0].mimeType == "image/jpeg" + assert base64.b64decode(result.content[0].data).startswith(b"\xff\xd8\xff") + + +@pytest.mark.asyncio +async def test_file_read_tool_treats_svg_as_text( + monkeypatch: pytest.MonkeyPatch, + tmp_path, +): + workspace = _setup_local_fs_tools(monkeypatch, tmp_path) + svg_path = workspace / "shape.svg" + svg_text = ( + "" + ) + svg_path.write_text(svg_text, encoding="utf-8") + + result = await fs_tools.FileReadTool().call( + _make_context(), + path="shape.svg", + ) + + assert result == svg_text + + +@pytest.mark.asyncio +async def test_file_read_tool_rejects_pdf_as_binary( + monkeypatch: pytest.MonkeyPatch, + tmp_path, +): + workspace = _setup_local_fs_tools(monkeypatch, tmp_path) + pdf_path = workspace / "doc.pdf" + pdf_path.write_bytes(b"%PDF-1.7\n%\xe2\xe3\xcf\xd3\n1 0 obj\n<<>>\nendobj\n") + + result = await fs_tools.FileReadTool().call( + _make_context(), + path="doc.pdf", + ) + + assert result == "Error reading file: binary files are not supported by this tool." + + +@pytest.mark.asyncio +async def test_grep_tool_applies_result_limit( + monkeypatch: pytest.MonkeyPatch, + tmp_path, +): + workspace = _setup_local_fs_tools(monkeypatch, tmp_path) + text_path = workspace / "grep.txt" + text_path.write_text( + "match-1\nmatch-2\nmatch-3\nmatch-4\n", + encoding="utf-8", + ) + + result = await fs_tools.GrepTool().call( + _make_context(), + pattern="match", + path="grep.txt", + result_limit=2, + ) + + assert "match-1" in result + assert "match-2" in result + assert "match-3" not in result + assert "[Truncated to first 2 result groups.]" in result From 86ac40d94401838c07947c6616230fafff2e22d1 Mon Sep 17 00:00:00 2001 From: Soulter <905617992@qq.com> Date: Wed, 8 Apr 2026 00:34:38 +0800 Subject: [PATCH 06/20] feat: add file read utilities and integrate with filesystem tools --- astrbot/core/computer/booters/local.py | 32 ++-- .../file_read.py => file_read_utils.py} | 171 ++++++++++-------- astrbot/core/computer/tools/fs.py | 3 +- tests/test_computer_fs_tools.py | 4 +- tests/test_local_filesystem_component.py | 4 +- tests/unit/test_computer.py | 73 +------- 6 files changed, 114 insertions(+), 173 deletions(-) rename astrbot/core/computer/{tools/tool_utils/file_read.py => file_read_utils.py} (90%) diff --git a/astrbot/core/computer/booters/local.py b/astrbot/core/computer/booters/local.py index 875a0f7e77..44122361d6 100644 --- a/astrbot/core/computer/booters/local.py +++ b/astrbot/core/computer/booters/local.py @@ -12,6 +12,10 @@ from python_ripgrep import search from astrbot.api import logger +from astrbot.core.computer.file_read_utils import ( + detect_text_encoding, + read_local_text_range_sync, +) from astrbot.core.utils.astrbot_path import get_astrbot_root from ..olayer import FileSystemComponent, PythonComponent, ShellComponent @@ -35,18 +39,6 @@ ] -def _slice_content_by_lines( - content: str, - *, - offset: int | None = None, - limit: int | None = None, -) -> str: - lines = content.splitlines(keepends=True) - start = 0 if offset is None else offset - selected = lines[start:] if limit is None else lines[start : start + limit] - return "".join(selected) - - def _is_safe_command(command: str) -> bool: cmd = f" {command.strip().lower()} " return not any(pat in cmd for pat in _BLOCKED_COMMAND_PATTERNS) @@ -203,16 +195,16 @@ async def read_file( ) -> dict[str, Any]: def _run() -> dict[str, Any]: abs_path = os.path.abspath(path) - with open(abs_path, "rb") as f: - raw_content = f.read() - content = _decode_bytes_with_fallback( - raw_content, - preferred_encoding=encoding, - ) + detected_encoding = encoding + if encoding == "utf-8": + with open(abs_path, "rb") as f: + raw_sample = f.read(8192) + detected_encoding = detect_text_encoding(raw_sample) or encoding return { "success": True, - "content": _slice_content_by_lines( - content, + "content": read_local_text_range_sync( + abs_path, + encoding=detected_encoding, offset=offset, limit=limit, ), diff --git a/astrbot/core/computer/tools/tool_utils/file_read.py b/astrbot/core/computer/file_read_utils.py similarity index 90% rename from astrbot/core/computer/tools/tool_utils/file_read.py rename to astrbot/core/computer/file_read_utils.py index e0a6f21420..3c553434a3 100644 --- a/astrbot/core/computer/tools/tool_utils/file_read.py +++ b/astrbot/core/computer/file_read_utils.py @@ -12,8 +12,6 @@ from astrbot.core.agent.context.token_counter import EstimateTokenCounter from astrbot.core.agent.message import Message from astrbot.core.agent.tool import ToolExecResult -from astrbot.core.computer.booters.base import ComputerBooter -from astrbot.core.computer.booters.local import LocalBooter from astrbot.core.utils.astrbot_path import get_astrbot_temp_path from astrbot.core.utils.media_utils import ( IMAGE_COMPRESS_DEFAULT_MAX_SIZE, @@ -22,6 +20,8 @@ _compress_image_sync, ) +from .booters.base import ComputerBooter + _MAX_FILE_READ_BYTES = 128 * 1024 _MAX_FILE_READ_TOKENS = 25_000 _MAX_TEXT_FILE_FULL_READ_BYTES = 256 * 1024 @@ -135,6 +135,85 @@ def _build_image_read_script(path: str) -> str: """.strip() +def _looks_like_text(decoded: str) -> bool: + if not decoded: + return True + + disallowed = 0 + printable = 0 + for char in decoded: + if char in "\n\r\t\f\b": + printable += 1 + continue + if char.isprintable(): + printable += 1 + code = ord(char) + if (0 <= code < 32) or (127 <= code < 160): + disallowed += 1 + + total = max(len(decoded), 1) + return disallowed / total <= 0.02 and printable / total >= 0.85 + + +def detect_text_encoding(sample: bytes) -> str | None: + if not sample: + return "utf-8" + + if b"\x00" in sample and not sample.startswith(_UTF_BOMS): + odd_bytes = sample[1::2] + even_bytes = sample[0::2] + odd_zero_ratio = odd_bytes.count(0) / max(len(odd_bytes), 1) + even_zero_ratio = even_bytes.count(0) / max(len(even_bytes), 1) + if odd_zero_ratio < 0.8 and even_zero_ratio < 0.8: + return None + + for encoding in _TEXT_ENCODINGS: + try: + decoded = sample.decode(encoding) + except UnicodeDecodeError: + continue + if _looks_like_text(decoded): + return encoding + + return None + + +def read_local_text_range_sync( + path: str, + *, + encoding: str, + offset: int | None, + limit: int | None, +) -> str: + lines: list[str] = [] + start = 0 if offset is None else offset + end = None if limit is None else start + limit + with open(path, encoding=encoding, newline="") as file_obj: + for index, line in enumerate(file_obj): + if index < start: + continue + if end is not None and index >= end: + break + lines.append(line) + return "".join(lines) + + +async def read_local_text_range( + path: str, + *, + encoding: str, + offset: int | None, + limit: int | None, +) -> str: + return await to_thread( + read_local_text_range_sync, + path, + encoding=encoding, + offset=offset, + limit=limit, + ) + + async def _exec_python_json( booter: ComputerBooter, script: str, @@ -179,29 +258,6 @@ def _run() -> dict[str, str | int]: return await to_thread(_run) -async def _read_local_text_range( - path: str, - *, - encoding: str, - offset: int | None, - limit: int | None, -) -> str: - def _run() -> str: - lines: list[str] = [] - start = 0 if offset is None else offset - end = None if limit is None else start + limit - with Path(path).open("r", encoding=encoding, newline="") as file_obj: - for index, line in enumerate(file_obj): - if index < start: - continue - if end is not None and index >= end: - break - lines.append(line) - return "".join(lines) - - return await to_thread(_run) - - async def _read_local_image_base64(path: str) -> dict[str, str | int]: def _run() -> dict[str, str | int]: data = Path(path).read_bytes() @@ -264,49 +320,6 @@ def _looks_like_known_binary(sample: bytes) -> bool: return any(sample.startswith(prefix) for prefix in _BINARY_MAGIC_PREFIXES) -def _looks_like_text(decoded: str) -> bool: - if not decoded: - return True - - disallowed = 0 - printable = 0 - for char in decoded: - if char in "\n\r\t\f\b": - printable += 1 - continue - if char.isprintable(): - printable += 1 - code = ord(char) - if (0 <= code < 32) or (127 <= code < 160): - disallowed += 1 - - total = max(len(decoded), 1) - return disallowed / total <= 0.02 and printable / total >= 0.85 - - -def _detect_text_encoding(sample: bytes) -> str | None: - if not sample: - return "utf-8" - - if b"\x00" in sample and not sample.startswith(_UTF_BOMS): - odd_bytes = sample[1::2] - even_bytes = sample[0::2] - odd_zero_ratio = odd_bytes.count(0) / max(len(odd_bytes), 1) - even_zero_ratio = even_bytes.count(0) / max(len(even_bytes), 1) - if odd_zero_ratio < 0.8 and even_zero_ratio < 0.8: - return None - - for encoding in _TEXT_ENCODINGS: - try: - decoded = sample.decode(encoding) - except UnicodeDecodeError: - continue - if _looks_like_text(decoded): - return encoding - - return None - - def _probe_file(sample: bytes, *, size_bytes: int) -> FileProbe: if image_mime := _detect_image_mime(sample): return FileProbe( @@ -324,7 +337,7 @@ def _probe_file(sample: bytes, *, size_bytes: int) -> FileProbe: size_bytes=size_bytes, ) - if encoding := _detect_text_encoding(sample): + if encoding := detect_text_encoding(sample): return FileProbe( kind="text", encoding=encoding, @@ -375,11 +388,12 @@ def _validate_full_text_read_request(probe: FileProbe) -> str | None: async def read_file_tool_result( booter: ComputerBooter, *, + local_mode: bool, path: str, offset: int | None, limit: int | None, ) -> ToolExecResult: - if isinstance(booter, LocalBooter): + if local_mode: probe_payload = await _probe_local_file(path) else: probe_payload = await _exec_python_json( @@ -396,7 +410,7 @@ async def read_file_tool_result( return "Error reading file: binary files are not supported by this tool." if probe.kind == "image": - if isinstance(booter, LocalBooter): + if local_mode: image_payload = await _read_local_image_base64(path) else: image_payload = await _exec_python_json( @@ -424,20 +438,18 @@ async def read_file_tool_result( ] ) - if isinstance(booter, LocalBooter): - if offset is None and limit is None: - if validation_error := _validate_full_text_read_request(probe): - return validation_error - content = await _read_local_text_range( + if offset is None and limit is None: + if validation_error := _validate_full_text_read_request(probe): + return validation_error + + if local_mode: + content = await read_local_text_range( path, encoding=probe.encoding or "utf-8", offset=offset, limit=limit, ) else: - if offset is None and limit is None: - if validation_error := _validate_full_text_read_request(probe): - return validation_error text_payload = await _exec_python_json( booter, _build_text_read_script( @@ -449,6 +461,7 @@ async def read_file_tool_result( action="text read", ) content = str(text_payload.get("content", "") or "") + if not content: return "No content found at the requested line offset." diff --git a/astrbot/core/computer/tools/fs.py b/astrbot/core/computer/tools/fs.py index 7595e543cf..7c9c68e401 100644 --- a/astrbot/core/computer/tools/fs.py +++ b/astrbot/core/computer/tools/fs.py @@ -42,6 +42,7 @@ from astrbot.core.agent.run_context import ContextWrapper from astrbot.core.agent.tool import ToolExecResult from astrbot.core.astr_agent_context import AstrAgentContext +from astrbot.core.computer.file_read_utils import read_file_tool_result from astrbot.core.message.components import File from astrbot.core.utils.astrbot_path import ( get_astrbot_skills_path, @@ -51,7 +52,6 @@ from ..computer_client import get_booter from .permissions import check_admin_permission -from .tool_utils.file_read import read_file_tool_result def _normalize_umo_for_workspace(umo: str) -> str: @@ -229,6 +229,7 @@ async def call( ) return await read_file_tool_result( sb, + local_mode=local_env, path=normalized_path, offset=offset, limit=limit, diff --git a/tests/test_computer_fs_tools.py b/tests/test_computer_fs_tools.py index 857c73ff0b..a75bfdaadc 100644 --- a/tests/test_computer_fs_tools.py +++ b/tests/test_computer_fs_tools.py @@ -9,9 +9,9 @@ from PIL import Image from astrbot.core.agent.run_context import ContextWrapper +from astrbot.core.computer import file_read_utils from astrbot.core.computer.booters.local import LocalBooter from astrbot.core.computer.tools import fs as fs_tools -from astrbot.core.computer.tools.tool_utils import file_read as file_read_utils def _make_context( @@ -101,7 +101,7 @@ async def test_file_read_tool_rejects_large_full_text_read_before_local_stream_r async def _unexpected_read(*args, **kwargs): raise AssertionError("full file read should be rejected before streaming") - monkeypatch.setattr(file_read_utils, "_read_local_text_range", _unexpected_read) + monkeypatch.setattr(file_read_utils, "read_local_text_range", _unexpected_read) result = await fs_tools.FileReadTool().call( _make_context(), diff --git a/tests/test_local_filesystem_component.py b/tests/test_local_filesystem_component.py index b8e1180c09..6380c103f9 100644 --- a/tests/test_local_filesystem_component.py +++ b/tests/test_local_filesystem_component.py @@ -9,8 +9,6 @@ def _allow_tmp_root(monkeypatch, tmp_path: Path) -> None: monkeypatch.setattr(local_booter, "get_astrbot_root", lambda: str(tmp_path)) - monkeypatch.setattr(local_booter, "get_astrbot_data_path", lambda: str(tmp_path)) - monkeypatch.setattr(local_booter, "get_astrbot_temp_path", lambda: str(tmp_path)) def test_local_file_system_component_prefers_utf8_before_windows_locale( @@ -27,7 +25,7 @@ def test_local_file_system_component_prefers_utf8_before_windows_locale( skill_path = tmp_path / "skills" / "demo.txt" skill_path.parent.mkdir(parents=True, exist_ok=True) - skill_path.write_bytes("技能内容".encode("utf-8")) + skill_path.write_bytes("技能内容".encode()) result = asyncio.run(LocalFileSystemComponent().read_file(str(skill_path))) diff --git a/tests/unit/test_computer.py b/tests/unit/test_computer.py index 6083b3c695..71b31a301a 100644 --- a/tests/unit/test_computer.py +++ b/tests/unit/test_computer.py @@ -125,6 +125,7 @@ def test_is_safe_command_blocked(self): for cmd in blocked_commands: assert _is_safe_command(cmd) is False, f"Command '{cmd}' should be blocked" + class TestLocalShellComponent: """Tests for LocalShellComponent.""" @@ -165,14 +166,6 @@ async def test_exec_with_cwd(self, tmp_path): "astrbot.core.computer.booters.local.get_astrbot_root", return_value=str(tmp_path), ), - patch( - "astrbot.core.computer.booters.local.get_astrbot_data_path", - return_value=str(tmp_path), - ), - patch( - "astrbot.core.computer.booters.local.get_astrbot_temp_path", - return_value=str(tmp_path), - ), ): # Use python to read file to avoid Windows vs Unix command differences result = await shell.exec( @@ -247,14 +240,6 @@ async def test_create_file(self, tmp_path): "astrbot.core.computer.booters.local.get_astrbot_root", return_value=str(tmp_path), ), - patch( - "astrbot.core.computer.booters.local.get_astrbot_data_path", - return_value=str(tmp_path), - ), - patch( - "astrbot.core.computer.booters.local.get_astrbot_temp_path", - return_value=str(tmp_path), - ), ): result = await fs.create_file(str(test_path), "test content") assert result["success"] is True @@ -273,14 +258,6 @@ async def test_read_file(self, tmp_path): "astrbot.core.computer.booters.local.get_astrbot_root", return_value=str(tmp_path), ), - patch( - "astrbot.core.computer.booters.local.get_astrbot_data_path", - return_value=str(tmp_path), - ), - patch( - "astrbot.core.computer.booters.local.get_astrbot_temp_path", - return_value=str(tmp_path), - ), ): result = await fs.read_file(str(test_path)) assert result["success"] is True @@ -297,14 +274,6 @@ async def test_write_file(self, tmp_path): "astrbot.core.computer.booters.local.get_astrbot_root", return_value=str(tmp_path), ), - patch( - "astrbot.core.computer.booters.local.get_astrbot_data_path", - return_value=str(tmp_path), - ), - patch( - "astrbot.core.computer.booters.local.get_astrbot_temp_path", - return_value=str(tmp_path), - ), ): result = await fs.write_file(str(test_path), "new content") assert result["success"] is True @@ -322,14 +291,6 @@ async def test_delete_file(self, tmp_path): "astrbot.core.computer.booters.local.get_astrbot_root", return_value=str(tmp_path), ), - patch( - "astrbot.core.computer.booters.local.get_astrbot_data_path", - return_value=str(tmp_path), - ), - patch( - "astrbot.core.computer.booters.local.get_astrbot_temp_path", - return_value=str(tmp_path), - ), ): result = await fs.delete_file(str(test_path)) assert result["success"] is True @@ -348,14 +309,6 @@ async def test_delete_directory(self, tmp_path): "astrbot.core.computer.booters.local.get_astrbot_root", return_value=str(tmp_path), ), - patch( - "astrbot.core.computer.booters.local.get_astrbot_data_path", - return_value=str(tmp_path), - ), - patch( - "astrbot.core.computer.booters.local.get_astrbot_temp_path", - return_value=str(tmp_path), - ), ): result = await fs.delete_file(str(test_dir)) assert result["success"] is True @@ -375,14 +328,6 @@ async def test_list_dir(self, tmp_path): "astrbot.core.computer.booters.local.get_astrbot_root", return_value=str(tmp_path), ), - patch( - "astrbot.core.computer.booters.local.get_astrbot_data_path", - return_value=str(tmp_path), - ), - patch( - "astrbot.core.computer.booters.local.get_astrbot_temp_path", - return_value=str(tmp_path), - ), ): # Without hidden files result = await fs.list_dir(str(tmp_path), show_hidden=False) @@ -405,14 +350,6 @@ async def test_read_nonexistent_file(self, tmp_path): "astrbot.core.computer.booters.local.get_astrbot_root", return_value=str(tmp_path), ), - patch( - "astrbot.core.computer.booters.local.get_astrbot_data_path", - return_value=str(tmp_path), - ), - patch( - "astrbot.core.computer.booters.local.get_astrbot_temp_path", - return_value=str(tmp_path), - ), ): # Should raise FileNotFoundError with pytest.raises(FileNotFoundError): @@ -586,7 +523,7 @@ async def test_get_booter_shipyard(self): "shipyard_access_token": "test_token", "shipyard_ttl": 3600, "shipyard_max_sessions": 10, - } + }, } }.get(key, default) mock_context.get_config = MagicMock(return_value=mock_config) @@ -634,7 +571,7 @@ async def test_get_booter_unknown_type(self): "computer_use_runtime": "sandbox", "sandbox": { "booter": "unknown_type", - } + }, } }.get(key, default) mock_context.get_config = MagicMock(return_value=mock_config) @@ -660,7 +597,7 @@ async def test_get_booter_reuses_existing(self): "booter": "shipyard", "shipyard_endpoint": "http://localhost:8080", "shipyard_access_token": "test_token", - } + }, } }.get(key, default) mock_context.get_config = MagicMock(return_value=mock_config) @@ -705,7 +642,7 @@ async def test_get_booter_rebuild_unavailable(self): "booter": "shipyard", "shipyard_endpoint": "http://localhost:8080", "shipyard_access_token": "test_token", - } + }, } }.get(key, default) mock_context.get_config = MagicMock(return_value=mock_config) From 56a099bf9075716b7a849a8eec88c57a6ad90e60 Mon Sep 17 00:00:00 2001 From: Soulter <905617992@qq.com> Date: Wed, 8 Apr 2026 15:29:00 +0800 Subject: [PATCH 07/20] refactor: move computer tools to builtin tools registry --- astrbot/core/astr_agent_tool_exec.py | 79 ++++++++---- astrbot/core/astr_main_agent.py | 122 ++++++++++-------- astrbot/core/astr_main_agent_resources.py | 52 -------- .../computer_tools}/__init__.py | 46 ++++--- .../tools => tools/computer_tools}/fs.py | 9 +- .../computer_tools}/permissions.py | 0 .../tools => tools/computer_tools}/python.py | 6 +- .../tools => tools/computer_tools}/shell.py | 17 +-- .../computer_tools/shipyard_neo/__init__.py | 31 +++++ .../computer_tools/shipyard_neo}/browser.py | 9 +- .../shipyard_neo}/neo_skills.py | 17 ++- astrbot/core/tools/registry.py | 1 + tests/test_computer_fs_tools.py | 2 +- tests/test_computer_tool_permissions.py | 10 +- tests/test_neo_skill_tools.py | 8 +- tests/unit/test_astr_main_agent.py | 47 +++---- tests/unit/test_func_tool_manager.py | 26 ++++ tests/unit/test_python_tools.py | 5 +- 18 files changed, 283 insertions(+), 204 deletions(-) rename astrbot/core/{computer/tools => tools/computer_tools}/__init__.py (82%) rename astrbot/core/{computer/tools => tools/computer_tools}/fs.py (99%) rename astrbot/core/{computer/tools => tools/computer_tools}/permissions.py (100%) rename astrbot/core/{computer/tools => tools/computer_tools}/python.py (96%) rename astrbot/core/{computer/tools => tools/computer_tools}/shell.py (86%) create mode 100644 astrbot/core/tools/computer_tools/shipyard_neo/__init__.py rename astrbot/core/{computer/tools => tools/computer_tools/shipyard_neo}/browser.py (96%) rename astrbot/core/{computer/tools => tools/computer_tools/shipyard_neo}/neo_skills.py (98%) diff --git a/astrbot/core/astr_agent_tool_exec.py b/astrbot/core/astr_agent_tool_exec.py index c2c5ae7419..d668dfeec9 100644 --- a/astrbot/core/astr_agent_tool_exec.py +++ b/astrbot/core/astr_agent_tool_exec.py @@ -19,16 +19,6 @@ from astrbot.core.astr_agent_context import AstrAgentContext from astrbot.core.astr_main_agent_resources import ( BACKGROUND_TASK_RESULT_WOKE_SYSTEM_PROMPT, - EXECUTE_SHELL_TOOL, - FILE_DOWNLOAD_TOOL, - FILE_EDIT_TOOL, - FILE_UPLOAD_TOOL, - FILE_WRITE_TOOL, - GREP_TOOL, - LOCAL_EXECUTE_SHELL_TOOL, - LOCAL_PYTHON_TOOL, - PYTHON_TOOL, - READ_FILE_TOOL, ) from astrbot.core.cron.events import CronMessageEvent from astrbot.core.message.components import Image @@ -40,6 +30,17 @@ from astrbot.core.platform.message_session import MessageSession from astrbot.core.provider.entites import ProviderRequest from astrbot.core.provider.register import llm_tools +from astrbot.core.tools.computer_tools import ( + ExecuteShellTool, + FileDownloadTool, + FileEditTool, + FileReadTool, + FileUploadTool, + FileWriteTool, + GrepTool, + LocalPythonTool, + PythonTool, +) from astrbot.core.tools.message_tools import SendMessageToUserTool from astrbot.core.utils.astrbot_path import get_astrbot_temp_path from astrbot.core.utils.history_saver import persist_agent_history @@ -181,26 +182,44 @@ async def _run_in_background() -> None: return @classmethod - def _get_runtime_computer_tools(cls, runtime: str) -> dict[str, FunctionTool]: + def _get_runtime_computer_tools( + cls, + runtime: str, + tool_mgr, + ) -> dict[str, FunctionTool]: if runtime == "sandbox": + shell_tool = tool_mgr.get_builtin_tool(ExecuteShellTool) + python_tool = tool_mgr.get_builtin_tool(PythonTool) + upload_tool = tool_mgr.get_builtin_tool(FileUploadTool) + download_tool = tool_mgr.get_builtin_tool(FileDownloadTool) + read_tool = tool_mgr.get_builtin_tool(FileReadTool) + write_tool = tool_mgr.get_builtin_tool(FileWriteTool) + edit_tool = tool_mgr.get_builtin_tool(FileEditTool) + grep_tool = tool_mgr.get_builtin_tool(GrepTool) return { - EXECUTE_SHELL_TOOL.name: EXECUTE_SHELL_TOOL, - PYTHON_TOOL.name: PYTHON_TOOL, - FILE_UPLOAD_TOOL.name: FILE_UPLOAD_TOOL, - FILE_DOWNLOAD_TOOL.name: FILE_DOWNLOAD_TOOL, - READ_FILE_TOOL.name: READ_FILE_TOOL, - FILE_WRITE_TOOL.name: FILE_WRITE_TOOL, - FILE_EDIT_TOOL.name: FILE_EDIT_TOOL, - GREP_TOOL.name: GREP_TOOL, + shell_tool.name: shell_tool, + python_tool.name: python_tool, + upload_tool.name: upload_tool, + download_tool.name: download_tool, + read_tool.name: read_tool, + write_tool.name: write_tool, + edit_tool.name: edit_tool, + grep_tool.name: grep_tool, } if runtime == "local": + shell_tool = tool_mgr.get_builtin_tool(ExecuteShellTool) + python_tool = tool_mgr.get_builtin_tool(LocalPythonTool) + read_tool = tool_mgr.get_builtin_tool(FileReadTool) + write_tool = tool_mgr.get_builtin_tool(FileWriteTool) + edit_tool = tool_mgr.get_builtin_tool(FileEditTool) + grep_tool = tool_mgr.get_builtin_tool(GrepTool) return { - LOCAL_EXECUTE_SHELL_TOOL.name: LOCAL_EXECUTE_SHELL_TOOL, - LOCAL_PYTHON_TOOL.name: LOCAL_PYTHON_TOOL, - READ_FILE_TOOL.name: READ_FILE_TOOL, - FILE_WRITE_TOOL.name: FILE_WRITE_TOOL, - FILE_EDIT_TOOL.name: FILE_EDIT_TOOL, - GREP_TOOL.name: GREP_TOOL, + shell_tool.name: shell_tool, + python_tool.name: python_tool, + read_tool.name: read_tool, + write_tool.name: write_tool, + edit_tool.name: edit_tool, + grep_tool.name: grep_tool, } return {} @@ -215,7 +234,15 @@ def _build_handoff_toolset( cfg = ctx.get_config(umo=event.unified_msg_origin) provider_settings = cfg.get("provider_settings", {}) runtime = str(provider_settings.get("computer_use_runtime", "local")) - runtime_computer_tools = cls._get_runtime_computer_tools(runtime) + tool_mgr = ( + ctx.get_llm_tool_manager() + if hasattr(ctx, "get_llm_tool_manager") + else llm_tools + ) + runtime_computer_tools = cls._get_runtime_computer_tools( + runtime, + tool_mgr, + ) # Keep persona semantics aligned with the main agent: tools=None means # "all tools", including runtime computer-use tools. diff --git a/astrbot/core/astr_main_agent.py b/astrbot/core/astr_main_agent.py index 8de545b1f0..55bd4fe8c2 100644 --- a/astrbot/core/astr_main_agent.py +++ b/astrbot/core/astr_main_agent.py @@ -20,34 +20,10 @@ from astrbot.core.astr_agent_run_util import AgentRunner from astrbot.core.astr_agent_tool_exec import FunctionToolExecutor from astrbot.core.astr_main_agent_resources import ( - ANNOTATE_EXECUTION_TOOL, - BROWSER_BATCH_EXEC_TOOL, - BROWSER_EXEC_TOOL, CHATUI_SPECIAL_DEFAULT_PERSONA_PROMPT, - CREATE_SKILL_CANDIDATE_TOOL, - CREATE_SKILL_PAYLOAD_TOOL, - EVALUATE_SKILL_CANDIDATE_TOOL, - EXECUTE_SHELL_TOOL, - FILE_DOWNLOAD_TOOL, - FILE_EDIT_TOOL, - FILE_UPLOAD_TOOL, - FILE_WRITE_TOOL, - GET_EXECUTION_HISTORY_TOOL, - GET_SKILL_PAYLOAD_TOOL, - GREP_TOOL, - LIST_SKILL_CANDIDATES_TOOL, - LIST_SKILL_RELEASES_TOOL, LIVE_MODE_SYSTEM_PROMPT, LLM_SAFETY_MODE_SYSTEM_PROMPT, - LOCAL_EXECUTE_SHELL_TOOL, - LOCAL_PYTHON_TOOL, - PROMOTE_SKILL_CANDIDATE_TOOL, - PYTHON_TOOL, - READ_FILE_TOOL, - ROLLBACK_SKILL_RELEASE_TOOL, - RUN_BROWSER_SKILL_TOOL, SANDBOX_MODE_PROMPT, - SYNC_SKILL_RELEASE_TOOL, TOOL_CALL_PROMPT, TOOL_CALL_PROMPT_SKILLS_LIKE_MODE, ) @@ -63,6 +39,31 @@ from astrbot.core.skills.skill_manager import SkillManager, build_skills_prompt from astrbot.core.star.context import Context from astrbot.core.star.star_handler import star_map +from astrbot.core.tools.computer_tools import ( + AnnotateExecutionTool, + BrowserBatchExecTool, + BrowserExecTool, + CreateSkillCandidateTool, + CreateSkillPayloadTool, + EvaluateSkillCandidateTool, + ExecuteShellTool, + FileDownloadTool, + FileEditTool, + FileReadTool, + FileUploadTool, + FileWriteTool, + GetExecutionHistoryTool, + GetSkillPayloadTool, + GrepTool, + ListSkillCandidatesTool, + ListSkillReleasesTool, + LocalPythonTool, + PromoteSkillCandidateTool, + PythonTool, + RollbackSkillReleaseTool, + RunBrowserSkillTool, + SyncSkillReleaseTool, +) from astrbot.core.tools.cron_tools import ( CreateActiveCronTool, DeleteCronJobTool, @@ -299,15 +300,16 @@ def _apply_prompt_prefix(req: ProviderRequest, cfg: dict) -> None: req.prompt = f"{prefix}{req.prompt}" -def _apply_local_env_tools(req: ProviderRequest) -> None: +def _apply_local_env_tools(req: ProviderRequest, plugin_context: Context) -> None: if req.func_tool is None: req.func_tool = ToolSet() - req.func_tool.add_tool(LOCAL_EXECUTE_SHELL_TOOL) - req.func_tool.add_tool(LOCAL_PYTHON_TOOL) - req.func_tool.add_tool(READ_FILE_TOOL) - req.func_tool.add_tool(FILE_WRITE_TOOL) - req.func_tool.add_tool(FILE_EDIT_TOOL) - req.func_tool.add_tool(GREP_TOOL) + tool_mgr = plugin_context.get_llm_tool_manager() + req.func_tool.add_tool(tool_mgr.get_builtin_tool(ExecuteShellTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(LocalPythonTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(FileReadTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(FileWriteTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(FileEditTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(GrepTool)) req.system_prompt = f"{req.system_prompt or ''}\n{_build_local_mode_prompt()}\n" @@ -994,7 +996,10 @@ def _apply_llm_safety_mode(config: MainAgentBuildConfig, req: ProviderRequest) - def _apply_sandbox_tools( - config: MainAgentBuildConfig, req: ProviderRequest, session_id: str + config: MainAgentBuildConfig, + req: ProviderRequest, + session_id: str, + plugin_context: Context, ) -> None: if req.func_tool is None: req.func_tool = ToolSet() @@ -1010,14 +1015,15 @@ def _apply_sandbox_tools( os.environ["SHIPYARD_ENDPOINT"] = ep os.environ["SHIPYARD_ACCESS_TOKEN"] = at - req.func_tool.add_tool(EXECUTE_SHELL_TOOL) - req.func_tool.add_tool(PYTHON_TOOL) - req.func_tool.add_tool(FILE_UPLOAD_TOOL) - req.func_tool.add_tool(FILE_DOWNLOAD_TOOL) - req.func_tool.add_tool(READ_FILE_TOOL) - req.func_tool.add_tool(FILE_WRITE_TOOL) - req.func_tool.add_tool(FILE_EDIT_TOOL) - req.func_tool.add_tool(GREP_TOOL) + tool_mgr = plugin_context.get_llm_tool_manager() + req.func_tool.add_tool(tool_mgr.get_builtin_tool(ExecuteShellTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(PythonTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(FileUploadTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(FileDownloadTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(FileReadTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(FileWriteTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(FileEditTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(GrepTool)) if booter == "shipyard_neo": # Neo-specific path rule: filesystem tools operate relative to sandbox # workspace root. Do not prepend "/workspace". @@ -1053,22 +1059,22 @@ def _apply_sandbox_tools( # Browser tools: only register if profile supports browser # (or if capabilities are unknown because sandbox hasn't booted yet) if sandbox_capabilities is None or "browser" in sandbox_capabilities: - req.func_tool.add_tool(BROWSER_EXEC_TOOL) - req.func_tool.add_tool(BROWSER_BATCH_EXEC_TOOL) - req.func_tool.add_tool(RUN_BROWSER_SKILL_TOOL) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(BrowserExecTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(BrowserBatchExecTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(RunBrowserSkillTool)) # Neo-specific tools (always available for shipyard_neo) - req.func_tool.add_tool(GET_EXECUTION_HISTORY_TOOL) - req.func_tool.add_tool(ANNOTATE_EXECUTION_TOOL) - req.func_tool.add_tool(CREATE_SKILL_PAYLOAD_TOOL) - req.func_tool.add_tool(GET_SKILL_PAYLOAD_TOOL) - req.func_tool.add_tool(CREATE_SKILL_CANDIDATE_TOOL) - req.func_tool.add_tool(LIST_SKILL_CANDIDATES_TOOL) - req.func_tool.add_tool(EVALUATE_SKILL_CANDIDATE_TOOL) - req.func_tool.add_tool(PROMOTE_SKILL_CANDIDATE_TOOL) - req.func_tool.add_tool(LIST_SKILL_RELEASES_TOOL) - req.func_tool.add_tool(ROLLBACK_SKILL_RELEASE_TOOL) - req.func_tool.add_tool(SYNC_SKILL_RELEASE_TOOL) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(GetExecutionHistoryTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(AnnotateExecutionTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(CreateSkillPayloadTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(GetSkillPayloadTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(CreateSkillCandidateTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(ListSkillCandidatesTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(EvaluateSkillCandidateTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(PromoteSkillCandidateTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(ListSkillReleasesTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(RollbackSkillReleaseTool)) + req.func_tool.add_tool(tool_mgr.get_builtin_tool(SyncSkillReleaseTool)) req.system_prompt = f"{req.system_prompt or ''}\n{SANDBOX_MODE_PROMPT}\n" @@ -1358,9 +1364,9 @@ async def build_main_agent( _apply_llm_safety_mode(config, req) if config.computer_use_runtime == "sandbox": - _apply_sandbox_tools(config, req, req.session_id) + _apply_sandbox_tools(config, req, req.session_id, plugin_context) elif config.computer_use_runtime == "local": - _apply_local_env_tools(req) + _apply_local_env_tools(req, plugin_context) agent_runner = AgentRunner() astr_agent_ctx = AstrAgentContext( @@ -1398,7 +1404,9 @@ async def build_main_agent( ) if config.computer_use_runtime == "local": - from astrbot.core.computer.tools.fs import _normalize_umo_for_workspace + from astrbot.core.tools.computer_tools.fs import ( + _normalize_umo_for_workspace, + ) normalized_umo = _normalize_umo_for_workspace(event.unified_msg_origin) tool_prompt += ( diff --git a/astrbot/core/astr_main_agent_resources.py b/astrbot/core/astr_main_agent_resources.py index 442b91e165..821ece702c 100644 --- a/astrbot/core/astr_main_agent_resources.py +++ b/astrbot/core/astr_main_agent_resources.py @@ -1,31 +1,5 @@ import base64 -from astrbot.core.computer.tools import ( - AnnotateExecutionTool, - BrowserBatchExecTool, - BrowserExecTool, - CreateSkillCandidateTool, - CreateSkillPayloadTool, - EvaluateSkillCandidateTool, - ExecuteShellTool, - FileDownloadTool, - FileEditTool, - FileReadTool, - FileUploadTool, - FileWriteTool, - GetExecutionHistoryTool, - GetSkillPayloadTool, - GrepTool, - ListSkillCandidatesTool, - ListSkillReleasesTool, - LocalPythonTool, - PromoteSkillCandidateTool, - PythonTool, - RollbackSkillReleaseTool, - RunBrowserSkillTool, - SyncSkillReleaseTool, -) - LLM_SAFETY_MODE_SYSTEM_PROMPT = """You are running in Safe Mode. Rules: @@ -134,32 +108,6 @@ "{background_task_result}" ) - -EXECUTE_SHELL_TOOL = ExecuteShellTool() -LOCAL_EXECUTE_SHELL_TOOL = ExecuteShellTool(is_local=True) -PYTHON_TOOL = PythonTool() -LOCAL_PYTHON_TOOL = LocalPythonTool() -FILE_UPLOAD_TOOL = FileUploadTool() -FILE_DOWNLOAD_TOOL = FileDownloadTool() -READ_FILE_TOOL = FileReadTool() -FILE_WRITE_TOOL = FileWriteTool() -FILE_EDIT_TOOL = FileEditTool() -GREP_TOOL = GrepTool() -BROWSER_EXEC_TOOL = BrowserExecTool() -BROWSER_BATCH_EXEC_TOOL = BrowserBatchExecTool() -RUN_BROWSER_SKILL_TOOL = RunBrowserSkillTool() -GET_EXECUTION_HISTORY_TOOL = GetExecutionHistoryTool() -ANNOTATE_EXECUTION_TOOL = AnnotateExecutionTool() -CREATE_SKILL_PAYLOAD_TOOL = CreateSkillPayloadTool() -GET_SKILL_PAYLOAD_TOOL = GetSkillPayloadTool() -CREATE_SKILL_CANDIDATE_TOOL = CreateSkillCandidateTool() -LIST_SKILL_CANDIDATES_TOOL = ListSkillCandidatesTool() -EVALUATE_SKILL_CANDIDATE_TOOL = EvaluateSkillCandidateTool() -PROMOTE_SKILL_CANDIDATE_TOOL = PromoteSkillCandidateTool() -LIST_SKILL_RELEASES_TOOL = ListSkillReleasesTool() -ROLLBACK_SKILL_RELEASE_TOOL = RollbackSkillReleaseTool() -SYNC_SKILL_RELEASE_TOOL = SyncSkillReleaseTool() - # we prevent astrbot from connecting to known malicious hosts # these hosts are base64 encoded BLOCKED = {"dGZid2h2d3IuY2xvdWQuc2VhbG9zLmlv", "a291cmljaGF0"} diff --git a/astrbot/core/computer/tools/__init__.py b/astrbot/core/tools/computer_tools/__init__.py similarity index 82% rename from astrbot/core/computer/tools/__init__.py rename to astrbot/core/tools/computer_tools/__init__.py index ec34388e1d..a147ccbcd0 100644 --- a/astrbot/core/computer/tools/__init__.py +++ b/astrbot/core/tools/computer_tools/__init__.py @@ -1,4 +1,3 @@ -from .browser import BrowserBatchExecTool, BrowserExecTool, RunBrowserSkillTool from .fs import ( FileDownloadTool, FileEditTool, @@ -6,9 +5,15 @@ FileUploadTool, FileWriteTool, GrepTool, + _normalize_umo_for_workspace, ) -from .neo_skills import ( +from .permissions import check_admin_permission +from .python import LocalPythonTool, PythonTool +from .shell import ExecuteShellTool +from .shipyard_neo import ( AnnotateExecutionTool, + BrowserBatchExecTool, + BrowserExecTool, CreateSkillCandidateTool, CreateSkillPayloadTool, EvaluateSkillCandidateTool, @@ -18,33 +23,34 @@ ListSkillReleasesTool, PromoteSkillCandidateTool, RollbackSkillReleaseTool, + RunBrowserSkillTool, SyncSkillReleaseTool, ) -from .python import LocalPythonTool, PythonTool -from .shell import ExecuteShellTool __all__ = [ - "BrowserExecTool", - "BrowserBatchExecTool", - "RunBrowserSkillTool", - "GetExecutionHistoryTool", "AnnotateExecutionTool", - "CreateSkillPayloadTool", - "GetSkillPayloadTool", + "BrowserBatchExecTool", + "BrowserExecTool", "CreateSkillCandidateTool", - "ListSkillCandidatesTool", + "CreateSkillPayloadTool", "EvaluateSkillCandidateTool", - "PromoteSkillCandidateTool", - "ListSkillReleasesTool", - "RollbackSkillReleaseTool", - "SyncSkillReleaseTool", + "ExecuteShellTool", + "FileDownloadTool", + "FileEditTool", + "FileReadTool", "FileUploadTool", "FileWriteTool", - "FileEditTool", + "GetExecutionHistoryTool", + "GetSkillPayloadTool", "GrepTool", - "FileReadTool", - "PythonTool", + "ListSkillCandidatesTool", + "ListSkillReleasesTool", "LocalPythonTool", - "ExecuteShellTool", - "FileDownloadTool", + "PromoteSkillCandidateTool", + "PythonTool", + "RollbackSkillReleaseTool", + "RunBrowserSkillTool", + "SyncSkillReleaseTool", + "_normalize_umo_for_workspace", + "check_admin_permission", ] diff --git a/astrbot/core/computer/tools/fs.py b/astrbot/core/tools/computer_tools/fs.py similarity index 99% rename from astrbot/core/computer/tools/fs.py rename to astrbot/core/tools/computer_tools/fs.py index 7c9c68e401..b23296bdb0 100644 --- a/astrbot/core/computer/tools/fs.py +++ b/astrbot/core/tools/computer_tools/fs.py @@ -42,6 +42,7 @@ from astrbot.core.agent.run_context import ContextWrapper from astrbot.core.agent.tool import ToolExecResult from astrbot.core.astr_agent_context import AstrAgentContext +from astrbot.core.computer.computer_client import get_booter from astrbot.core.computer.file_read_utils import read_file_tool_result from astrbot.core.message.components import File from astrbot.core.utils.astrbot_path import ( @@ -50,7 +51,7 @@ get_astrbot_workspaces_path, ) -from ..computer_client import get_booter +from ..registry import builtin_tool from .permissions import check_admin_permission @@ -162,6 +163,7 @@ def _decode_escaped_text(value: str) -> str: ) +@builtin_tool @dataclass class FileReadTool(FunctionTool): name: str = "astrbot_file_read_tool" @@ -241,6 +243,7 @@ async def call( return f"Error reading file: {exc}" +@builtin_tool @dataclass class FileWriteTool(FunctionTool): name: str = "astrbot_file_write_tool" @@ -307,6 +310,7 @@ async def call( return f"Error writing file: {exc}" +@builtin_tool @dataclass class FileEditTool(FunctionTool): name: str = "astrbot_file_edit_tool" @@ -392,6 +396,7 @@ async def call( return f"Error editing file: {exc}" +@builtin_tool @dataclass class GrepTool(FunctionTool): name: str = "astrbot_grep_tool" @@ -597,6 +602,7 @@ async def call( return f"Error searching files: {exc}" +@builtin_tool @dataclass class FileUploadTool(FunctionTool): name: str = "astrbot_upload_file" @@ -662,6 +668,7 @@ async def call( return f"Error uploading file: {str(e)}" +@builtin_tool @dataclass class FileDownloadTool(FunctionTool): name: str = "astrbot_download_file" diff --git a/astrbot/core/computer/tools/permissions.py b/astrbot/core/tools/computer_tools/permissions.py similarity index 100% rename from astrbot/core/computer/tools/permissions.py rename to astrbot/core/tools/computer_tools/permissions.py diff --git a/astrbot/core/computer/tools/python.py b/astrbot/core/tools/computer_tools/python.py similarity index 96% rename from astrbot/core/computer/tools/python.py rename to astrbot/core/tools/computer_tools/python.py index bf9aaa14e5..148beb7c51 100644 --- a/astrbot/core/computer/tools/python.py +++ b/astrbot/core/tools/computer_tools/python.py @@ -8,9 +8,11 @@ from astrbot.core.agent.tool import ToolExecResult from astrbot.core.astr_agent_context import AstrAgentContext, AstrMessageEvent from astrbot.core.computer.computer_client import get_booter, get_local_booter -from astrbot.core.computer.tools.permissions import check_admin_permission from astrbot.core.message.message_event_result import MessageChain +from ..registry import builtin_tool +from .permissions import check_admin_permission + _OS_NAME = platform.system() param_schema = { @@ -61,6 +63,7 @@ async def handle_result(result: dict, event: AstrMessageEvent) -> ToolExecResult return resp +@builtin_tool @dataclass class PythonTool(FunctionTool): name: str = "astrbot_execute_ipython" @@ -83,6 +86,7 @@ async def call( return f"Error executing code: {str(e)}" +@builtin_tool @dataclass class LocalPythonTool(FunctionTool): name: str = "astrbot_execute_python" diff --git a/astrbot/core/computer/tools/shell.py b/astrbot/core/tools/computer_tools/shell.py similarity index 86% rename from astrbot/core/computer/tools/shell.py rename to astrbot/core/tools/computer_tools/shell.py index b5009d30fd..0c23dae43f 100644 --- a/astrbot/core/computer/tools/shell.py +++ b/astrbot/core/tools/computer_tools/shell.py @@ -5,11 +5,13 @@ from astrbot.core.agent.run_context import ContextWrapper from astrbot.core.agent.tool import ToolExecResult from astrbot.core.astr_agent_context import AstrAgentContext +from astrbot.core.computer.computer_client import get_booter -from ..computer_client import get_booter, get_local_booter +from ..registry import builtin_tool from .permissions import check_admin_permission +@builtin_tool @dataclass class ExecuteShellTool(FunctionTool): name: str = "astrbot_execute_shell" @@ -38,8 +40,6 @@ class ExecuteShellTool(FunctionTool): } ) - is_local: bool = False - async def call( self, context: ContextWrapper[AstrAgentContext], @@ -50,13 +50,10 @@ async def call( if permission_error := check_admin_permission(context, "Shell execution"): return permission_error - if self.is_local: - sb = get_local_booter() - else: - sb = await get_booter( - context.context.context, - context.context.event.unified_msg_origin, - ) + sb = await get_booter( + context.context.context, + context.context.event.unified_msg_origin, + ) try: result = await sb.shell.exec(command, background=background, env=env) return json.dumps(result) diff --git a/astrbot/core/tools/computer_tools/shipyard_neo/__init__.py b/astrbot/core/tools/computer_tools/shipyard_neo/__init__.py new file mode 100644 index 0000000000..9228c86354 --- /dev/null +++ b/astrbot/core/tools/computer_tools/shipyard_neo/__init__.py @@ -0,0 +1,31 @@ +from .browser import BrowserBatchExecTool, BrowserExecTool, RunBrowserSkillTool +from .neo_skills import ( + AnnotateExecutionTool, + CreateSkillCandidateTool, + CreateSkillPayloadTool, + EvaluateSkillCandidateTool, + GetExecutionHistoryTool, + GetSkillPayloadTool, + ListSkillCandidatesTool, + ListSkillReleasesTool, + PromoteSkillCandidateTool, + RollbackSkillReleaseTool, + SyncSkillReleaseTool, +) + +__all__ = [ + "AnnotateExecutionTool", + "BrowserBatchExecTool", + "BrowserExecTool", + "CreateSkillCandidateTool", + "CreateSkillPayloadTool", + "EvaluateSkillCandidateTool", + "GetExecutionHistoryTool", + "GetSkillPayloadTool", + "ListSkillCandidatesTool", + "ListSkillReleasesTool", + "PromoteSkillCandidateTool", + "RollbackSkillReleaseTool", + "RunBrowserSkillTool", + "SyncSkillReleaseTool", +] diff --git a/astrbot/core/computer/tools/browser.py b/astrbot/core/tools/computer_tools/shipyard_neo/browser.py similarity index 96% rename from astrbot/core/computer/tools/browser.py rename to astrbot/core/tools/computer_tools/shipyard_neo/browser.py index cd8484acb6..f3cfb3449c 100644 --- a/astrbot/core/computer/tools/browser.py +++ b/astrbot/core/tools/computer_tools/shipyard_neo/browser.py @@ -6,9 +6,9 @@ from astrbot.core.agent.run_context import ContextWrapper from astrbot.core.agent.tool import ToolExecResult from astrbot.core.astr_agent_context import AstrAgentContext - -from ..computer_client import get_booter -from .permissions import check_admin_permission +from astrbot.core.computer.computer_client import get_booter +from astrbot.core.tools.computer_tools.permissions import check_admin_permission +from astrbot.core.tools.registry import builtin_tool def _to_json(data: Any) -> str: @@ -29,6 +29,7 @@ async def _get_browser_component(context: ContextWrapper[AstrAgentContext]) -> A return browser +@builtin_tool @dataclass class BrowserExecTool(FunctionTool): name: str = "astrbot_execute_browser" @@ -86,6 +87,7 @@ async def call( return f"Error executing browser command: {str(e)}" +@builtin_tool @dataclass class BrowserBatchExecTool(FunctionTool): name: str = "astrbot_execute_browser_batch" @@ -150,6 +152,7 @@ async def call( return f"Error executing browser batch command: {str(e)}" +@builtin_tool @dataclass class RunBrowserSkillTool(FunctionTool): name: str = "astrbot_run_browser_skill" diff --git a/astrbot/core/computer/tools/neo_skills.py b/astrbot/core/tools/computer_tools/shipyard_neo/neo_skills.py similarity index 98% rename from astrbot/core/computer/tools/neo_skills.py rename to astrbot/core/tools/computer_tools/shipyard_neo/neo_skills.py index 327f144722..03ba1c4a4b 100644 --- a/astrbot/core/computer/tools/neo_skills.py +++ b/astrbot/core/tools/computer_tools/shipyard_neo/neo_skills.py @@ -7,10 +7,10 @@ from astrbot.core.agent.run_context import ContextWrapper from astrbot.core.agent.tool import ToolExecResult from astrbot.core.astr_agent_context import AstrAgentContext +from astrbot.core.computer.computer_client import get_booter from astrbot.core.skills.neo_skill_sync import NeoSkillSyncManager - -from ..computer_client import get_booter -from .permissions import check_admin_permission +from astrbot.core.tools.computer_tools.permissions import check_admin_permission +from astrbot.core.tools.registry import builtin_tool def _to_jsonable(model_like: Any) -> Any: @@ -64,6 +64,7 @@ async def _run( return f"{self.error_prefix} {error_action}: {str(e)}" +@builtin_tool @dataclass class GetExecutionHistoryTool(NeoSkillToolBase): name: str = "astrbot_get_execution_history" @@ -110,6 +111,7 @@ async def call( ) +@builtin_tool @dataclass class AnnotateExecutionTool(NeoSkillToolBase): name: str = "astrbot_annotate_execution" @@ -147,6 +149,7 @@ async def call( ) +@builtin_tool @dataclass class CreateSkillPayloadTool(NeoSkillToolBase): name: str = "astrbot_create_skill_payload" @@ -194,6 +197,7 @@ async def call( ) +@builtin_tool @dataclass class GetSkillPayloadTool(NeoSkillToolBase): name: str = "astrbot_get_skill_payload" @@ -220,6 +224,7 @@ async def call( ) +@builtin_tool @dataclass class CreateSkillCandidateTool(NeoSkillToolBase): name: str = "astrbot_create_skill_candidate" @@ -273,6 +278,7 @@ async def call( ) +@builtin_tool @dataclass class ListSkillCandidatesTool(NeoSkillToolBase): name: str = "astrbot_list_skill_candidates" @@ -310,6 +316,7 @@ async def call( ) +@builtin_tool @dataclass class EvaluateSkillCandidateTool(NeoSkillToolBase): name: str = "astrbot_evaluate_skill_candidate" @@ -350,6 +357,7 @@ async def call( ) +@builtin_tool @dataclass class PromoteSkillCandidateTool(NeoSkillToolBase): name: str = "astrbot_promote_skill_candidate" @@ -420,6 +428,7 @@ async def call( return f"Error promoting skill candidate: {str(e)}" +@builtin_tool @dataclass class ListSkillReleasesTool(NeoSkillToolBase): name: str = "astrbot_list_skill_releases" @@ -460,6 +469,7 @@ async def call( ) +@builtin_tool @dataclass class RollbackSkillReleaseTool(NeoSkillToolBase): name: str = "astrbot_rollback_skill_release" @@ -486,6 +496,7 @@ async def call( ) +@builtin_tool @dataclass class SyncSkillReleaseTool(NeoSkillToolBase): name: str = "astrbot_sync_skill_release" diff --git a/astrbot/core/tools/registry.py b/astrbot/core/tools/registry.py index eaca4af144..4a1fa8d669 100644 --- a/astrbot/core/tools/registry.py +++ b/astrbot/core/tools/registry.py @@ -8,6 +8,7 @@ TFunctionTool = TypeVar("TFunctionTool", bound=type[FunctionTool]) _BUILTIN_TOOL_MODULES = ( + "astrbot.core.tools.computer_tools", "astrbot.core.tools.cron_tools", "astrbot.core.tools.knowledge_base_tools", "astrbot.core.tools.message_tools", diff --git a/tests/test_computer_fs_tools.py b/tests/test_computer_fs_tools.py index a75bfdaadc..6e718dfbd6 100644 --- a/tests/test_computer_fs_tools.py +++ b/tests/test_computer_fs_tools.py @@ -11,7 +11,7 @@ from astrbot.core.agent.run_context import ContextWrapper from astrbot.core.computer import file_read_utils from astrbot.core.computer.booters.local import LocalBooter -from astrbot.core.computer.tools import fs as fs_tools +from astrbot.core.tools.computer_tools import fs as fs_tools def _make_context( diff --git a/tests/test_computer_tool_permissions.py b/tests/test_computer_tool_permissions.py index 669cd6b8a7..07f7983da3 100644 --- a/tests/test_computer_tool_permissions.py +++ b/tests/test_computer_tool_permissions.py @@ -4,8 +4,10 @@ import pytest from astrbot.core.agent.run_context import ContextWrapper -from astrbot.core.computer.tools.browser import BrowserExecTool -from astrbot.core.computer.tools.neo_skills import GetExecutionHistoryTool +from astrbot.core.tools.computer_tools.shipyard_neo.browser import BrowserExecTool +from astrbot.core.tools.computer_tools.shipyard_neo.neo_skills import ( + GetExecutionHistoryTool, +) class _FakeBrowser: @@ -49,7 +51,7 @@ async def _fake_get_booter(_ctx, _session_id): return SimpleNamespace(browser=_FakeBrowser()) monkeypatch.setattr( - "astrbot.core.computer.tools.browser.get_booter", + "astrbot.core.tools.computer_tools.shipyard_neo.browser.get_booter", _fake_get_booter, ) @@ -72,7 +74,7 @@ async def _fake_get_booter(_ctx, _session_id): ) monkeypatch.setattr( - "astrbot.core.computer.tools.neo_skills.get_booter", + "astrbot.core.tools.computer_tools.shipyard_neo.neo_skills.get_booter", _fake_get_booter, ) diff --git a/tests/test_neo_skill_tools.py b/tests/test_neo_skill_tools.py index 218ada57bd..076da00945 100644 --- a/tests/test_neo_skill_tools.py +++ b/tests/test_neo_skill_tools.py @@ -4,7 +4,9 @@ from types import SimpleNamespace from astrbot.core.agent.run_context import ContextWrapper -from astrbot.core.computer.tools.neo_skills import PromoteSkillCandidateTool +from astrbot.core.tools.computer_tools.shipyard_neo.neo_skills import ( + PromoteSkillCandidateTool, +) class _FakeSkills: @@ -46,11 +48,11 @@ async def _fake_sync_release(self, client, **kwargs): raise ValueError("sync failed") monkeypatch.setattr( - "astrbot.core.computer.tools.neo_skills.get_booter", + "astrbot.core.tools.computer_tools.shipyard_neo.neo_skills.get_booter", _fake_get_booter, ) monkeypatch.setattr( - "astrbot.core.computer.tools.neo_skills.NeoSkillSyncManager.sync_release", + "astrbot.core.tools.computer_tools.shipyard_neo.neo_skills.NeoSkillSyncManager.sync_release", _fake_sync_release, ) diff --git a/tests/unit/test_astr_main_agent.py b/tests/unit/test_astr_main_agent.py index 4619bb065f..631cc28326 100644 --- a/tests/unit/test_astr_main_agent.py +++ b/tests/unit/test_astr_main_agent.py @@ -40,7 +40,9 @@ def mock_context(): return_value=(None, None, None, False) ) ctx.persona_manager.get_persona_v3_by_id = MagicMock(return_value=None) - ctx.get_llm_tool_manager.return_value = MagicMock() + tool_mgr = MagicMock() + tool_mgr.get_builtin_tool.side_effect = lambda cls, **kwargs: cls(**kwargs) + ctx.get_llm_tool_manager.return_value = tool_mgr ctx.subagent_orchestrator = None return ctx @@ -621,9 +623,10 @@ async def test_subagent_dedupe_uses_default_persona_tools( tmgr = mock_context.get_llm_tool_manager.return_value tmgr.func_list = [tool_a, tool_b] tmgr.get_full_tool_set.return_value = ToolSet([tool_a, tool_b]) - tmgr.get_func.side_effect = lambda name: {"tool_a": tool_a, "tool_b": tool_b}.get( - name - ) + tmgr.get_func.side_effect = lambda name: { + "tool_a": tool_a, + "tool_b": tool_b, + }.get(name) handoff = MagicMock() handoff.name = "transfer_to_planner" @@ -1488,7 +1491,7 @@ def test_apply_llm_safety_mode_empty_system_prompt(self): class TestApplySandboxTools: """Tests for _apply_sandbox_tools function.""" - def test_apply_sandbox_tools_creates_toolset_if_none(self): + def test_apply_sandbox_tools_creates_toolset_if_none(self, mock_context): """Test that ToolSet is created when func_tool is None.""" module = ama config = module.MainAgentBuildConfig( @@ -1498,12 +1501,12 @@ def test_apply_sandbox_tools_creates_toolset_if_none(self): ) req = ProviderRequest(prompt="Test", func_tool=None) - module._apply_sandbox_tools(config, req, "session-123") + module._apply_sandbox_tools(config, req, "session-123", mock_context) assert req.func_tool is not None assert isinstance(req.func_tool, ToolSet) - def test_apply_sandbox_tools_adds_required_tools(self): + def test_apply_sandbox_tools_adds_required_tools(self, mock_context): """Test that all required sandbox tools are added.""" module = ama config = module.MainAgentBuildConfig( @@ -1513,7 +1516,7 @@ def test_apply_sandbox_tools_adds_required_tools(self): ) req = ProviderRequest(prompt="Test", func_tool=None) - module._apply_sandbox_tools(config, req, "session-123") + module._apply_sandbox_tools(config, req, "session-123", mock_context) tool_names = req.func_tool.names() assert "astrbot_execute_shell" in tool_names @@ -1521,7 +1524,7 @@ def test_apply_sandbox_tools_adds_required_tools(self): assert "astrbot_upload_file" in tool_names assert "astrbot_download_file" in tool_names - def test_apply_sandbox_tools_adds_sandbox_prompt(self): + def test_apply_sandbox_tools_adds_sandbox_prompt(self, mock_context): """Test that sandbox mode prompt is added to system_prompt.""" module = ama config = module.MainAgentBuildConfig( @@ -1531,11 +1534,11 @@ def test_apply_sandbox_tools_adds_sandbox_prompt(self): ) req = ProviderRequest(prompt="Test", system_prompt="Original prompt") - module._apply_sandbox_tools(config, req, "session-123") + module._apply_sandbox_tools(config, req, "session-123", mock_context) assert "sandboxed environment" in req.system_prompt - def test_apply_sandbox_tools_with_shipyard_booter(self, monkeypatch): + def test_apply_sandbox_tools_with_shipyard_booter(self, monkeypatch, mock_context): """Test sandbox tools with shipyard booter configuration.""" module = ama config = module.MainAgentBuildConfig( @@ -1552,12 +1555,12 @@ def test_apply_sandbox_tools_with_shipyard_booter(self, monkeypatch): monkeypatch.delenv("SHIPYARD_ENDPOINT", raising=False) monkeypatch.delenv("SHIPYARD_ACCESS_TOKEN", raising=False) - module._apply_sandbox_tools(config, req, "session-123") + module._apply_sandbox_tools(config, req, "session-123", mock_context) assert os.environ.get("SHIPYARD_ENDPOINT") == "https://shipyard.example.com" assert os.environ.get("SHIPYARD_ACCESS_TOKEN") == "test-token" - def test_apply_sandbox_tools_shipyard_missing_endpoint(self): + def test_apply_sandbox_tools_shipyard_missing_endpoint(self, mock_context): """Test that shipyard config is skipped when endpoint is missing.""" module = ama config = module.MainAgentBuildConfig( @@ -1572,7 +1575,7 @@ def test_apply_sandbox_tools_shipyard_missing_endpoint(self): req = ProviderRequest(prompt="Test", func_tool=None) with patch("astrbot.core.astr_main_agent.logger") as mock_logger: - module._apply_sandbox_tools(config, req, "session-123") + module._apply_sandbox_tools(config, req, "session-123", mock_context) mock_logger.error.assert_called_once() assert ( @@ -1580,7 +1583,7 @@ def test_apply_sandbox_tools_shipyard_missing_endpoint(self): in mock_logger.error.call_args[0][0] ) - def test_apply_sandbox_tools_shipyard_missing_access_token(self): + def test_apply_sandbox_tools_shipyard_missing_access_token(self, mock_context): """Test that shipyard config is skipped when access token is missing.""" module = ama config = module.MainAgentBuildConfig( @@ -1595,11 +1598,11 @@ def test_apply_sandbox_tools_shipyard_missing_access_token(self): req = ProviderRequest(prompt="Test", func_tool=None) with patch("astrbot.core.astr_main_agent.logger") as mock_logger: - module._apply_sandbox_tools(config, req, "session-123") + module._apply_sandbox_tools(config, req, "session-123", mock_context) mock_logger.error.assert_called_once() - def test_apply_sandbox_tools_preserves_existing_toolset(self): + def test_apply_sandbox_tools_preserves_existing_toolset(self, mock_context): """Test that existing tools are preserved when adding sandbox tools.""" module = ama config = module.MainAgentBuildConfig( @@ -1613,12 +1616,12 @@ def test_apply_sandbox_tools_preserves_existing_toolset(self): existing_toolset.add_tool(existing_tool) req = ProviderRequest(prompt="Test", func_tool=existing_toolset) - module._apply_sandbox_tools(config, req, "session-123") + module._apply_sandbox_tools(config, req, "session-123", mock_context) assert "existing_tool" in req.func_tool.names() assert "astrbot_execute_shell" in req.func_tool.names() - def test_apply_sandbox_tools_appends_to_existing_system_prompt(self): + def test_apply_sandbox_tools_appends_to_existing_system_prompt(self, mock_context): """Test that sandbox prompt is appended to existing system prompt.""" module = ama config = module.MainAgentBuildConfig( @@ -1628,12 +1631,12 @@ def test_apply_sandbox_tools_appends_to_existing_system_prompt(self): ) req = ProviderRequest(prompt="Test", system_prompt="Base prompt") - module._apply_sandbox_tools(config, req, "session-123") + module._apply_sandbox_tools(config, req, "session-123", mock_context) assert req.system_prompt.startswith("Base prompt") assert "sandboxed environment" in req.system_prompt - def test_apply_sandbox_tools_with_none_system_prompt(self): + def test_apply_sandbox_tools_with_none_system_prompt(self, mock_context): """Test that sandbox prompt is applied when system_prompt is None.""" module = ama config = module.MainAgentBuildConfig( @@ -1643,7 +1646,7 @@ def test_apply_sandbox_tools_with_none_system_prompt(self): ) req = ProviderRequest(prompt="Test", system_prompt=None) - module._apply_sandbox_tools(config, req, "session-123") + module._apply_sandbox_tools(config, req, "session-123", mock_context) assert isinstance(req.system_prompt, str) assert "sandboxed environment" in req.system_prompt diff --git a/tests/unit/test_func_tool_manager.py b/tests/unit/test_func_tool_manager.py index 3c03e618f5..908810cdb3 100644 --- a/tests/unit/test_func_tool_manager.py +++ b/tests/unit/test_func_tool_manager.py @@ -1,5 +1,6 @@ from astrbot.core import sp from astrbot.core.provider.func_tool_manager import FunctionToolManager +from astrbot.core.tools.computer_tools.shell import ExecuteShellTool from astrbot.core.tools.message_tools import SendMessageToUserTool @@ -12,3 +13,28 @@ def test_get_builtin_tool_by_class_returns_cached_instance(): assert tool_by_class is tool_by_name assert manager.get_func("send_message_to_user") is tool_by_class assert tool_by_class.name == "send_message_to_user" + + +def test_builtin_tool_ignores_inactivated_llm_tools(): + manager = FunctionToolManager() + sp.put( + "inactivated_llm_tools", + ["send_message_to_user"], + scope="global", + scope_id="global", + ) + + try: + tool = manager.get_builtin_tool(SendMessageToUserTool) + assert tool.active is True + finally: + sp.put("inactivated_llm_tools", [], scope="global", scope_id="global") + + +def test_computer_tools_are_registered_as_builtin_tools(): + manager = FunctionToolManager() + + tool = manager.get_builtin_tool(ExecuteShellTool) + + assert tool.name == "astrbot_execute_shell" + assert manager.is_builtin_tool("astrbot_execute_shell") is True diff --git a/tests/unit/test_python_tools.py b/tests/unit/test_python_tools.py index 2aae65d2a9..deabc0db34 100644 --- a/tests/unit/test_python_tools.py +++ b/tests/unit/test_python_tools.py @@ -1,5 +1,7 @@ import platform -from astrbot.core.computer.tools.python import PythonTool, LocalPythonTool + +from astrbot.core.tools.computer_tools.python import LocalPythonTool, PythonTool + def test_python_tool_description_contains_os(): """测试 PythonTool 的描述中是否包含当前操作系统信息""" @@ -8,6 +10,7 @@ def test_python_tool_description_contains_os(): assert current_os in tool.description assert "IPython" in tool.description + def test_local_python_tool_description_contains_os(): """测试 LocalPythonTool 的描述中是否包含当前操作系统信息和兼容性提示""" tool = LocalPythonTool() From efc93a37b14d394c4c633266771553a9b0b68785 Mon Sep 17 00:00:00 2001 From: Soulter <905617992@qq.com> Date: Wed, 8 Apr 2026 15:34:18 +0800 Subject: [PATCH 08/20] refactor: remove unused plugin_context parameter from _apply_sandbox_tools --- astrbot/core/astr_main_agent.py | 6 +++--- tests/unit/test_astr_main_agent.py | 18 +++++++++--------- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/astrbot/core/astr_main_agent.py b/astrbot/core/astr_main_agent.py index 55bd4fe8c2..4a9e2637d0 100644 --- a/astrbot/core/astr_main_agent.py +++ b/astrbot/core/astr_main_agent.py @@ -36,6 +36,7 @@ from astrbot.core.platform.astr_message_event import AstrMessageEvent from astrbot.core.provider import Provider from astrbot.core.provider.entities import ProviderRequest +from astrbot.core.provider.register import llm_tools from astrbot.core.skills.skill_manager import SkillManager, build_skills_prompt from astrbot.core.star.context import Context from astrbot.core.star.star_handler import star_map @@ -999,7 +1000,6 @@ def _apply_sandbox_tools( config: MainAgentBuildConfig, req: ProviderRequest, session_id: str, - plugin_context: Context, ) -> None: if req.func_tool is None: req.func_tool = ToolSet() @@ -1015,7 +1015,7 @@ def _apply_sandbox_tools( os.environ["SHIPYARD_ENDPOINT"] = ep os.environ["SHIPYARD_ACCESS_TOKEN"] = at - tool_mgr = plugin_context.get_llm_tool_manager() + tool_mgr = llm_tools req.func_tool.add_tool(tool_mgr.get_builtin_tool(ExecuteShellTool)) req.func_tool.add_tool(tool_mgr.get_builtin_tool(PythonTool)) req.func_tool.add_tool(tool_mgr.get_builtin_tool(FileUploadTool)) @@ -1364,7 +1364,7 @@ async def build_main_agent( _apply_llm_safety_mode(config, req) if config.computer_use_runtime == "sandbox": - _apply_sandbox_tools(config, req, req.session_id, plugin_context) + _apply_sandbox_tools(config, req, req.session_id) elif config.computer_use_runtime == "local": _apply_local_env_tools(req, plugin_context) diff --git a/tests/unit/test_astr_main_agent.py b/tests/unit/test_astr_main_agent.py index 631cc28326..b5c2924d78 100644 --- a/tests/unit/test_astr_main_agent.py +++ b/tests/unit/test_astr_main_agent.py @@ -1501,7 +1501,7 @@ def test_apply_sandbox_tools_creates_toolset_if_none(self, mock_context): ) req = ProviderRequest(prompt="Test", func_tool=None) - module._apply_sandbox_tools(config, req, "session-123", mock_context) + module._apply_sandbox_tools(config, req, "session-123") assert req.func_tool is not None assert isinstance(req.func_tool, ToolSet) @@ -1516,7 +1516,7 @@ def test_apply_sandbox_tools_adds_required_tools(self, mock_context): ) req = ProviderRequest(prompt="Test", func_tool=None) - module._apply_sandbox_tools(config, req, "session-123", mock_context) + module._apply_sandbox_tools(config, req, "session-123") tool_names = req.func_tool.names() assert "astrbot_execute_shell" in tool_names @@ -1534,7 +1534,7 @@ def test_apply_sandbox_tools_adds_sandbox_prompt(self, mock_context): ) req = ProviderRequest(prompt="Test", system_prompt="Original prompt") - module._apply_sandbox_tools(config, req, "session-123", mock_context) + module._apply_sandbox_tools(config, req, "session-123") assert "sandboxed environment" in req.system_prompt @@ -1555,7 +1555,7 @@ def test_apply_sandbox_tools_with_shipyard_booter(self, monkeypatch, mock_contex monkeypatch.delenv("SHIPYARD_ENDPOINT", raising=False) monkeypatch.delenv("SHIPYARD_ACCESS_TOKEN", raising=False) - module._apply_sandbox_tools(config, req, "session-123", mock_context) + module._apply_sandbox_tools(config, req, "session-123") assert os.environ.get("SHIPYARD_ENDPOINT") == "https://shipyard.example.com" assert os.environ.get("SHIPYARD_ACCESS_TOKEN") == "test-token" @@ -1575,7 +1575,7 @@ def test_apply_sandbox_tools_shipyard_missing_endpoint(self, mock_context): req = ProviderRequest(prompt="Test", func_tool=None) with patch("astrbot.core.astr_main_agent.logger") as mock_logger: - module._apply_sandbox_tools(config, req, "session-123", mock_context) + module._apply_sandbox_tools(config, req, "session-123") mock_logger.error.assert_called_once() assert ( @@ -1598,7 +1598,7 @@ def test_apply_sandbox_tools_shipyard_missing_access_token(self, mock_context): req = ProviderRequest(prompt="Test", func_tool=None) with patch("astrbot.core.astr_main_agent.logger") as mock_logger: - module._apply_sandbox_tools(config, req, "session-123", mock_context) + module._apply_sandbox_tools(config, req, "session-123") mock_logger.error.assert_called_once() @@ -1616,7 +1616,7 @@ def test_apply_sandbox_tools_preserves_existing_toolset(self, mock_context): existing_toolset.add_tool(existing_tool) req = ProviderRequest(prompt="Test", func_tool=existing_toolset) - module._apply_sandbox_tools(config, req, "session-123", mock_context) + module._apply_sandbox_tools(config, req, "session-123") assert "existing_tool" in req.func_tool.names() assert "astrbot_execute_shell" in req.func_tool.names() @@ -1631,7 +1631,7 @@ def test_apply_sandbox_tools_appends_to_existing_system_prompt(self, mock_contex ) req = ProviderRequest(prompt="Test", system_prompt="Base prompt") - module._apply_sandbox_tools(config, req, "session-123", mock_context) + module._apply_sandbox_tools(config, req, "session-123") assert req.system_prompt.startswith("Base prompt") assert "sandboxed environment" in req.system_prompt @@ -1646,7 +1646,7 @@ def test_apply_sandbox_tools_with_none_system_prompt(self, mock_context): ) req = ProviderRequest(prompt="Test", system_prompt=None) - module._apply_sandbox_tools(config, req, "session-123", mock_context) + module._apply_sandbox_tools(config, req, "session-123") assert isinstance(req.system_prompt, str) assert "sandboxed environment" in req.system_prompt From adc01e0c9d3ead1c80b28b2800f791a7d893f3b2 Mon Sep 17 00:00:00 2001 From: Soulter <905617992@qq.com> Date: Thu, 9 Apr 2026 23:49:22 +0800 Subject: [PATCH 09/20] feat: supports to display enabled builtin tools in configs --- astrbot/core/tools/computer_tools/fs.py | 19 +- astrbot/core/tools/computer_tools/python.py | 10 +- astrbot/core/tools/computer_tools/shell.py | 6 +- .../computer_tools/shipyard_neo/browser.py | 11 +- .../computer_tools/shipyard_neo/neo_skills.py | 27 +- astrbot/core/tools/cron_tools.py | 10 +- astrbot/core/tools/knowledge_base_tools.py | 6 +- astrbot/core/tools/registry.py | 268 +++++++++++++++++- astrbot/core/tools/web_search_tools.py | 26 +- astrbot/dashboard/routes/tools.py | 26 ++ .../componentPanel/components/ToolTable.vue | 96 ++++++- .../extension/componentPanel/types.ts | 19 ++ .../i18n/locales/en-US/features/tool-use.json | 9 + .../i18n/locales/ru-RU/features/tool-use.json | 9 + .../i18n/locales/zh-CN/features/tool-use.json | 9 + 15 files changed, 504 insertions(+), 47 deletions(-) diff --git a/astrbot/core/tools/computer_tools/fs.py b/astrbot/core/tools/computer_tools/fs.py index b23296bdb0..8b513913c6 100644 --- a/astrbot/core/tools/computer_tools/fs.py +++ b/astrbot/core/tools/computer_tools/fs.py @@ -54,6 +54,13 @@ from ..registry import builtin_tool from .permissions import check_admin_permission +_COMPUTER_RUNTIME_TOOL_CONFIG = { + "provider_settings.computer_use_runtime": ("local", "sandbox"), +} +_SANDBOX_RUNTIME_TOOL_CONFIG = { + "provider_settings.computer_use_runtime": "sandbox", +} + def _normalize_umo_for_workspace(umo: str) -> str: normalized = re.sub(r"[^A-Za-z0-9._-]+", "_", umo.strip()) @@ -163,7 +170,7 @@ def _decode_escaped_text(value: str) -> str: ) -@builtin_tool +@builtin_tool(config=_COMPUTER_RUNTIME_TOOL_CONFIG) @dataclass class FileReadTool(FunctionTool): name: str = "astrbot_file_read_tool" @@ -243,7 +250,7 @@ async def call( return f"Error reading file: {exc}" -@builtin_tool +@builtin_tool(config=_COMPUTER_RUNTIME_TOOL_CONFIG) @dataclass class FileWriteTool(FunctionTool): name: str = "astrbot_file_write_tool" @@ -310,7 +317,7 @@ async def call( return f"Error writing file: {exc}" -@builtin_tool +@builtin_tool(config=_COMPUTER_RUNTIME_TOOL_CONFIG) @dataclass class FileEditTool(FunctionTool): name: str = "astrbot_file_edit_tool" @@ -396,7 +403,7 @@ async def call( return f"Error editing file: {exc}" -@builtin_tool +@builtin_tool(config=_COMPUTER_RUNTIME_TOOL_CONFIG) @dataclass class GrepTool(FunctionTool): name: str = "astrbot_grep_tool" @@ -602,7 +609,7 @@ async def call( return f"Error searching files: {exc}" -@builtin_tool +@builtin_tool(config=_SANDBOX_RUNTIME_TOOL_CONFIG) @dataclass class FileUploadTool(FunctionTool): name: str = "astrbot_upload_file" @@ -668,7 +675,7 @@ async def call( return f"Error uploading file: {str(e)}" -@builtin_tool +@builtin_tool(config=_SANDBOX_RUNTIME_TOOL_CONFIG) @dataclass class FileDownloadTool(FunctionTool): name: str = "astrbot_download_file" diff --git a/astrbot/core/tools/computer_tools/python.py b/astrbot/core/tools/computer_tools/python.py index 148beb7c51..1be2a6e1b5 100644 --- a/astrbot/core/tools/computer_tools/python.py +++ b/astrbot/core/tools/computer_tools/python.py @@ -14,6 +14,12 @@ from .permissions import check_admin_permission _OS_NAME = platform.system() +_SANDBOX_PYTHON_TOOL_CONFIG = { + "provider_settings.computer_use_runtime": "sandbox", +} +_LOCAL_PYTHON_TOOL_CONFIG = { + "provider_settings.computer_use_runtime": "local", +} param_schema = { "type": "object", @@ -63,7 +69,7 @@ async def handle_result(result: dict, event: AstrMessageEvent) -> ToolExecResult return resp -@builtin_tool +@builtin_tool(config=_SANDBOX_PYTHON_TOOL_CONFIG) @dataclass class PythonTool(FunctionTool): name: str = "astrbot_execute_ipython" @@ -86,7 +92,7 @@ async def call( return f"Error executing code: {str(e)}" -@builtin_tool +@builtin_tool(config=_LOCAL_PYTHON_TOOL_CONFIG) @dataclass class LocalPythonTool(FunctionTool): name: str = "astrbot_execute_python" diff --git a/astrbot/core/tools/computer_tools/shell.py b/astrbot/core/tools/computer_tools/shell.py index 0c23dae43f..98343bc1ca 100644 --- a/astrbot/core/tools/computer_tools/shell.py +++ b/astrbot/core/tools/computer_tools/shell.py @@ -10,8 +10,12 @@ from ..registry import builtin_tool from .permissions import check_admin_permission +_COMPUTER_RUNTIME_TOOL_CONFIG = { + "provider_settings.computer_use_runtime": ("local", "sandbox"), +} -@builtin_tool + +@builtin_tool(config=_COMPUTER_RUNTIME_TOOL_CONFIG) @dataclass class ExecuteShellTool(FunctionTool): name: str = "astrbot_execute_shell" diff --git a/astrbot/core/tools/computer_tools/shipyard_neo/browser.py b/astrbot/core/tools/computer_tools/shipyard_neo/browser.py index f3cfb3449c..72aa6076d1 100644 --- a/astrbot/core/tools/computer_tools/shipyard_neo/browser.py +++ b/astrbot/core/tools/computer_tools/shipyard_neo/browser.py @@ -10,6 +10,11 @@ from astrbot.core.tools.computer_tools.permissions import check_admin_permission from astrbot.core.tools.registry import builtin_tool +_SHIPYARD_NEO_TOOL_CONFIG = { + "provider_settings.computer_use_runtime": "sandbox", + "provider_settings.sandbox.booter": "shipyard_neo", +} + def _to_json(data: Any) -> str: return json.dumps(data, ensure_ascii=False, default=str) @@ -29,7 +34,7 @@ async def _get_browser_component(context: ContextWrapper[AstrAgentContext]) -> A return browser -@builtin_tool +@builtin_tool(config=_SHIPYARD_NEO_TOOL_CONFIG) @dataclass class BrowserExecTool(FunctionTool): name: str = "astrbot_execute_browser" @@ -87,7 +92,7 @@ async def call( return f"Error executing browser command: {str(e)}" -@builtin_tool +@builtin_tool(config=_SHIPYARD_NEO_TOOL_CONFIG) @dataclass class BrowserBatchExecTool(FunctionTool): name: str = "astrbot_execute_browser_batch" @@ -152,7 +157,7 @@ async def call( return f"Error executing browser batch command: {str(e)}" -@builtin_tool +@builtin_tool(config=_SHIPYARD_NEO_TOOL_CONFIG) @dataclass class RunBrowserSkillTool(FunctionTool): name: str = "astrbot_run_browser_skill" diff --git a/astrbot/core/tools/computer_tools/shipyard_neo/neo_skills.py b/astrbot/core/tools/computer_tools/shipyard_neo/neo_skills.py index 03ba1c4a4b..edbe1ef6fd 100644 --- a/astrbot/core/tools/computer_tools/shipyard_neo/neo_skills.py +++ b/astrbot/core/tools/computer_tools/shipyard_neo/neo_skills.py @@ -12,6 +12,11 @@ from astrbot.core.tools.computer_tools.permissions import check_admin_permission from astrbot.core.tools.registry import builtin_tool +_SHIPYARD_NEO_TOOL_CONFIG = { + "provider_settings.computer_use_runtime": "sandbox", + "provider_settings.sandbox.booter": "shipyard_neo", +} + def _to_jsonable(model_like: Any) -> Any: if isinstance(model_like, dict): @@ -64,7 +69,7 @@ async def _run( return f"{self.error_prefix} {error_action}: {str(e)}" -@builtin_tool +@builtin_tool(config=_SHIPYARD_NEO_TOOL_CONFIG) @dataclass class GetExecutionHistoryTool(NeoSkillToolBase): name: str = "astrbot_get_execution_history" @@ -111,7 +116,7 @@ async def call( ) -@builtin_tool +@builtin_tool(config=_SHIPYARD_NEO_TOOL_CONFIG) @dataclass class AnnotateExecutionTool(NeoSkillToolBase): name: str = "astrbot_annotate_execution" @@ -149,7 +154,7 @@ async def call( ) -@builtin_tool +@builtin_tool(config=_SHIPYARD_NEO_TOOL_CONFIG) @dataclass class CreateSkillPayloadTool(NeoSkillToolBase): name: str = "astrbot_create_skill_payload" @@ -197,7 +202,7 @@ async def call( ) -@builtin_tool +@builtin_tool(config=_SHIPYARD_NEO_TOOL_CONFIG) @dataclass class GetSkillPayloadTool(NeoSkillToolBase): name: str = "astrbot_get_skill_payload" @@ -224,7 +229,7 @@ async def call( ) -@builtin_tool +@builtin_tool(config=_SHIPYARD_NEO_TOOL_CONFIG) @dataclass class CreateSkillCandidateTool(NeoSkillToolBase): name: str = "astrbot_create_skill_candidate" @@ -278,7 +283,7 @@ async def call( ) -@builtin_tool +@builtin_tool(config=_SHIPYARD_NEO_TOOL_CONFIG) @dataclass class ListSkillCandidatesTool(NeoSkillToolBase): name: str = "astrbot_list_skill_candidates" @@ -316,7 +321,7 @@ async def call( ) -@builtin_tool +@builtin_tool(config=_SHIPYARD_NEO_TOOL_CONFIG) @dataclass class EvaluateSkillCandidateTool(NeoSkillToolBase): name: str = "astrbot_evaluate_skill_candidate" @@ -357,7 +362,7 @@ async def call( ) -@builtin_tool +@builtin_tool(config=_SHIPYARD_NEO_TOOL_CONFIG) @dataclass class PromoteSkillCandidateTool(NeoSkillToolBase): name: str = "astrbot_promote_skill_candidate" @@ -428,7 +433,7 @@ async def call( return f"Error promoting skill candidate: {str(e)}" -@builtin_tool +@builtin_tool(config=_SHIPYARD_NEO_TOOL_CONFIG) @dataclass class ListSkillReleasesTool(NeoSkillToolBase): name: str = "astrbot_list_skill_releases" @@ -469,7 +474,7 @@ async def call( ) -@builtin_tool +@builtin_tool(config=_SHIPYARD_NEO_TOOL_CONFIG) @dataclass class RollbackSkillReleaseTool(NeoSkillToolBase): name: str = "astrbot_rollback_skill_release" @@ -496,7 +501,7 @@ async def call( ) -@builtin_tool +@builtin_tool(config=_SHIPYARD_NEO_TOOL_CONFIG) @dataclass class SyncSkillReleaseTool(NeoSkillToolBase): name: str = "astrbot_sync_skill_release" diff --git a/astrbot/core/tools/cron_tools.py b/astrbot/core/tools/cron_tools.py index 599957e0ab..6387988521 100644 --- a/astrbot/core/tools/cron_tools.py +++ b/astrbot/core/tools/cron_tools.py @@ -9,6 +9,10 @@ from astrbot.core.astr_agent_context import AstrAgentContext from astrbot.core.tools.registry import builtin_tool +_CRON_TOOL_CONFIG = { + "provider_settings.proactive_capability.add_cron_tools": True, +} + def _extract_job_session(job: Any) -> str | None: payload = getattr(job, "payload", None) @@ -18,7 +22,7 @@ def _extract_job_session(job: Any) -> str | None: return str(session) if session is not None else None -@builtin_tool +@builtin_tool(config=_CRON_TOOL_CONFIG) @dataclass class CreateActiveCronTool(FunctionTool[AstrAgentContext]): name: str = "create_future_task" @@ -107,7 +111,7 @@ async def call( return f"Scheduled future task {job.job_id} ({job.name}) {suffix}." -@builtin_tool +@builtin_tool(config=_CRON_TOOL_CONFIG) @dataclass class DeleteCronJobTool(FunctionTool[AstrAgentContext]): name: str = "delete_future_task" @@ -144,7 +148,7 @@ async def call( return f"Deleted cron job {job_id}." -@builtin_tool +@builtin_tool(config=_CRON_TOOL_CONFIG) @dataclass class ListCronJobsTool(FunctionTool[AstrAgentContext]): name: str = "list_future_tasks" diff --git a/astrbot/core/tools/knowledge_base_tools.py b/astrbot/core/tools/knowledge_base_tools.py index e27a883d4a..e082fd4253 100644 --- a/astrbot/core/tools/knowledge_base_tools.py +++ b/astrbot/core/tools/knowledge_base_tools.py @@ -9,6 +9,10 @@ from astrbot.core.star.context import Context from astrbot.core.tools.registry import builtin_tool +_KNOWLEDGE_BASE_TOOL_CONFIG = { + "kb_agentic_mode": True, +} + def check_all_kb(kb_list: list[KBHelper | None]) -> bool: """检查是否所有的知识库都为空""" @@ -83,7 +87,7 @@ async def retrieve_knowledge_base( return None -@builtin_tool +@builtin_tool(config=_KNOWLEDGE_BASE_TOOL_CONFIG) @dataclass class KnowledgeBaseQueryTool(FunctionTool[AstrAgentContext]): name: str = "astr_kb_search" diff --git a/astrbot/core/tools/registry.py b/astrbot/core/tools/registry.py index 4a1fa8d669..c3b10d2295 100644 --- a/astrbot/core/tools/registry.py +++ b/astrbot/core/tools/registry.py @@ -1,7 +1,9 @@ from __future__ import annotations +from collections.abc import Callable +from dataclasses import dataclass from importlib import import_module -from typing import TypeVar +from typing import Any, TypeVar from astrbot.core.agent.tool import FunctionTool @@ -18,6 +20,182 @@ _builtin_tool_classes_by_name: dict[str, type[FunctionTool]] = {} _builtin_tool_names_by_class: dict[type[FunctionTool], str] = {} _builtin_tools_loaded = False +_MISSING = object() + + +@dataclass(frozen=True) +class BuiltinToolConfigCondition: + key: str + operator: str + expected: Any = None + message: str | None = None + + def evaluate(self, config: dict[str, Any]) -> dict[str, Any]: + actual = _get_config_value(config, self.key) + + if self.operator == "equals": + matched = actual == self.expected + elif self.operator == "in": + expected_values = tuple(self.expected or ()) + matched = actual in expected_values + elif self.operator == "truthy": + matched = bool(actual) + elif self.operator == "custom": + matched = bool(self.expected) + else: + raise ValueError( + f"Unsupported builtin tool config operator: {self.operator}" + ) + + return { + "key": self.key, + "operator": self.operator, + "expected": _json_safe(self.expected), + "actual": _json_safe(None if actual is _MISSING else actual), + "matched": matched, + "message": self.message, + } + + +@dataclass(frozen=True) +class BuiltinToolConfigRule: + conditions: tuple[BuiltinToolConfigCondition, ...] = () + evaluator: Callable[[dict[str, Any]], list[dict[str, Any]]] | None = None + + def evaluate(self, config: dict[str, Any]) -> list[dict[str, Any]]: + if self.evaluator is not None: + return self.evaluator(config) + return [condition.evaluate(config) for condition in self.conditions] + + +def _get_config_value(config: dict[str, Any], key_path: str) -> Any: + current: Any = config + for segment in key_path.split("."): + if not isinstance(current, dict) or segment not in current: + return _MISSING + current = current[segment] + return current + + +def _json_safe(value: Any) -> Any: + if isinstance(value, tuple): + return [_json_safe(item) for item in value] + if isinstance(value, list): + return [_json_safe(item) for item in value] + if isinstance(value, dict): + return {key: _json_safe(val) for key, val in value.items()} + return value + + +def _equals(key: str, expected: Any) -> BuiltinToolConfigCondition: + return BuiltinToolConfigCondition(key=key, operator="equals", expected=expected) + + +def _in(key: str, expected: tuple[Any, ...]) -> BuiltinToolConfigCondition: + return BuiltinToolConfigCondition(key=key, operator="in", expected=expected) + + +def _custom_condition(key: str, *, matched: bool, message: str) -> dict[str, Any]: + return { + "key": key, + "operator": "custom", + "expected": None, + "actual": None, + "matched": matched, + "message": message, + } + + +def _build_rule_from_config_map( + config_map: dict[str, Any], +) -> BuiltinToolConfigRule: + conditions: list[BuiltinToolConfigCondition] = [] + for key, expected in config_map.items(): + if isinstance(expected, tuple): + conditions.append(_in(key, expected)) + else: + conditions.append(_equals(key, expected)) + return BuiltinToolConfigRule(conditions=tuple(conditions)) + + +def _evaluate_send_message_tool(config: dict[str, Any]) -> list[dict[str, Any]]: + platform_configs = config.get("platform", []) + if not isinstance(platform_configs, list): + return [ + _custom_condition( + "platform", + matched=False, + message="No enabled platform in this config supports proactive messaging.", + ) + ] + + for platform_cfg in platform_configs: + if not isinstance(platform_cfg, dict): + continue + if platform_cfg.get("enable", False) is False: + continue + + platform_type = str(platform_cfg.get("type", "")).strip() + platform_id = str(platform_cfg.get("id", "")).strip() or platform_type + if not platform_type: + continue + + if platform_type in {"wecom", "weixin_official_account"}: + continue + + if platform_type == "wecom_ai_bot": + webhook = str(platform_cfg.get("msg_push_webhook_url", "")).strip() + if not webhook: + continue + return [ + _custom_condition( + "platform[].type", + matched=True, + message=( + f"Enabled platform `{platform_id}` uses `wecom_ai_bot`, which supports proactive messaging " + "when `platform[].msg_push_webhook_url` is configured." + ), + ), + BuiltinToolConfigCondition( + key="platform[].msg_push_webhook_url", + operator="truthy", + ).evaluate({"platform[]": {"msg_push_webhook_url": webhook}}), + ] + + return [ + _custom_condition( + "platform[].type", + matched=True, + message=( + f"Enabled platform `{platform_id}` (`{platform_type}`) supports proactive messaging." + ), + ) + ] + + return [ + _custom_condition( + "platform", + matched=False, + message="No enabled platform in this config supports proactive messaging.", + ) + ] + + +_BUILTIN_TOOL_CONFIG_RULES: dict[str, BuiltinToolConfigRule] = {} + + +def _register_builtin_tool_config_rule( + tool_names: tuple[str, ...], + rule: BuiltinToolConfigRule, +) -> None: + for tool_name in tool_names: + _BUILTIN_TOOL_CONFIG_RULES[tool_name] = rule + + +_register_builtin_tool_config_rule( + ("send_message_to_user",), + BuiltinToolConfigRule(evaluator=_evaluate_send_message_tool), +) def _resolve_builtin_tool_name(tool_cls: type[FunctionTool]) -> str: @@ -35,18 +213,29 @@ def _resolve_builtin_tool_name(tool_cls: type[FunctionTool]) -> str: ) -def builtin_tool(tool_cls: TFunctionTool) -> TFunctionTool: - tool_name = _resolve_builtin_tool_name(tool_cls) - existing = _builtin_tool_classes_by_name.get(tool_name) - if existing is not None and existing is not tool_cls: - raise ValueError( - f"Builtin tool name conflict detected: {tool_name} is already registered by " - f"{existing.__module__}.{existing.__name__}.", - ) +def builtin_tool( + tool_cls: TFunctionTool | None = None, + *, + config: dict[str, Any] | None = None, +) -> TFunctionTool | Callable[[TFunctionTool], TFunctionTool]: + def _register(cls: TFunctionTool) -> TFunctionTool: + tool_name = _resolve_builtin_tool_name(cls) + existing = _builtin_tool_classes_by_name.get(tool_name) + if existing is not None and existing is not cls: + raise ValueError( + f"Builtin tool name conflict detected: {tool_name} is already registered by " + f"{existing.__module__}.{existing.__name__}.", + ) - _builtin_tool_classes_by_name[tool_name] = tool_cls - _builtin_tool_names_by_class[tool_cls] = tool_name - return tool_cls + _builtin_tool_classes_by_name[tool_name] = cls + _builtin_tool_names_by_class[cls] = tool_name + if config is not None: + _BUILTIN_TOOL_CONFIG_RULES[tool_name] = _build_rule_from_config_map(config) + return cls + + if tool_cls is None: + return _register + return _register(tool_cls) def ensure_builtin_tools_loaded() -> None: @@ -75,9 +264,64 @@ def iter_builtin_tool_classes() -> tuple[type[FunctionTool], ...]: return tuple(_builtin_tool_classes_by_name.values()) +def get_builtin_tool_config_rule(name: str) -> BuiltinToolConfigRule | None: + ensure_builtin_tools_loaded() + return _BUILTIN_TOOL_CONFIG_RULES.get(name) + + +def get_builtin_tool_config_statuses( + tool_name: str, + config_entries: list[dict[str, Any]], +) -> list[dict[str, Any]]: + rule = get_builtin_tool_config_rule(tool_name) + if rule is None: + return [] + + statuses: list[dict[str, Any]] = [] + for entry in config_entries: + config = entry.get("config") + if not isinstance(config, dict): + continue + + conditions = rule.evaluate(config) + enabled = bool(conditions) and all( + bool(condition.get("matched")) for condition in conditions + ) + statuses.append( + { + "conf_id": entry.get("conf_id"), + "conf_name": entry.get("conf_name"), + "enabled": enabled, + "matched_conditions": [ + condition for condition in conditions if condition.get("matched") + ], + "failed_conditions": [ + condition + for condition in conditions + if not condition.get("matched") + ], + } + ) + return statuses + + +def get_builtin_tool_config_tags( + tool_name: str, + config_entries: list[dict[str, Any]], +) -> list[dict[str, Any]]: + return [ + status + for status in get_builtin_tool_config_statuses(tool_name, config_entries) + if status["enabled"] + ] + + __all__ = [ "builtin_tool", "ensure_builtin_tools_loaded", + "get_builtin_tool_config_rule", + "get_builtin_tool_config_statuses", + "get_builtin_tool_config_tags", "get_builtin_tool_class", "get_builtin_tool_name", "iter_builtin_tool_classes", diff --git a/astrbot/core/tools/web_search_tools.py b/astrbot/core/tools/web_search_tools.py index 5ca8c3e08e..eacee95114 100644 --- a/astrbot/core/tools/web_search_tools.py +++ b/astrbot/core/tools/web_search_tools.py @@ -20,6 +20,22 @@ "web_search_bocha", "web_search_brave", ] +_TAVILY_WEB_SEARCH_TOOL_CONFIG = { + "provider_settings.web_search": True, + "provider_settings.websearch_provider": "tavily", +} +_BOCHA_WEB_SEARCH_TOOL_CONFIG = { + "provider_settings.web_search": True, + "provider_settings.websearch_provider": "bocha", +} +_BRAVE_WEB_SEARCH_TOOL_CONFIG = { + "provider_settings.web_search": True, + "provider_settings.websearch_provider": "brave", +} +_BAIDU_WEB_SEARCH_TOOL_CONFIG = { + "provider_settings.web_search": True, + "provider_settings.websearch_provider": "baidu_ai_search", +} @std_dataclass @@ -276,7 +292,7 @@ async def _baidu_search( ] -@builtin_tool +@builtin_tool(config=_TAVILY_WEB_SEARCH_TOOL_CONFIG) @pydantic_dataclass class TavilyWebSearchTool(FunctionTool[AstrAgentContext]): name: str = "web_search_tavily" @@ -359,7 +375,7 @@ async def call(self, context, **kwargs) -> ToolExecResult: return _search_result_payload(results) -@builtin_tool +@builtin_tool(config=_TAVILY_WEB_SEARCH_TOOL_CONFIG) @pydantic_dataclass class TavilyExtractWebPageTool(FunctionTool[AstrAgentContext]): name: str = "tavily_extract_web_page" @@ -406,7 +422,7 @@ async def call(self, context, **kwargs) -> ToolExecResult: return ret or "Error: Tavily web searcher does not return any results." -@builtin_tool +@builtin_tool(config=_BOCHA_WEB_SEARCH_TOOL_CONFIG) @pydantic_dataclass class BochaWebSearchTool(FunctionTool[AstrAgentContext]): name: str = "web_search_bocha" @@ -470,7 +486,7 @@ async def call(self, context, **kwargs) -> ToolExecResult: return _search_result_payload(results) -@builtin_tool +@builtin_tool(config=_BRAVE_WEB_SEARCH_TOOL_CONFIG) @pydantic_dataclass class BraveWebSearchTool(FunctionTool[AstrAgentContext]): name: str = "web_search_brave" @@ -528,7 +544,7 @@ async def call(self, context, **kwargs) -> ToolExecResult: return _search_result_payload(results) -@builtin_tool +@builtin_tool(config=_BAIDU_WEB_SEARCH_TOOL_CONFIG) @pydantic_dataclass class BaiduWebSearchTool(FunctionTool[AstrAgentContext]): name: str = "web_search_baidu" diff --git a/astrbot/dashboard/routes/tools.py b/astrbot/dashboard/routes/tools.py index 33b74deffc..7273c51761 100644 --- a/astrbot/dashboard/routes/tools.py +++ b/astrbot/dashboard/routes/tools.py @@ -6,6 +6,7 @@ from astrbot.core.agent.mcp_client import MCPTool from astrbot.core.core_lifecycle import AstrBotCoreLifecycle from astrbot.core.star import star_map +from astrbot.core.tools.registry import get_builtin_tool_config_statuses from .route import Response, Route, RouteContext @@ -434,13 +435,36 @@ async def get_tool_list(self): if tool.name not in existing_names: tools.append(tool) + conf_list = self.core_lifecycle.astrbot_config_mgr.get_conf_list() + conf_name_map = {conf["id"]: conf["name"] for conf in conf_list} + config_entries = [] + for conf_id, conf in self.core_lifecycle.astrbot_config_mgr.confs.items(): + config_entries.append( + { + "conf_id": conf_id, + "conf_name": conf_name_map.get(conf_id, conf_id), + "config": conf, + } + ) + tools_dict = [] for tool in tools: readonly = False + builtin_config_statuses = [] + builtin_config_tags = [] if self.tool_mgr.is_builtin_tool(tool.name): origin = "builtin" origin_name = "AstrBot Core" readonly = True + builtin_config_statuses = get_builtin_tool_config_statuses( + tool.name, + config_entries, + ) + builtin_config_tags = [ + status + for status in builtin_config_statuses + if status["enabled"] + ] elif isinstance(tool, MCPTool): origin = "mcp" origin_name = tool.mcp_server_name @@ -462,6 +486,8 @@ async def get_tool_list(self): "origin": origin, "origin_name": origin_name, "readonly": readonly, + "builtin_config_statuses": builtin_config_statuses, + "builtin_config_tags": builtin_config_tags, } tools_dict.append(tool_info) return Response().ok(data=tools_dict).__dict__ diff --git a/dashboard/src/components/extension/componentPanel/components/ToolTable.vue b/dashboard/src/components/extension/componentPanel/components/ToolTable.vue index f0be7bbc83..9615e5ea8c 100644 --- a/dashboard/src/components/extension/componentPanel/components/ToolTable.vue +++ b/dashboard/src/components/extension/componentPanel/components/ToolTable.vue @@ -1,7 +1,7 @@