AstrBot 4.11.3__py3-none-any.whl → 4.12.0__py3-none-any.whl

astrbot/core/pipeline/process_stage/method/agent_sub_stages/internal.py

@@ -2,10 +2,11 @@
 
 import asyncio
 import json
+import os
 from collections.abc import AsyncGenerator
 
 from astrbot.core import logger
-from astrbot.core.agent.message import Message
+from astrbot.core.agent.message import Message, TextPart
 from astrbot.core.agent.response import AgentStats
 from astrbot.core.agent.tool import ToolSet
 from astrbot.core.astr_agent_context import AstrAgentContext
@@ -35,8 +36,16 @@ from .....astr_agent_tool_exec import FunctionToolExecutor
 from ....context import PipelineContext, call_event_hook
 from ...stage import Stage
 from ...utils import (
+    CHATUI_EXTRA_PROMPT,
+    EXECUTE_SHELL_TOOL,
+    FILE_DOWNLOAD_TOOL,
+    FILE_UPLOAD_TOOL,
     KNOWLEDGE_BASE_QUERY_TOOL,
     LLM_SAFETY_MODE_SYSTEM_PROMPT,
+    PYTHON_TOOL,
+    SANDBOX_MODE_PROMPT,
+    TOOL_CALL_PROMPT,
+    decoded_blocked,
     retrieve_knowledge_base,
 )
 
@@ -93,6 +102,8 @@ class InternalAgentSubStage(Stage):
             "safety_mode_strategy", "system_prompt"
         )
 
+        self.sandbox_cfg = settings.get("sandbox", {})
+
         self.conv_manager = ctx.plugin_manager.context.conversation_manager
 
     def _select_provider(self, event: AstrMessageEvent):
@@ -341,54 +352,45 @@ class InternalAgentSubStage(Stage):
         prov: Provider,
     ):
         """处理 WebChat 平台的特殊情况，包括第一次 LLM 对话时总结对话内容生成 title"""
-        if not req.conversation:
+        from astrbot.core import db_helper
+
+        chatui_session_id = event.session_id.split("!")[-1]
+        user_prompt = req.prompt
+
+        session = await db_helper.get_platform_session_by_id(chatui_session_id)
+
+        if (
+            not user_prompt
+            or not chatui_session_id
+            or not session
+            or session.display_name
+        ):
             return
