AstrBot 4.13.2__py3-none-any.whl → 4.14.1__py3-none-any.whl

astrbot/dashboard/routes/cron.py

@@ -0,0 +1,174 @@
+import traceback
+from datetime import datetime
+
+from quart import jsonify, request
+
+from astrbot.core import logger
+from astrbot.core.core_lifecycle import AstrBotCoreLifecycle
+
+from .route import Response, Route, RouteContext
+
+
+class CronRoute(Route):
+    def __init__(
+        self, context: RouteContext, core_lifecycle: AstrBotCoreLifecycle
+    ) -> None:
+        super().__init__(context)
+        self.core_lifecycle = core_lifecycle
+        self.routes = [
+            ("/cron/jobs", ("GET", self.list_jobs)),
+            ("/cron/jobs", ("POST", self.create_job)),
+            ("/cron/jobs/<job_id>", ("PATCH", self.update_job)),
+            ("/cron/jobs/<job_id>", ("DELETE", self.delete_job)),
+        ]
+        self.register_routes()
+
+    def _serialize_job(self, job):
+        data = job.model_dump() if hasattr(job, "model_dump") else job.__dict__
+        for k in ["created_at", "updated_at", "last_run_at", "next_run_time"]:
+            if isinstance(data.get(k), datetime):
+                data[k] = data[k].isoformat()
+        # expose note explicitly for UI (prefer payload.note then description)
+        payload = data.get("payload") or {}
+        data["note"] = payload.get("note") or data.get("description") or ""
+        data["run_at"] = payload.get("run_at")
+        data["run_once"] = data.get("run_once", False)
+        # status is internal; hide to avoid implying one-time completion for recurring jobs
+        data.pop("status", None)
+        return data
+
+    async def list_jobs(self):
+        try:
+            cron_mgr = self.core_lifecycle.cron_manager
+            if cron_mgr is None:
+                return jsonify(
+                    Response().error("Cron manager not initialized").__dict__
+                )
+            job_type = request.args.get("type")
+            jobs = await cron_mgr.list_jobs(job_type)
+            data = [self._serialize_job(j) for j in jobs]
+            return jsonify(Response().ok(data=data).__dict__)
+        except Exception as e:  # noqa: BLE001
+            logger.error(traceback.format_exc())
+            return jsonify(Response().error(f"Failed to list jobs: {e!s}").__dict__)
+
+    async def create_job(self):
+        try:
+            cron_mgr = self.core_lifecycle.cron_manager
+            if cron_mgr is None:
+                return jsonify(
+                    Response().error("Cron manager not initialized").__dict__
+                )
+
+            payload = await request.json
+            if not isinstance(payload, dict):
+                return jsonify(Response().error("Invalid payload").__dict__)
+
+            name = payload.get("name") or "active_agent_task"
+            cron_expression = payload.get("cron_expression")
+            note = payload.get("note") or payload.get("description") or name
+            session = payload.get("session")
+            persona_id = payload.get("persona_id")
+            provider_id = payload.get("provider_id")
+            timezone = payload.get("timezone")
+            enabled = bool(payload.get("enabled", True))
+            run_once = bool(payload.get("run_once", False))
+            run_at = payload.get("run_at")
+
+            if not session:
+                return jsonify(Response().error("session is required").__dict__)
+            if run_once and not run_at:
+                return jsonify(
+                    Response().error("run_at is required when run_once=true").__dict__
+                )
+            if (not run_once) and not cron_expression:
+                return jsonify(
+                    Response()
+                    .error("cron_expression is required when run_once=false")
+                    .__dict__
+                )
+            if run_once and cron_expression:
+                cron_expression = None  # ignore cron when run_once specified
+            run_at_dt = None
+            if run_at:
+                try:
+                    run_at_dt = datetime.fromisoformat(str(run_at))
+                except Exception:
+                    return jsonify(
+                        Response().error("run_at must be ISO datetime").__dict__
+                    )
+
+            job_payload = {
+                "session": session,
+                "note": note,
+                "persona_id": persona_id,
+                "provider_id": provider_id,
+                "run_at": run_at,
+                "origin": "api",
+            }
+
+            job = await cron_mgr.add_active_job(
+                name=name,
+                cron_expression=cron_expression,
+                payload=job_payload,
+                description=note,
+                timezone=timezone,
+                enabled=enabled,
+                run_once=run_once,
+                run_at=run_at_dt,
+            )
+
+            return jsonify(Response().ok(data=self._serialize_job(job)).__dict__)
+        except Exception as e:  # noqa: BLE001
+            logger.error(traceback.format_exc())
+            return jsonify(Response().error(f"Failed to create job: {e!s}").__dict__)
+
+    async def update_job(self, job_id: str):
+        try:
+            cron_mgr = self.core_lifecycle.cron_manager
+            if cron_mgr is None:
+                return jsonify(
+                    Response().error("Cron manager not initialized").__dict__
+                )
+
+            payload = await request.json
+            if not isinstance(payload, dict):
+                return jsonify(Response().error("Invalid payload").__dict__)
+
+            updates = {
+                "name": payload.get("name"),
+                "cron_expression": payload.get("cron_expression"),
+                "description": payload.get("description"),
+                "enabled": payload.get("enabled"),
+                "timezone": payload.get("timezone"),
+                "run_once": payload.get("run_once"),
+                "payload": payload.get("payload"),
+            }
+            # remove None values to avoid unwanted resets
+            updates = {k: v for k, v in updates.items() if v is not None}
+            if "run_at" in payload:
+                updates.setdefault("payload", {})
+                if updates["payload"] is None:
+                    updates["payload"] = {}
+                updates["payload"]["run_at"] = payload.get("run_at")
+
+            job = await cron_mgr.update_job(job_id, **updates)
+            if not job:
+                return jsonify(Response().error("Job not found").__dict__)
+            return jsonify(Response().ok(data=self._serialize_job(job)).__dict__)
+        except Exception as e:  # noqa: BLE001
+            logger.error(traceback.format_exc())
+            return jsonify(Response().error(f"Failed to update job: {e!s}").__dict__)
+
+    async def delete_job(self, job_id: str):
+        try:
+            cron_mgr = self.core_lifecycle.cron_manager
+            if cron_mgr is None:
+                return jsonify(
+                    Response().error("Cron manager not initialized").__dict__
+                )
+            await cron_mgr.delete_job(job_id)
+            return jsonify(Response().ok(message="deleted").__dict__)
+        except Exception as e:  # noqa: BLE001
+            logger.error(traceback.format_exc())
+            return jsonify(Response().error(f"Failed to delete job: {e!s}").__dict__)

