AstrBot 4.12.4__py3-none-any.whl → 4.13.0__py3-none-any.whl

astrbot/builtin_stars/astrbot/process_llm_request.py

@@ -10,8 +10,11 @@ from astrbot.api.provider import Provider, ProviderRequest
 from astrbot.core.agent.message import TextPart
 from astrbot.core.pipeline.process_stage.utils import (
     CHATUI_SPECIAL_DEFAULT_PERSONA_PROMPT,
+    LOCAL_EXECUTE_SHELL_TOOL,
+    LOCAL_PYTHON_TOOL,
 )
 from astrbot.core.provider.func_tool_manager import ToolSet
+from astrbot.core.skills.skill_manager import SkillManager, build_skills_prompt
 
 
 class ProcessLLMRequest:
@@ -25,6 +28,15 @@ class ProcessLLMRequest:
         else:
             logger.info(f"Timezone set to: {self.timezone}")
 
+        self.skill_manager = SkillManager()
+
+    def _apply_local_env_tools(self, req: ProviderRequest) -> None:
+        """Add local environment tools to the provider request."""
+        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)
+
     async def _ensure_persona(
         self, req: ProviderRequest, cfg: dict, umo: str, platform_type: str
     ):
@@ -66,6 +78,30 @@ class ProcessLLMRequest:
             if begin_dialogs := copy.deepcopy(persona["_begin_dialogs_processed"]):
                 req.contexts[:0] = begin_dialogs
 
+        # skills select and prompt
+        runtime = self.skills_cfg.get("runtime", "local")
+        skills = self.skill_manager.list_skills(active_only=True, runtime=runtime)
+        if runtime == "sandbox" and not self.sandbox_cfg.get("enable", False):
+            logger.warning(
+                "Skills runtime is set to sandbox, but sandbox mode is disabled, will skip skills prompt injection.",
+            )
+            req.system_prompt += "\n[Background: User added some skills, and skills runtime is set to sandbox, but sandbox mode is disabled. So skills will be unavailable.]\n"
+        elif skills:
+            # persona.skills == None means all skills are allowed
+            if persona and persona.get("skills") is not None:
+                if not persona["skills"]:
+                    return
+                allowed = set(persona["skills"])
+                skills = [skill for skill in skills if skill.name in allowed]
+            if skills:
+                req.system_prompt += f"\n{build_skills_prompt(skills)}\n"
+
+            # if user wants to use skills in non-sandbox mode, apply local env tools
+            runtime = self.skills_cfg.get("runtime", "local")
+            sandbox_enabled = self.sandbox_cfg.get("enable", False)
+            if runtime == "local" and not sandbox_enabled:
+                self._apply_local_env_tools(req)
+
         # tools select
         tmgr = self.ctx.get_llm_tool_manager()
         if (persona and persona.get("tools") is None) or not persona:
@@ -81,7 +117,10 @@ class ProcessLLMRequest:
                     tool = tmgr.get_func(tool_name)
                     if tool and tool.active:
                         toolset.add_tool(tool)