-        conversation = await self.conv_manager.get_conversation(
-            event.unified_msg_origin,
-            req.conversation.cid,
+
+        llm_resp = await prov.text_chat(
+            system_prompt=(
+                "You are a conversation title generator. "
+                "Generate a concise title in the same language as the user’s input, "
+                "no more than 10 words, capturing only the core topic."
+                "If the input is a greeting, small talk, or has no clear topic, "
+                "(e.g., “hi”, “hello”, “haha”), return <None>. "
+                "Output only the title itself or <None>, with no explanations."
+            ),
+            prompt=(
+                f"Generate a concise title for the following user query:\n{user_prompt}"
+            ),
         )
-        if conversation and not req.conversation.title:
-            messages = json.loads(conversation.history)
-            latest_pair = messages[-2:]
-            if not latest_pair:
+        if llm_resp and llm_resp.completion_text:
+            title = llm_resp.completion_text.strip()
+            if not title or "<None>" in title:
                 return
-            content = latest_pair[0].get("content", "")
-            if isinstance(content, list):
-                # 多模态
-                text_parts = []
-                for item in content:
-                    if isinstance(item, dict):
-                        if item.get("type") == "text":
-                            text_parts.append(item.get("text", ""))
-                        elif item.get("type") == "image":
-                            text_parts.append("[图片]")
-                    elif isinstance(item, str):
-                        text_parts.append(item)
-                cleaned_text = "User: " + " ".join(text_parts).strip()
-            elif isinstance(content, str):
-                cleaned_text = "User: " + content.strip()
-            else:
-                return
-            logger.debug(f"WebChat 对话标题生成请求，清理后的文本: {cleaned_text}")
-            llm_resp = await prov.text_chat(
-                system_prompt="You are expert in summarizing user's query.",
-                prompt=(
-                    f"Please summarize the following query of user:\n"
-                    f"{cleaned_text}\n"
-                    "Only output the summary within 10 words, DO NOT INCLUDE any other text."
-                    "You must use the same language as the user."
-                    "If you think the dialog is too short to summarize, only output a special mark: `<None>`"
-                ),
+            logger.info(
+                f"Generated chatui title for session {chatui_session_id}: {title}"
+            )
+            await db_helper.update_platform_session(
+                session_id=chatui_session_id,
+                display_name=title,
             )
-            if llm_resp and llm_resp.completion_text:
-                title = llm_resp.completion_text.strip()
-                if not title or "<None>" in title:
-                    return
-                await self.conv_manager.update_conversation_title(
-                    unified_msg_origin=event.unified_msg_origin,
-                    title=title,
-                    conversation_id=req.conversation.cid,
-                )
 
     async def _save_to_history(
         self,
@@ -466,6 +468,24 @@ class InternalAgentSubStage(Stage):
                 f"Unsupported llm_safety_mode strategy: {self.safety_mode_strategy}.",
             )
 
+    def _apply_sandbox_tools(self, req: ProviderRequest, session_id: str) -> None:
+        """Add sandbox tools to the provider request."""
+        if req.func_tool is None:
+            req.func_tool = ToolSet()
+        if self.sandbox_cfg.get("booter") == "shipyard":
+            ep = self.sandbox_cfg.get("shipyard_endpoint", "")
+            at = self.sandbox_cfg.get("shipyard_access_token", "")
+            if not ep or not at:
+                logger.error("Shipyard sandbox configuration is incomplete.")
+                return
+            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.system_prompt += f"\n{SANDBOX_MODE_PROMPT}\n"
+
     async def process(
         self, event: AstrMessageEvent, provider_wake_prefix: str
     ) -> AsyncGenerator[None, None]:
@@ -501,6 +521,14 @@ class InternalAgentSubStage(Stage):
                 logger.debug("skip llm request: empty message and no provider_request")
                 return
 
+            api_base = provider.provider_config.get("api_base", "")
+            for host in decoded_blocked:
+                if host in api_base:
+                    logger.error(
+                        f"Provider API base {api_base} is blocked due to security reasons. Please use another ai provider."
+                    )
+                    return
+
             logger.debug("ready to request llm provider")
 
             # 通知等待调用 LLM（在获取锁之前）
@@ -536,6 +564,20 @@ class InternalAgentSubStage(Stage):
                             image_path = await comp.convert_to_file_path()
                             req.image_urls.append(image_path)
 
+                            req.extra_user_content_parts.append(
+                                TextPart(text=f"[Image Attachment: path {image_path}]")
+                            )
+                        elif isinstance(comp, File) and self.sandbox_cfg.get(
+                            "enable", False
+                        ):
+                            file_path = await comp.get_file()
+                            file_name = comp.name or os.path.basename(file_path)
+                            req.extra_user_content_parts.append(
+                                TextPart(
+                                    text=f"[File Attachment: name {file_name}, path {file_path}]"
+                                )
+                            )
+
                     conversation = await self._get_session_conv(event)
                     req.conversation = conversation
                     req.contexts = json.loads(conversation.history)
@@ -586,6 +628,10 @@ class InternalAgentSubStage(Stage):
                 if self.llm_safety_mode:
                     self._apply_llm_safety_mode(req)
 
+                # apply sandbox tools
+                if self.sandbox_cfg.get("enable", False):
+                    self._apply_sandbox_tools(req, req.session_id)
+
                 stream_to_general = (
                     self.unsupported_streaming_strategy == "turn_off"
                     and not event.platform_meta.support_streaming_message
@@ -609,6 +655,18 @@ class InternalAgentSubStage(Stage):
                             "limit"
                         ]["context"]
 
+                # ChatUI 对话的标题生成
+                if event.get_platform_name() == "webchat":
+                    asyncio.create_task(self._handle_webchat(event, req, provider))
+
+                    # 注入 ChatUI 额外 prompt
+                    # 比如 follow-up questions 提示等
+                    req.system_prompt += f"\n{CHATUI_EXTRA_PROMPT}\n"
+
+                # 注入基本 prompt
+                if req.func_tool and req.func_tool.tools:
+                    req.system_prompt += f"\n{TOOL_CALL_PROMPT}\n"
+
                 await agent_runner.reset(
                     provider=provider,
                     request=req,
@@ -679,10 +737,6 @@ class InternalAgentSubStage(Stage):
                         agent_runner.stats,
                     )
 
-            # 异步处理 WebChat 特殊情况
-            if event.get_platform_name() == "webchat":
-                asyncio.create_task(self._handle_webchat(event, req, provider))
-
             asyncio.create_task(
                 Metric.upload(
                     llm_tick=1,

astrbot/core/pipeline/process_stage/utils.py

@@ -1,3 +1,5 @@
+import base64
+
 from pydantic import Field
 from pydantic.dataclasses import dataclass
 
@@ -5,6 +7,12 @@ from astrbot.api import logger, sp
 from astrbot.core.agent.run_context import ContextWrapper
 from astrbot.core.agent.tool import FunctionTool, ToolExecResult
 from astrbot.core.astr_agent_context import AstrAgentContext
+from astrbot.core.sandbox.tools import (
+    ExecuteShellTool,
+    FileDownloadTool,
+    FileUploadTool,
+    PythonTool,
+)
 from astrbot.core.star.context import Context
 
 LLM_SAFETY_MODE_SYSTEM_PROMPT = """You are running in Safe Mode.
@@ -19,6 +27,28 @@ Rules:
 - Output same language as the user's input.
 """
 
+SANDBOX_MODE_PROMPT = (
+    "You have access to a sandboxed environment and can execute shell commands and Python code securely."
+    # "Your have extended skills library, such as PDF processing, image generation, data analysis, etc. "
+    # "Before handling complex tasks, please retrieve and review the documentation in the in /app/skills/ directory. "
+    # "If the current task matches the description of a specific skill, prioritize following the workflow defined by that skill."
+    # "Use `ls /app/skills/` to list all available skills. "
+    # "Use `cat /app/skills/{skill_name}/SKILL.md` to read the documentation of a specific skill."
+    # "SKILL.md might be large, you can read the description first, which is located in the YAML frontmatter of the file."
+    # "Use shell commands such as grep, sed, awk to extract relevant information from the documentation as needed.\n"
+)
+
+TOOL_CALL_PROMPT = (
+    "You MUST NOT return an empty response, especially after invoking a tool."
+    "Before calling any tool, provide a brief explanatory message to the user stating the purpose of the tool call."
+    "After the tool call is completed, you must briefly summarize the results returned by the tool for the user."
+)
+
+CHATUI_EXTRA_PROMPT = (
+    'When you answered, you need to add a follow up question / summarization but do not add "Follow up" words. '
+    "Such as, user asked you to generate codes, you can add: Do you need me to run these codes for you?"
+)
+
 
 @dataclass
 class KnowledgeBaseQueryTool(FunctionTool[AstrAgentContext]):
@@ -135,3 +165,13 @@ async def retrieve_knowledge_base(
 
 
 KNOWLEDGE_BASE_QUERY_TOOL = KnowledgeBaseQueryTool()
+
+EXECUTE_SHELL_TOOL = ExecuteShellTool()
+PYTHON_TOOL = PythonTool()
+FILE_UPLOAD_TOOL = FileUploadTool()
+FILE_DOWNLOAD_TOOL = FileDownloadTool()
+
+# we prevent astrbot from connecting to known malicious hosts
+# these hosts are base64 encoded
+BLOCKED = {"dGZid2h2d3IuY2xvdWQuc2VhbG9zLmlv", "a291cmljaGF0"}
+decoded_blocked = [base64.b64decode(b).decode("utf-8") for b in BLOCKED]

astrbot/core/platform/sources/discord/discord_platform_adapter.py

@@ -370,6 +370,8 @@ class DiscordPlatformAdapter(Platform):
         for handler_md in star_handlers_registry:
             if not star_map[handler_md.handler_module_path].activated:
                 continue
+            if not handler_md.enabled:
+                continue
             for event_filter in handler_md.event_filters:
                 cmd_info = self._extract_command_info(event_filter, handler_md)
                 if not cmd_info:

astrbot/core/platform/sources/telegram/tg_adapter.py

@@ -161,6 +161,8 @@ class TelegramPlatformAdapter(Platform):
             handler_metadata = handler_md
             if not star_map[handler_metadata.handler_module_path].activated:
                 continue
+            if not handler_metadata.enabled:
+                continue
             for event_filter in handler_metadata.event_filters:
                 cmd_info = self._extract_command_info(
                     event_filter,

astrbot/core/platform/sources/webchat/webchat_adapter.py

@@ -93,7 +93,8 @@ class WebChatAdapter(Platform):
         session: MessageSesion,
         message_chain: MessageChain,
     ):
-        await WebChatMessageEvent._send(message_chain, session.session_id)
+        message_id = f"active_{str(uuid.uuid4())}"
+        await WebChatMessageEvent._send(message_id, message_chain, session.session_id)
         await super().send_by_session(session, message_chain)
 
     async def _get_message_history(
@@ -196,7 +197,7 @@ class WebChatAdapter(Platform):
 
         abm.session_id = f"webchat!{username}!{cid}"
 
-        abm.message_id = str(uuid.uuid4())
+        abm.message_id = payload.get("message_id")
 
         # 处理消息段列表
         message_parts = payload.get("message", [])

astrbot/core/platform/sources/webchat/webchat_event.py

@@ -21,7 +21,10 @@ class WebChatMessageEvent(AstrMessageEvent):
 
     @staticmethod
     async def _send(
-        message: MessageChain | None, session_id: str, streaming: bool = False
+        message_id: str,
+        message: MessageChain | None,
+        session_id: str,
+        streaming: bool = False,
     ) -> str | None:
         cid = session_id.split("!")[-1]
         web_chat_back_queue = webchat_queue_mgr.get_or_create_back_queue(cid)
@@ -31,6 +34,7 @@ class WebChatMessageEvent(AstrMessageEvent):
                     "type": "end",
                     "data": "",
                     "streaming": False,
+                    "message_id": message_id,
                 },  # end means this request is finished
             )
             return
@@ -45,6 +49,7 @@ class WebChatMessageEvent(AstrMessageEvent):
                         "data": data,
                         "streaming": streaming,
                         "chain_type": message.type,
+                        "message_id": message_id,
                     },
                 )
             elif isinstance(comp, Json):
@@ -54,6 +59,7 @@ class WebChatMessageEvent(AstrMessageEvent):
                         "data": json.dumps(comp.data, ensure_ascii=False),
                         "streaming": streaming,
                         "chain_type": message.type,
+                        "message_id": message_id,
                     },
                 )
             elif isinstance(comp, Image):