astrbot/dashboard/routes/log.py

@@ -31,6 +31,16 @@ class LogRoute(Route):
             view_func=self.log_history,
             methods=["GET"],
         )
+        self.app.add_url_rule(
+            "/api/trace/settings",
+            view_func=self.get_trace_settings,
+            methods=["GET"],
+        )
+        self.app.add_url_rule(
+            "/api/trace/settings",
+            view_func=self.update_trace_settings,
+            methods=["POST"],
+        )
 
     async def _replay_cached_logs(
         self, last_event_id: str
@@ -106,3 +116,29 @@ class LogRoute(Route):
         except Exception as e:
             logger.error(f"获取日志历史失败: {e}")
             return Response().error(f"获取日志历史失败: {e}").__dict__
+
+    async def get_trace_settings(self):
+        """获取 Trace 设置"""
+        try:
+            trace_enable = self.config.get("trace_enable", True)
+            return Response().ok(data={"trace_enable": trace_enable}).__dict__
+        except Exception as e:
+            logger.error(f"获取 Trace 设置失败: {e}")
+            return Response().error(f"获取 Trace 设置失败: {e}").__dict__
+
+    async def update_trace_settings(self):
+        """更新 Trace 设置"""
+        try:
+            data = await request.json
+            if data is None:
+                return Response().error("请求数据为空").__dict__
+
+            trace_enable = data.get("trace_enable")
+            if trace_enable is not None:
+                self.config["trace_enable"] = bool(trace_enable)
+                self.config.save_config()
+
+            return Response().ok(message="Trace 设置已更新").__dict__
+        except Exception as e:
+            logger.error(f"更新 Trace 设置失败: {e}")
+            return Response().error(f"更新 Trace 设置失败: {e}").__dict__

astrbot/dashboard/routes/plugin.py

@@ -315,6 +315,17 @@ class PluginRoute(Route):
                 "display_name": plugin.display_name,
                 "logo": f"/api/file/{logo_url}" if logo_url else None,
             }