-        req.func_tool = toolset
+        if not req.func_tool:
+            req.func_tool = toolset
+        else:
+            req.func_tool.merge(toolset)
         logger.debug(f"Tool set for persona {persona_id}: {toolset.names()}")
 
     async def _ensure_img_caption(
@@ -134,6 +173,8 @@ class ProcessLLMRequest:
         cfg: dict = self.ctx.get_config(umo=event.unified_msg_origin)[
             "provider_settings"
         ]
+        self.skills_cfg = cfg.get("skills", {})
+        self.sandbox_cfg = cfg.get("sandbox", {})
 
         # prompt prefix
         if prefix := cfg.get("prompt_prefix"):

astrbot/cli/__init__.py

@@ -1 +1 @@
-__version__ = "4.12.4"
+__version__ = "4.13.0"

astrbot/core/agent/runners/tool_loop_agent_runner.py

@@ -1,3 +1,4 @@
+import copy
 import sys
 import time
 import traceback
@@ -14,6 +15,7 @@ from mcp.types import (
 
 from astrbot import logger
 from astrbot.core.agent.message import TextPart, ThinkPart
+from astrbot.core.agent.tool import ToolSet
 from astrbot.core.message.components import Json
 from astrbot.core.message.message_event_result import (
     MessageChain,
@@ -64,6 +66,7 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
         # customize
         custom_token_counter: TokenCounter | None = None,
         custom_compressor: ContextCompressor | None = None,
+        tool_schema_mode: str | None = "full",
         **kwargs: T.Any,
     ) -> None:
         self.req = request
@@ -99,6 +102,24 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
         self.agent_hooks = agent_hooks
         self.run_context = run_context
 
+        # These two are used for tool schema mode handling
+        # We now have two modes:
+        # - "full": use full tool schema for LLM calls, default.
+        # - "skills_like": use light tool schema for LLM calls, and re-query with param-only schema when needed.
+        #   Light tool schema does not include tool parameters.
+        #   This can reduce token usage when tools have large descriptions.
+        # See #4681
+        self.tool_schema_mode = tool_schema_mode
+        self._tool_schema_param_set = None
+        if tool_schema_mode == "skills_like":
+            tool_set = self.req.func_tool
+            if not tool_set:
+                return
+            light_set = tool_set.get_light_tool_set()
+            self._tool_schema_param_set = tool_set.get_param_only_tool_set()
+            # MODIFIE the req.func_tool to use light tool schemas
+            self.req.func_tool = light_set
+
         messages = []
         # append existing messages in the run context
         for msg in request.contexts:
@@ -253,6 +274,9 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
 
         # 如果有工具调用，还需处理工具调用
         if llm_resp.tools_call_name:
+            if self.tool_schema_mode == "skills_like":
+                llm_resp, _ = await self._resolve_tool_exec(llm_resp)
+
             tool_call_result_blocks = []
             async for result in self._handle_function_tools(self.req, llm_resp):
                 if isinstance(result, list):
@@ -269,6 +293,7 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                         type=ar_type,
                         data=AgentResponseData(chain=result),
                     )
+
             # 将结果添加到上下文中
             parts = []
             if llm_resp.reasoning_content or llm_resp.reasoning_signature:
@@ -354,7 +379,7 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
             try:
                 if not req.func_tool:
                     return
-                func_tool = req.func_tool.get_func(func_tool_name)
+                func_tool = req.func_tool.get_tool(func_tool_name)
                 logger.info(f"使用工具：{func_tool_name}，参数：{func_tool_args}")
 
                 if not func_tool:
@@ -537,6 +562,71 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
         if tool_call_result_blocks:
             yield tool_call_result_blocks
 
+    def _build_tool_requery_context(
+        self, tool_names: list[str]
+    ) -> list[dict[str, T.Any]]:
+        """Build contexts for re-querying LLM with param-only tool schemas."""
+        contexts: list[dict[str, T.Any]] = []
+        for msg in self.run_context.messages:
+            if hasattr(msg, "model_dump"):
+                contexts.append(msg.model_dump())  # type: ignore[call-arg]
+            elif isinstance(msg, dict):
+                contexts.append(copy.deepcopy(msg))
+        instruction = (
+            "You have decided to call tool(s): "
+            + ", ".join(tool_names)
+            + ". Now call the tool(s) with required arguments using the tool schema, "
+            "and follow the existing tool-use rules."
+        )
+        if contexts and contexts[0].get("role") == "system":
+            content = contexts[0].get("content") or ""
+            contexts[0]["content"] = f"{content}\n{instruction}"
+        else:
+            contexts.insert(0, {"role": "system", "content": instruction})
+        return contexts
+
+    def _build_tool_subset(self, tool_set: ToolSet, tool_names: list[str]) -> ToolSet:
+        """Build a subset of tools from the given tool set based on tool names."""
+        subset = ToolSet()
+        for name in tool_names:
+            tool = tool_set.get_tool(name)
+            if tool:
+                subset.add_tool(tool)
+        return subset
+
+    async def _resolve_tool_exec(
+        self,
+        llm_resp: LLMResponse,
+    ) -> tuple[LLMResponse, ToolSet | None]:
+        """Used in 'skills_like' tool schema mode to re-query LLM with param-only tool schemas."""
+        tool_names = llm_resp.tools_call_name
+        if not tool_names:
+            return llm_resp, self.req.func_tool
+        full_tool_set = self.req.func_tool
+        if not isinstance(full_tool_set, ToolSet):
+            return llm_resp, self.req.func_tool
+
+        subset = self._build_tool_subset(full_tool_set, tool_names)
+        if not subset.tools:
+            return llm_resp, full_tool_set
+
+        if isinstance(self._tool_schema_param_set, ToolSet):
+            param_subset = self._build_tool_subset(
+                self._tool_schema_param_set, tool_names
+            )
+            if param_subset.tools and tool_names:
+                contexts = self._build_tool_requery_context(tool_names)
+                requery_resp = await self.provider.text_chat(
+                    contexts=contexts,
+                    func_tool=param_subset,
+                    model=self.req.model,
+                    session_id=self.req.session_id,
+                )
+                if requery_resp:
+                    llm_resp = requery_resp
+
+        return llm_resp, subset
+
     def done(self) -> bool:
         """检查 Agent 是否已完成工作"""
         return self._state in (AgentState.DONE, AgentState.ERROR)

astrbot/core/agent/tool.py

@@ -1,3 +1,4 @@
+import copy
 from collections.abc import AsyncGenerator, Awaitable, Callable
 from typing import Any, Generic
 
@@ -102,6 +103,47 @@ class ToolSet:
                 return tool
         return None
 
+    def get_light_tool_set(self) -> "ToolSet":
+        """Return a light tool set with only name/description."""
+        light_tools = []
+        for tool in self.tools:
+            if hasattr(tool, "active") and not tool.active:
+                continue
+            light_params = {
+                "type": "object",
+                "properties": {},
+            }
+            light_tools.append(
+                FunctionTool(
+                    name=tool.name,
+                    parameters=light_params,
+                    description=tool.description,
+                    handler=None,
+                )
+            )
+        return ToolSet(light_tools)
+
+    def get_param_only_tool_set(self) -> "ToolSet":
+        """Return a tool set with name/parameters only (no description)."""
+        param_tools = []
+        for tool in self.tools:
+            if hasattr(tool, "active") and not tool.active:
+                continue
+            params = (
+                copy.deepcopy(tool.parameters)
+                if tool.parameters
+                else {"type": "object", "properties": {}}
+            )
+            param_tools.append(
+                FunctionTool(
+                    name=tool.name,
+                    parameters=params,
+                    description="",
+                    handler=None,
+                )
+            )
+        return ToolSet(param_tools)
+
     @deprecated(reason="Use add_tool() instead", version="4.0.0")
     def add_func(
         self,
@@ -147,18 +189,15 @@ class ToolSet:
         """Convert tools to OpenAI API function calling schema format."""
         result = []
         for tool in self.tools:
-            func_def = {
-                "type": "function",
-                "function": {
-                    "name": tool.name,
-                    "description": tool.description,
-                },
-            }
+            func_def = {"type": "function", "function": {"name": tool.name}}
+            if tool.description:
+                func_def["function"]["description"] = tool.description
 
-            if (
-                tool.parameters and tool.parameters.get("properties")
-            ) or not omit_empty_parameter_field:
-                func_def["function"]["parameters"] = tool.parameters
+            if tool.parameters is not None:
+                if (
+                    tool.parameters and tool.parameters.get("properties")
+                ) or not omit_empty_parameter_field:
+                    func_def["function"]["parameters"] = tool.parameters
 
             result.append(func_def)
         return result
@@ -171,11 +210,9 @@ class ToolSet:
             if tool.parameters:
                 input_schema["properties"] = tool.parameters.get("properties", {})
                 input_schema["required"] = tool.parameters.get("required", [])
-            tool_def = {
-                "name": tool.name,
-                "description": tool.description,
-                "input_schema": input_schema,
-            }
+            tool_def = {"name": tool.name, "input_schema": input_schema}
+            if tool.description:
+                tool_def["description"] = tool.description
             result.append(tool_def)
         return result
 
@@ -245,10 +282,9 @@ class ToolSet:
 
         tools = []
         for tool in self.tools:
-            d: dict[str, Any] = {
-                "name": tool.name,
-                "description": tool.description,
-            }
+            d: dict[str, Any] = {"name": tool.name}
+            if tool.description:
+                d["description"] = tool.description
             if tool.parameters:
                 d["parameters"] = convert_schema(tool.parameters)
             tools.append(d)
@@ -274,6 +310,11 @@ class ToolSet:
         """获取所有工具的名称列表"""
         return [tool.name for tool in self.tools]
 
+    def merge(self, other: "ToolSet"):
+        """Merge another ToolSet into this one."""
+        for tool in other.tools:
+            self.add_tool(tool)
+
     def __len__(self):
         return len(self.tools)
 

astrbot/core/astr_agent_tool_exec.py

@@ -256,7 +256,7 @@ async def call_local_llm_tool(
                 # 这里逐步执行异步生成器, 对于每个 yield 返回的 ret, 执行下面的代码
                 # 返回值只能是 MessageEventResult 或者 None（无返回值）
                 _has_yielded = True
-                if isinstance(ret, (MessageEventResult, CommandResult)):
+                if isinstance(ret, MessageEventResult | CommandResult):
                     # 如果返回值是 MessageEventResult, 设置结果并继续
                     event.set_result(ret)
                     yield
@@ -273,7 +273,7 @@ async def call_local_llm_tool(
     elif inspect.iscoroutine(ready_to_call):
         # 如果只是一个协程, 直接执行
         ret = await ready_to_call
-        if isinstance(ret, (MessageEventResult, CommandResult)):
+        if isinstance(ret, MessageEventResult | CommandResult):
             event.set_result(ret)
             yield
         else:

astrbot/core/{sandbox → computer}/booters/base.py

@@ -1,7 +1,7 @@
 from ..olayer import FileSystemComponent, PythonComponent, ShellComponent
 
 
-class SandboxBooter:
+class ComputerBooter:
     @property
     def fs(self) -> FileSystemComponent: ...
 
@@ -16,16 +16,16 @@ class SandboxBooter:
     async def shutdown(self) -> None: ...
 
     async def upload_file(self, path: str, file_name: str) -> dict:
-        """Upload file to sandbox.
+        """Upload file to the computer.
 
         Should return a dict with `success` (bool) and `file_path` (str) keys.
         """
         ...
 
     async def download_file(self, remote_path: str, local_path: str):
-        """Download file from sandbox."""
+        """Download file from the computer."""
         ...
 
     async def available(self) -> bool:
-        """Check if the sandbox is available."""
+        """Check if the computer is available."""
         ...

astrbot/core/{sandbox → computer}/booters/boxlite.py

@@ -11,7 +11,7 @@ from shipyard.shell import ShellComponent as ShipyardShellComponent
 from astrbot.api import logger
 
 from ..olayer import FileSystemComponent, PythonComponent, ShellComponent
-from .base import SandboxBooter
+from .base import ComputerBooter
 
 
 class MockShipyardSandboxClient:
@@ -124,7 +124,7 @@ class MockShipyardSandboxClient:
                 loop -= 1
 
 
-class BoxliteBooter(SandboxBooter):
+class BoxliteBooter(ComputerBooter):
     async def boot(self, session_id: str) -> None:
         logger.info(
             f"Booting(Boxlite) for session: {session_id}, this may take a while..."

astrbot/core/computer/booters/local.py

@@ -0,0 +1,234 @@
+from __future__ import annotations
+
+import asyncio
+import os
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+from typing import Any
+
+from astrbot.api import logger
+from astrbot.core.utils.astrbot_path import (
+    get_astrbot_data_path,
+    get_astrbot_root,
+    get_astrbot_temp_path,
+)
+
+from ..olayer import FileSystemComponent, PythonComponent, ShellComponent
+from .base import ComputerBooter
+
+_BLOCKED_COMMAND_PATTERNS = [
+    " rm -rf ",
+    " rm -fr ",
+    " rm -r ",
+    " mkfs",
+    " dd if=",
+    " shutdown",
+    " reboot",
+    " poweroff",
+    " halt",
+    " sudo ",
+    ":(){:|:&};:",
+    " kill -9 ",
+    " killall ",
+]
+
+
+def _is_safe_command(command: str) -> bool:
+    cmd = f" {command.strip().lower()} "
+    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
+
+
+@dataclass
+class LocalShellComponent(ShellComponent):
+    async def exec(
+        self,
+        command: str,
+        cwd: str | None = None,
+        env: dict[str, str] | None = None,
+        timeout: int | None = 30,
+        shell: bool = True,
+        background: bool = False,
+    ) -> dict[str, Any]:
+        if not _is_safe_command(command):
+            raise PermissionError("Blocked unsafe shell command.")
+
+        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()
+            if background:
+                proc = subprocess.Popen(
+                    command,
+                    shell=shell,
+                    cwd=working_dir,
+                    env=run_env,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                )
+                return {"pid": proc.pid, "stdout": "", "stderr": "", "exit_code": None}
+            result = subprocess.run(
+                command,
+                shell=shell,
+                cwd=working_dir,
+                env=run_env,
+                timeout=timeout,
+                capture_output=True,
+                text=True,
+            )
+            return {
+                "stdout": result.stdout,
+                "stderr": result.stderr,
+                "exit_code": result.returncode,
+            }
+
+        return await asyncio.to_thread(_run)
+
+
+@dataclass
+class LocalPythonComponent(PythonComponent):
+    async def exec(
+        self,
+        code: str,
+        kernel_id: str | None = None,
+        timeout: int = 30,
+        silent: bool = False,
+    ) -> dict[str, Any]:
+        def _run() -> dict[str, Any]:
+            try:
+                result = subprocess.run(
+                    [os.environ.get("PYTHON", sys.executable), "-c", code],
+                    timeout=timeout,
+                    capture_output=True,
+                    text=True,
+                )
+                stdout = "" if silent else result.stdout
+                stderr = result.stderr if result.returncode != 0 else ""
+                return {
+                    "data": {
+                        "output": {"text": stdout, "images": []},
+                        "error": stderr,
+                    }
+                }
+            except subprocess.TimeoutExpired:
+                return {
+                    "data": {
+                        "output": {"text": "", "images": []},
+                        "error": "Execution timed out.",
+                    }
+                }
+
+        return await asyncio.to_thread(_run)
+
+
+@dataclass
+class LocalFileSystemComponent(FileSystemComponent):
+    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)
+            os.makedirs(os.path.dirname(abs_path), exist_ok=True)
+            with open(abs_path, "w", encoding="utf-8") as f:
+                f.write(content)
+            os.chmod(abs_path, mode)
+            return {"success": True, "path": abs_path}
+
+        return await asyncio.to_thread(_run)
+
+    async def read_file(self, path: str, encoding: str = "utf-8") -> dict[str, Any]:
+        def _run() -> dict[str, Any]:
+            abs_path = _ensure_safe_path(path)
+            with open(abs_path, encoding=encoding) as f:
+                content = f.read()
+            return {"success": True, "content": content}
+
+        return await asyncio.to_thread(_run)
+
+    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)
+            os.makedirs(os.path.dirname(abs_path), exist_ok=True)
+            with open(abs_path, mode, encoding=encoding) as f:
+                f.write(content)
+            return {"success": True, "path": abs_path}
+
+        return await asyncio.to_thread(_run)
+
+    async def delete_file(self, path: str) -> dict[str, Any]:
+        def _run() -> dict[str, Any]:
+            abs_path = _ensure_safe_path(path)
+            if os.path.isdir(abs_path):
+                shutil.rmtree(abs_path)
+            else:
+                os.remove(abs_path)
+            return {"success": True, "path": abs_path}
+
+        return await asyncio.to_thread(_run)
+
+    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)
+            entries = os.listdir(abs_path)
+            if not show_hidden:
+                entries = [e for e in entries if not e.startswith(".")]
+            return {"success": True, "entries": entries}
+
+        return await asyncio.to_thread(_run)
+
+
+class LocalBooter(ComputerBooter):
+    def __init__(self) -> None:
+        self._fs = LocalFileSystemComponent()
+        self._python = LocalPythonComponent()
+        self._shell = LocalShellComponent()
+
+    async def boot(self, session_id: str) -> None:
+        logger.info(f"Local computer booter initialized for session: {session_id}")
+
+    async def shutdown(self) -> None:
+        logger.info("Local computer booter shutdown complete.")
+
+    @property
+    def fs(self) -> FileSystemComponent:
+        return self._fs
+
+    @property
+    def python(self) -> PythonComponent:
+        return self._python
+
+    @property
+    def shell(self) -> ShellComponent:
+        return self._shell
+
+    async def upload_file(self, path: str, file_name: str) -> dict:
+        raise NotImplementedError(
+            "LocalBooter does not support upload_file operation. Use shell instead."
+        )
+
+    async def download_file(self, remote_path: str, local_path: str):
+        raise NotImplementedError(
+            "LocalBooter does not support download_file operation. Use shell instead."
+        )
+
+    async def available(self) -> bool:
+        return True

astrbot/core/{sandbox → computer}/booters/shipyard.py

@@ -3,10 +3,10 @@ from shipyard import ShipyardClient, Spec
 from astrbot.api import logger
 
 from ..olayer import FileSystemComponent, PythonComponent, ShellComponent
-from .base import SandboxBooter
+from .base import ComputerBooter
 
 
-class ShipyardBooter(SandboxBooter):
+class ShipyardBooter(ComputerBooter):
     def __init__(
         self,
         endpoint_url: str,