@@ -69,6 +75,7 @@ class WebChatMessageEvent(AstrMessageEvent):
                         "type": "image",
                         "data": data,
                         "streaming": streaming,
+                        "message_id": message_id,
                     },
                 )
             elif isinstance(comp, Record):
@@ -84,6 +91,7 @@ class WebChatMessageEvent(AstrMessageEvent):
                         "type": "record",
                         "data": data,
                         "streaming": streaming,
+                        "message_id": message_id,
                     },
                 )
             elif isinstance(comp, File):
@@ -94,12 +102,13 @@ class WebChatMessageEvent(AstrMessageEvent):
                 filename = f"{uuid.uuid4()!s}{ext}"
                 dest_path = os.path.join(imgs_dir, filename)
                 shutil.copy2(file_path, dest_path)
-                data = f"[FILE]{filename}|{original_name}"
+                data = f"[FILE]{filename}"
                 await web_chat_back_queue.put(
                     {
                         "type": "file",
                         "data": data,
                         "streaming": streaming,
+                        "message_id": message_id,
                     },
                 )
             else:
@@ -108,7 +117,8 @@ class WebChatMessageEvent(AstrMessageEvent):
         return data
 
     async def send(self, message: MessageChain | None):
-        await WebChatMessageEvent._send(message, session_id=self.session_id)
+        message_id = self.message_obj.message_id
+        await WebChatMessageEvent._send(message_id, message, session_id=self.session_id)
         await super().send(MessageChain([]))
 
     async def send_streaming(self, generator, use_fallback: bool = False):