+            # 检查是否为全空的幽灵插件
+            if not any(
+                [
+                    plugin.name,
+                    plugin.author,
+                    plugin.desc,
+                    plugin.version,
+                    plugin.display_name,
+                ]
+            ):
+                continue
             _plugin_resp.append(_t)
         return (
             Response()

astrbot/dashboard/routes/skills.py

@@ -4,7 +4,6 @@ import traceback
 from quart import request
 
 from astrbot.core import DEMO_MODE, logger
-from astrbot.core.computer.computer_client import get_booter
 from astrbot.core.skills.skill_manager import SkillManager
 from astrbot.core.utils.astrbot_path import get_astrbot_temp_path
 
@@ -25,14 +24,22 @@ class SkillsRoute(Route):
 
     async def get_skills(self):
         try:
-            cfg = self.core_lifecycle.astrbot_config.get("provider_settings", {}).get(
-                "skills", {}
+            provider_settings = self.core_lifecycle.astrbot_config.get(
+                "provider_settings", {}
             )
-            runtime = cfg.get("runtime", "local")
+            runtime = provider_settings.get("computer_use_runtime", "local")
             skills = SkillManager().list_skills(
                 active_only=False, runtime=runtime, show_sandbox_path=False
             )
-            return Response().ok([skill.__dict__ for skill in skills]).__dict__
+            return (
+                Response()
+                .ok(
+                    {
+                        "skills": [skill.__dict__ for skill in skills],
+                    }
+                )
+                .__dict__
+            )
         except Exception as e:
             logger.error(traceback.format_exc())
             return Response().error(str(e)).__dict__
@@ -60,41 +67,9 @@ class SkillsRoute(Route):
             temp_path = os.path.join(temp_dir, filename)
             await file.save(temp_path)
 
-            cfg = self.core_lifecycle.astrbot_config.get("provider_settings", {}).get(
-                "skills", {}
-            )
-            runtime = cfg.get("runtime", "local")
-            if runtime == "sandbox":
-                sandbox_enabled = (
-                    self.core_lifecycle.astrbot_config.get("provider_settings", {})
-                    .get("sandbox", {})
-                    .get("enable", False)
-                )
-                if not sandbox_enabled:
-                    return (
-                        Response()
-                        .error(
-                            "Sandbox is not enabled. Please enable sandbox before using sandbox runtime."
-                        )
-                        .__dict__
-                    )
             skill_mgr = SkillManager()
             skill_name = skill_mgr.install_skill_from_zip(temp_path, overwrite=True)
 
-            if runtime == "sandbox":
-                sb = await get_booter(self.core_lifecycle.star_context, "skills-upload")
-                remote_root = "/home/shared/skills"
-                remote_zip = f"{remote_root}/{skill_name}.zip"
-                await sb.shell.exec(f"mkdir -p {remote_root}")
-                upload_result = await sb.upload_file(temp_path, remote_zip)
-                if not upload_result.get("success", False):
-                    return (
-                        Response().error("Failed to upload skill to sandbox").__dict__
-                    )
-                await sb.shell.exec(
-                    f"unzip -o {remote_zip} -d {remote_root} && rm -f {remote_zip}"
-                )
-
             return (
                 Response()
                 .ok({"name": skill_name}, "Skill uploaded successfully.")

astrbot/dashboard/routes/subagent.py

@@ -0,0 +1,117 @@
+import traceback
+
+from quart import jsonify, request
+
+from astrbot.core import logger
+from astrbot.core.agent.handoff import HandoffTool
+from astrbot.core.core_lifecycle import AstrBotCoreLifecycle
+
+from .route import Response, Route, RouteContext
+
+
+class SubAgentRoute(Route):
+    def __init__(
+        self,
+        context: RouteContext,
+        core_lifecycle: AstrBotCoreLifecycle,
+    ) -> None:
+        super().__init__(context)
+        self.core_lifecycle = core_lifecycle
+        # NOTE: dict cannot hold duplicate keys; use list form to register multiple
+        # methods for the same path.
+        self.routes = [
+            ("/subagent/config", ("GET", self.get_config)),
+            ("/subagent/config", ("POST", self.update_config)),
+            ("/subagent/available-tools", ("GET", self.get_available_tools)),
+        ]
+        self.register_routes()
+
+    async def get_config(self):
+        try:
+            cfg = self.core_lifecycle.astrbot_config
+            data = cfg.get("subagent_orchestrator")
+
+            # First-time access: return a sane default instead of erroring.
+            if not isinstance(data, dict):
+                data = {
+                    "main_enable": False,
+                    "remove_main_duplicate_tools": False,
+                    "agents": [],
+                }
+
+            # Backward compatibility: older config used `enable`.
+            if (
+                isinstance(data, dict)
+                and "main_enable" not in data
+                and "enable" in data
+            ):
+                data["main_enable"] = bool(data.get("enable", False))
+
+            # Ensure required keys exist.
+            data.setdefault("main_enable", False)
+            data.setdefault("remove_main_duplicate_tools", False)
+            data.setdefault("agents", [])
+
+            # Backward/forward compatibility: ensure each agent contains provider_id.
+            # None means follow global/default provider settings.
+            if isinstance(data.get("agents"), list):
+                for a in data["agents"]:
+                    if isinstance(a, dict):
+                        a.setdefault("provider_id", None)
+                        a.setdefault("persona_id", None)
+            return jsonify(Response().ok(data=data).__dict__)
+        except Exception as e:
+            logger.error(traceback.format_exc())
+            return jsonify(Response().error(f"获取 subagent 配置失败: {e!s}").__dict__)
+
+    async def update_config(self):
+        try:
+            data = await request.json
+            if not isinstance(data, dict):
+                return jsonify(Response().error("配置必须为 JSON 对象").__dict__)
+
+            cfg = self.core_lifecycle.astrbot_config
+            cfg["subagent_orchestrator"] = data
+
+            # Persist to cmd_config.json
+            # AstrBotConfigManager does not expose a `save()` method; persist via AstrBotConfig.
+            cfg.save_config()
+
+            # Reload dynamic handoff tools if orchestrator exists
+            orch = getattr(self.core_lifecycle, "subagent_orchestrator", None)
+            if orch is not None:
+                await orch.reload_from_config(data)
+
+            return jsonify(Response().ok(message="保存成功").__dict__)
+        except Exception as e:
+            logger.error(traceback.format_exc())
+            return jsonify(Response().error(f"保存 subagent 配置失败: {e!s}").__dict__)
+
+    async def get_available_tools(self):
+        """Return all registered tools (name/description/parameters/active/origin).
+
+        UI can use this to build a multi-select list for subagent tool assignment.
+        """
+        try:
+            tool_mgr = self.core_lifecycle.provider_manager.llm_tools
+            tools_dict = []
+            for tool in tool_mgr.func_list:
+                # Prevent recursive routing: subagents should not be able to select
+                # the handoff (transfer_to_*) tools as their own mounted tools.
+                if isinstance(tool, HandoffTool):
+                    continue
+                if tool.handler_module_path == "core.subagent_orchestrator":
+                    continue
+                tools_dict.append(
+                    {
+                        "name": tool.name,
+                        "description": tool.description,
+                        "parameters": tool.parameters,
+                        "active": tool.active,
+                        "handler_module_path": tool.handler_module_path,
+                    }
+                )
+            return jsonify(Response().ok(data=tools_dict).__dict__)
+        except Exception as e:
+            logger.error(traceback.format_exc())
+            return jsonify(Response().error(f"获取可用工具失败: {e!s}").__dict__)

astrbot/dashboard/routes/tools.py

@@ -130,19 +130,25 @@ class ToolsRoute(Route):
             server_data = await request.json
 
             name = server_data.get("name", "")
+            old_name = server_data.get("oldName") or name
 
             if not name:
                 return Response().error("服务器名称不能为空").__dict__
 
             config = self.tool_mgr.load_mcp_config()
 
-            if name not in config["mcpServers"]:
-                return Response().error(f"服务器 {name} 不存在").__dict__
+            if old_name not in config["mcpServers"]:
+                return Response().error(f"服务器 {old_name} 不存在").__dict__
+
+            is_rename = name != old_name
+
+            if name in config["mcpServers"] and is_rename:
+                return Response().error(f"服务器 {name} 已存在").__dict__
 
             # 获取活动状态
             active = server_data.get(
                 "active",
-                config["mcpServers"][name].get("active", True),
+                config["mcpServers"][old_name].get("active", True),
             )
 
             # 创建新的配置对象
@@ -153,7 +159,13 @@ class ToolsRoute(Route):
 
             # 复制所有配置字段
             for key, value in server_data.items():
-                if key not in ["name", "active", "tools", "errlogs"]:  # 排除特殊字段
+                if key not in [
+                    "name",
+                    "active",
+                    "tools",
+                    "errlogs",
+                    "oldName",
+                ]:  # 排除特殊字段
                     if key == "mcpServers":
                         key_0 = list(server_data["mcpServers"].keys())[
                             0
@@ -165,29 +177,42 @@ class ToolsRoute(Route):
 
             # 如果只更新活动状态，保留原始配置
             if only_update_active:
-                for key, value in config["mcpServers"][name].items():
+                for key, value in config["mcpServers"][old_name].items():
                     if key != "active":  # 除了active之外的所有字段都保留
                         server_config[key] = value
 
-            config["mcpServers"][name] = server_config
+            # config["mcpServers"][name] = server_config
+            if is_rename:
+                config["mcpServers"].pop(old_name)
+                config["mcpServers"][name] = server_config
+            else:
+                config["mcpServers"][name] = server_config
 
             if self.tool_mgr.save_mcp_config(config):
                 # 处理MCP客户端状态变化
                 if active:
-                    if name in self.tool_mgr.mcp_client_dict or not only_update_active:
+                    if (
+                        old_name in self.tool_mgr.mcp_client_dict
+                        or not only_update_active
+                        or is_rename
+                    ):
                         try:
-                            await self.tool_mgr.disable_mcp_server(name, timeout=10)
+                            await self.tool_mgr.disable_mcp_server(old_name, timeout=10)
                         except TimeoutError as e:
                             return (
                                 Response()
-                                .error(f"启用前停用 MCP 服务器时 {name} 超时: {e!s}")
+                                .error(
+                                    f"启用前停用 MCP 服务器时 {old_name} 超时: {e!s}"
+                                )
                                 .__dict__
                             )
                         except Exception as e:
                             logger.error(traceback.format_exc())
                             return (
                                 Response()
-                                .error(f"启用前停用 MCP 服务器时 {name} 失败: {e!s}")
+                                .error(
+                                    f"启用前停用 MCP 服务器时 {old_name} 失败: {e!s}"
+                                )
                                 .__dict__
                             )
                     try:
@@ -208,18 +233,20 @@ class ToolsRoute(Route):
                             .__dict__
                         )
                 # 如果要停用服务器
-                elif name in self.tool_mgr.mcp_client_dict:
+                elif old_name in self.tool_mgr.mcp_client_dict:
                     try:
-                        await self.tool_mgr.disable_mcp_server(name, timeout=10)
+                        await self.tool_mgr.disable_mcp_server(old_name, timeout=10)
                     except TimeoutError:
                         return (
-                            Response().error(f"停用 MCP 服务器 {name} 超时。").__dict__
+                            Response()
+                            .error(f"停用 MCP 服务器 {old_name} 超时。")
+                            .__dict__
                         )
                     except Exception as e:
                         logger.error(traceback.format_exc())
                         return (
                             Response()
-                            .error(f"停用 MCP 服务器 {name} 失败: {e!s}")
+                            .error(f"停用 MCP 服务器 {old_name} 失败: {e!s}")
                             .__dict__
                         )
 

astrbot/dashboard/server.py

@@ -26,6 +26,7 @@ from .routes.live_chat import LiveChatRoute
 from .routes.platform import PlatformRoute
 from .routes.route import Response, RouteContext
 from .routes.session_management import SessionManagementRoute
+from .routes.subagent import SubAgentRoute
 from .routes.t2i import T2iRoute
 
 APP: Quart
@@ -79,6 +80,7 @@ class AstrBotDashboard:
         self.chat_route = ChatRoute(self.context, db, core_lifecycle)
         self.chatui_project_route = ChatUIProjectRoute(self.context, db)
         self.tools_root = ToolsRoute(self.context, core_lifecycle)
+        self.subagent_route = SubAgentRoute(self.context, core_lifecycle)
         self.skills_route = SkillsRoute(self.context, core_lifecycle)
         self.conversation_route = ConversationRoute(self.context, db, core_lifecycle)
         self.file_route = FileRoute(self.context)
@@ -88,6 +90,7 @@ class AstrBotDashboard:
             core_lifecycle,
         )
         self.persona_route = PersonaRoute(self.context, db, core_lifecycle)
+        self.cron_route = CronRoute(self.context, core_lifecycle)
         self.t2i_route = T2iRoute(self.context, core_lifecycle)
         self.kb_route = KnowledgeBaseRoute(self.context, core_lifecycle)
         self.platform_route = PlatformRoute(self.context, core_lifecycle)

{astrbot-4.13.2.dist-info → astrbot-4.14.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AstrBot
-Version: 4.13.2
+Version: 4.14.1
 Summary: Easy-to-use multi-platform LLM chatbot and development framework
 License-File: LICENSE
 Keywords: Astrbot,Astrbot Module,Astrbot Plugin
@@ -96,7 +96,7 @@ Description-Content-Type: text/markdown
 <a href="https://github.com/AstrBotDevs/AstrBot/issues">问题提交</a>
 </div>
 
-AstrBot 是一个开源的一站式 Agent 聊天机器人平台，可接入主流即时通讯软件，为个人、开发者和团队打造可靠、可扩展的对话式智能基础设施。无论是个人 AI 伙伴、智能客服、自动化助手，还是企业知识库，AstrBot 都能在你的即时通讯软件平台的工作流中快速构建生产可用的 AI 应用。
+AstrBot 是一个开源的一站式 Agentic 个人和群聊助手，可在 QQ、Telegram、企业微信、飞书、钉钉、Slack、等数十款主流即时通讯软件上部署，此外还内置类似 OpenWebUI 的轻量化 ChatUI，为个人、开发者和团队打造可靠、可扩展的对话式智能基础设施。无论是个人 AI 伙伴、智能客服、自动化助手，还是企业知识库，AstrBot 都能在你的即时通讯软件平台的工作流中快速构建 AI 应用。
 
 ![521771166-00782c4c-4437-4d97-aabc-605e3738da5c (1)](https://github.com/user-attachments/assets/61e7b505-f7db-41aa-a75f-4ef8f079b8ba)
 
@@ -112,6 +112,25 @@ AstrBot 是一个开源的一站式 Agent 聊天机器人平台，可接入主
 7. 🌈 Web ChatUI 支持，ChatUI 内置代理沙盒、网页搜索等。
 8. 🌐 国际化（i18n）支持。
 
+<br>
+
+<table align="center">
+  <tr align="center">
+    <th>💙 角色扮演 & 情感陪伴</th>
+    <th>✨ 主动式 Agent</th>
+    <th>🚀 通用 Agentic 能力</th>
+    <th>🧩 900+ 社区插件</th>
+  </tr>
+  <tr>
+    <td align="center"><p align="center"><img width="984" height="1746" alt="99b587c5d35eea09d84f33e6cf6cfd4f" src="https://github.com/user-attachments/assets/89196061-3290-458d-b51f-afa178049f84" /></p></td>
+    <td align="center"><p align="center"><img width="976" height="1612" alt="c449acd838c41d0915cc08a3824025b1" src="https://github.com/user-attachments/assets/f75368b4-e022-41dc-a9e0-131c3e73e32e" /></p></td>
+    <td align="center"><p align="center"><img width="974" height="1732" alt="image" src="https://github.com/user-attachments/assets/e22a3968-87d7-4708-a7cd-e7f198c7c32e" /></p></td>
+    <td align="center"><p align="center"><img width="976" height="1734" alt="image" src="https://github.com/user-attachments/assets/0952b395-6b4a-432a-8a50-c294b7f89750" /></p></td>
+  </tr>
+</table>
+
+陪伴与能力**从来不应该是**对立面。我们希望创造的是一个既能理解情绪、给予陪伴，也能可靠完成工作的机器人——致敬[ATRI](https://zh.wikipedia.org/zh-cn/ATRI_-My_Dear_Moments-)。
+
 ## 快速开始
 
 #### Docker 部署(推荐 🥳)