@@ -116,6 +126,7 @@ class WebChatMessageEvent(AstrMessageEvent):
         reasoning_content = ""
         cid = self.session_id.split("!")[-1]
         web_chat_back_queue = webchat_queue_mgr.get_or_create_back_queue(cid)
+        message_id = self.message_obj.message_id
         async for chain in generator:
             # if chain.type == "break" and final_data:
             #     # 分割符
@@ -130,7 +141,8 @@ class WebChatMessageEvent(AstrMessageEvent):
             #     continue
 
             r = await WebChatMessageEvent._send(
-                chain,
+                message_id=message_id,
+                message=chain,
                 session_id=self.session_id,
                 streaming=True,
             )
@@ -147,6 +159,7 @@ class WebChatMessageEvent(AstrMessageEvent):
                 "data": final_data,
                 "reasoning": reasoning_content,
                 "streaming": True,
+                "message_id": message_id,
             },
         )
         await super().send_streaming(generator, use_fallback)

astrbot/core/provider/sources/anthropic_source.py

@@ -127,6 +127,50 @@ class ProviderAnthropic(Provider):
                         ],
                     },
                 )
+            elif message["role"] == "user":
+                if isinstance(message.get("content"), list):
+                    converted_content = []
+                    for part in message["content"]:
+                        if part.get("type") == "image_url":
+                            # Convert OpenAI image_url format to Anthropic image format
+                            image_url_data = part.get("image_url", {})
+                            url = image_url_data.get("url", "")
+                            if url.startswith("data:"):
+                                try:
+                                    _, base64_data = url.split(",", 1)
+                                    # Detect actual image format from binary data
+                                    image_bytes = base64.b64decode(base64_data)
+                                    media_type = self._detect_image_mime_type(
+                                        image_bytes
+                                    )
+                                    converted_content.append(
+                                        {
+                                            "type": "image",
+                                            "source": {
+                                                "type": "base64",
+                                                "media_type": media_type,
+                                                "data": base64_data,
+                                            },
+                                        }
+                                    )
+                                except ValueError:
+                                    logger.warning(
+                                        f"Failed to parse image data URI: {url[:50]}..."
+                                    )
+                            else:
+                                logger.warning(
+                                    f"Unsupported image URL format for Anthropic: {url[:50]}..."
+                                )
+                        else:
+                            converted_content.append(part)
+                    new_messages.append(
+                        {
+                            "role": "user",
+                            "content": converted_content,
+                        }
+                    )
+                else:
+                    new_messages.append(message)
             else:
                 new_messages.append(message)
 

astrbot/core/sandbox/booters/base.py

@@ -0,0 +1,31 @@
+from ..olayer import FileSystemComponent, PythonComponent, ShellComponent
+
+
+class SandboxBooter:
+    @property
+    def fs(self) -> FileSystemComponent: ...
+
+    @property
+    def python(self) -> PythonComponent: ...
+
+    @property
+    def shell(self) -> ShellComponent: ...
+
+    async def boot(self, session_id: str) -> None: ...
+
+    async def shutdown(self) -> None: ...
+
+    async def upload_file(self, path: str, file_name: str) -> dict:
+        """Upload file to sandbox.
+
+        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."""
+        ...
+
+    async def available(self) -> bool:
+        """Check if the sandbox is available."""
+        ...