AstrBot 3.5.6__py3-none-any.whl → 4.7.0__py3-none-any.whl

astrbot/dashboard/routes/t2i.py

@@ -0,0 +1,233 @@
+# astrbot/dashboard/routes/t2i.py
+
+from dataclasses import asdict
+
+from quart import jsonify, request
+
+from astrbot.core import logger
+from astrbot.core.core_lifecycle import AstrBotCoreLifecycle
+from astrbot.core.utils.t2i.template_manager import TemplateManager
+
+from .route import Response, Route, RouteContext
+
+
+class T2iRoute(Route):
+    def __init__(self, context: RouteContext, core_lifecycle: AstrBotCoreLifecycle):
+        super().__init__(context)
+        self.core_lifecycle = core_lifecycle
+        self.config = core_lifecycle.astrbot_config
+        self.manager = TemplateManager()
+        # 使用列表保证路由注册顺序，避免 /<name> 路由优先匹配 /reset_default
+        self.routes = [
+            ("/t2i/templates", ("GET", self.list_templates)),
+            ("/t2i/templates/active", ("GET", self.get_active_template)),
+            ("/t2i/templates/create", ("POST", self.create_template)),
+            ("/t2i/templates/reset_default", ("POST", self.reset_default_template)),
+            ("/t2i/templates/set_active", ("POST", self.set_active_template)),
+            # 动态路由应该在静态路由之后注册
+            (
+                "/t2i/templates/<name>",
+                [
+                    ("GET", self.get_template),
+                    ("PUT", self.update_template),
+                    ("DELETE", self.delete_template),
+                ],
+            ),
+        ]
+        self.register_routes()
+
+    async def list_templates(self):
+        """获取所有T2I模板列表"""
+        try:
+            templates = self.manager.list_templates()
+            return jsonify(asdict(Response().ok(data=templates)))
+        except Exception as e:
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 500
+            return response
+
+    async def get_active_template(self):
+        """获取当前激活的T2I模板"""
+        try:
+            active_template = self.config.get("t2i_active_template", "base")
+            return jsonify(
+                asdict(Response().ok(data={"active_template": active_template})),
+            )
+        except Exception as e:
+            logger.error("Error in get_active_template", exc_info=True)
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 500
+            return response
+
+    async def get_template(self, name: str):
+        """获取指定名称的T2I模板内容"""
+        try:
+            content = self.manager.get_template(name)
+            return jsonify(
+                asdict(Response().ok(data={"name": name, "content": content})),
+            )
+        except FileNotFoundError:
+            response = jsonify(asdict(Response().error("Template not found")))
+            response.status_code = 404
+            return response
+        except Exception as e:
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 500
+            return response
+
+    async def create_template(self):
+        """创建一个新的T2I模板"""
+        try:
+            data = await request.json
+            name = data.get("name")
+            content = data.get("content")
+            if not name or not content:
+                response = jsonify(
+                    asdict(Response().error("Name and content are required.")),
+                )
+                response.status_code = 400
+                return response
+            name = name.strip()
+
+            self.manager.create_template(name, content)
+            response = jsonify(
+                asdict(
+                    Response().ok(
+                        data={"name": name},
+                        message="Template created successfully.",
+                    ),
+                ),
+            )
+            response.status_code = 201
+            return response
+        except FileExistsError:
+            response = jsonify(
+                asdict(Response().error("Template with this name already exists.")),
+            )
+            response.status_code = 409
+            return response
+        except ValueError as e:
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 400
+            return response
+        except Exception as e:
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 500
+            return response
+
+    async def update_template(self, name: str):
+        """更新一个已存在的T2I模板"""
+        try:
+            name = name.strip()
+            data = await request.json
+            content = data.get("content")
+            if content is None:
+                response = jsonify(asdict(Response().error("Content is required.")))
+                response.status_code = 400
+                return response
+
+            self.manager.update_template(name, content)
+
+            # 检查更新的是否为当前激活的模板，如果是，则热重载
+            active_template = self.config.get("t2i_active_template", "base")
+            if name == active_template:
+                await self.core_lifecycle.reload_pipeline_scheduler("default")
+                message = f"模板 '{name}' 已更新并重新加载。"
+            else:
+                message = f"模板 '{name}' 已更新。"
+
+            return jsonify(asdict(Response().ok(data={"name": name}, message=message)))
+        except ValueError as e:
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 400
+            return response
+        except Exception as e:
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 500
+            return response
+
+    async def delete_template(self, name: str):
+        """删除一个T2I模板"""
+        try:
+            name = name.strip()
+            self.manager.delete_template(name)
+            return jsonify(
+                asdict(Response().ok(message="Template deleted successfully.")),
+            )
+        except FileNotFoundError:
+            response = jsonify(asdict(Response().error("Template not found.")))
+            response.status_code = 404
+            return response
+        except ValueError as e:
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 400
+            return response
+        except Exception as e:
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 500
+            return response
+
+    async def set_active_template(self):
+        """设置当前活动的T2I模板"""
+        try:
+            data = await request.json
+            name = data.get("name")
+            if not name:
+                response = jsonify(asdict(Response().error("模板名称(name)不能为空。")))
+                response.status_code = 400
+                return response
+
+            # 验证模板文件是否存在
+            self.manager.get_template(name)
+
+            # 更新配置
+            config = self.config
+            config["t2i_active_template"] = name
+            config.save_config(config)
+
+            # 热重载以应用更改
+            await self.core_lifecycle.reload_pipeline_scheduler("default")
+
+            return jsonify(asdict(Response().ok(message=f"模板 '{name}' 已成功应用。")))
+
+        except FileNotFoundError:
+            response = jsonify(
+                asdict(Response().error(f"模板 '{name}' 不存在，无法应用。")),
+            )
+            response.status_code = 404
+            return response
+        except Exception as e:
+            logger.error("Error in set_active_template", exc_info=True)
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 500
+            return response
+
+    async def reset_default_template(self):
+        """重置默认的'base'模板"""
+        try:
+            self.manager.reset_default_template()
+
+            # 更新配置，将激活模板也重置为'base'
+            config = self.config
+            config["t2i_active_template"] = "base"
+            config.save_config(config)
+
+            # 热重载以应用更改
+            await self.core_lifecycle.reload_pipeline_scheduler("default")
+
+            return jsonify(
+                asdict(
+                    Response().ok(
+                        message="Default template has been reset and activated.",
+                    ),
+                ),
+            )
+        except FileNotFoundError as e:
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 404
+            return response
+        except Exception as e:
+            logger.error("Error in reset_default_template", exc_info=True)
+            response = jsonify(asdict(Response().error(str(e))))
+            response.status_code = 500
+            return response

astrbot/dashboard/routes/tools.py

@@ -1,18 +1,21 @@
-import os
-import json
-import aiohttp
 import traceback
-from .route import Route, Response, RouteContext
+
 from quart import request
-from astrbot.core.core_lifecycle import AstrBotCoreLifecycle
+
 from astrbot.core import logger
+from astrbot.core.core_lifecycle import AstrBotCoreLifecycle
+from astrbot.core.star import star_map
+
+from .route import Response, Route, RouteContext
 
 DEFAULT_MCP_CONFIG = {"mcpServers": {}}
 
 
 class ToolsRoute(Route):
     def __init__(
-        self, context: RouteContext, core_lifecycle: AstrBotCoreLifecycle
+        self,
+        context: RouteContext,
+        core_lifecycle: AstrBotCoreLifecycle,
     ) -> None:
         super().__init__(context)
         self.core_lifecycle = core_lifecycle
@@ -21,44 +24,17 @@ class ToolsRoute(Route):
             "/tools/mcp/add": ("POST", self.add_mcp_server),
             "/tools/mcp/update": ("POST", self.update_mcp_server),
             "/tools/mcp/delete": ("POST", self.delete_mcp_server),
-            "/tools/mcp/market": ("GET", self.get_mcp_markets),
+            "/tools/mcp/test": ("POST", self.test_mcp_connection),
+            "/tools/list": ("GET", self.get_tool_list),
+            "/tools/toggle-tool": ("POST", self.toggle_tool),
+            "/tools/mcp/sync-provider": ("POST", self.sync_provider),
         }
         self.register_routes()
         self.tool_mgr = self.core_lifecycle.provider_manager.llm_tools
 
-    @property
-    def mcp_config_path(self):
-        current_dir = os.path.dirname(os.path.abspath(__file__))
-        data_dir = os.path.abspath(os.path.join(current_dir, "../../../data"))
-        return os.path.join(data_dir, "mcp_server.json")
-
-    def load_mcp_config(self):
-        if not os.path.exists(self.mcp_config_path):
-            # 配置文件不存在，创建默认配置
-            os.makedirs(os.path.dirname(self.mcp_config_path), exist_ok=True)
-            with open(self.mcp_config_path, "w", encoding="utf-8") as f:
-                json.dump(DEFAULT_MCP_CONFIG, f, ensure_ascii=False, indent=4)
-            return DEFAULT_MCP_CONFIG
-
-        try:
-            with open(self.mcp_config_path, "r", encoding="utf-8") as f:
-                return json.load(f)
-        except Exception as e:
-            logger.error(f"加载 MCP 配置失败: {e}")
-            return DEFAULT_MCP_CONFIG
-
-    def save_mcp_config(self, config):
-        try:
-            with open(self.mcp_config_path, "w", encoding="utf-8") as f:
-                json.dump(config, f, ensure_ascii=False, indent=4)
-            return True
-        except Exception as e:
-            logger.error(f"保存 MCP 配置失败: {e}")
-            return False
-
     async def get_mcp_servers(self):
         try:
-            config = self.load_mcp_config()
+            config = self.tool_mgr.load_mcp_config()
             servers = []
 
             # 获取所有服务器并添加它们的工具列表
@@ -90,7 +66,7 @@ class ToolsRoute(Route):
             return Response().ok(servers).__dict__
         except Exception as e:
             logger.error(traceback.format_exc())
-            return Response().error(f"获取 MCP 服务器列表失败: {str(e)}").__dict__
+            return Response().error(f"获取 MCP 服务器列表失败: {e!s}").__dict__
 
     async def add_mcp_server(self):
         try:
@@ -121,28 +97,32 @@ class ToolsRoute(Route):
             if not has_valid_config:
                 return Response().error("必须提供有效的服务器配置").__dict__
 
-            config = self.load_mcp_config()
+            config = self.tool_mgr.load_mcp_config()
 
             if name in config["mcpServers"]:
                 return Response().error(f"服务器 {name} 已存在").__dict__
 
             config["mcpServers"][name] = server_config
 
-            if self.save_mcp_config(config):
-                # 动态初始化新MCP客户端
-                await self.tool_mgr.mcp_service_queue.put(
-                    {
-                        "type": "init",
-                        "name": name,
-                        "cfg": config["mcpServers"][name],
-                    }
-                )
+            if self.tool_mgr.save_mcp_config(config):
+                try:
+                    await self.tool_mgr.enable_mcp_server(
+                        name,
+                        server_config,
+                        timeout=30,
+                    )
+                except TimeoutError:
+                    return Response().error(f"启用 MCP 服务器 {name} 超时。").__dict__
+                except Exception as e:
+                    logger.error(traceback.format_exc())
+                    return (
+                        Response().error(f"启用 MCP 服务器 {name} 失败: {e!s}").__dict__
+                    )
                 return Response().ok(None, f"成功添加 MCP 服务器 {name}").__dict__
-            else:
-                return Response().error("保存配置失败").__dict__
+            return Response().error("保存配置失败").__dict__
         except Exception as e:
             logger.error(traceback.format_exc())
-            return Response().error(f"添加 MCP 服务器失败: {str(e)}").__dict__
+            return Response().error(f"添加 MCP 服务器失败: {e!s}").__dict__
 
     async def update_mcp_server(self):
         try:
@@ -153,14 +133,15 @@ class ToolsRoute(Route):
             if not name:
                 return Response().error("服务器名称不能为空").__dict__
 
-            config = self.load_mcp_config()
+            config = self.tool_mgr.load_mcp_config()
 
             if name not in config["mcpServers"]:
                 return Response().error(f"服务器 {name} 不存在").__dict__
 
             # 获取活动状态
             active = server_data.get(
-                "active", config["mcpServers"][name].get("active", True)
+                "active",
+                config["mcpServers"][name].get("active", True),
             )
 
             # 创建新的配置对象
@@ -189,49 +170,63 @@ class ToolsRoute(Route):
 
             config["mcpServers"][name] = server_config
 
-            if self.save_mcp_config(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:
-                        await self.tool_mgr.mcp_service_queue.put(
-                            {
-                                "type": "terminate",
-                                "name": name,
-                            }
+                        try:
+                            await self.tool_mgr.disable_mcp_server(name, timeout=10)
+                        except TimeoutError as e:
+                            return (
+                                Response()
+                                .error(f"启用前停用 MCP 服务器时 {name} 超时: {e!s}")
+                                .__dict__
+                            )
+                        except Exception as e:
+                            logger.error(traceback.format_exc())
+                            return (
+                                Response()
+                                .error(f"启用前停用 MCP 服务器时 {name} 失败: {e!s}")
+                                .__dict__
+                            )
+                    try:
+                        await self.tool_mgr.enable_mcp_server(
+                            name,
+                            config["mcpServers"][name],
+                            timeout=30,
                         )
-                        await self.tool_mgr.mcp_service_queue.put(
-                            {
-                                "type": "init",
-                                "name": name,
-                                "cfg": config["mcpServers"][name],
-                            }
+                    except TimeoutError:
+                        return (
+                            Response().error(f"启用 MCP 服务器 {name} 超时。").__dict__
                         )
-                    else:
-                        # 客户端不存在，初始化
-                        await self.tool_mgr.mcp_service_queue.put(
-                            {
-                                "type": "init",
-                                "name": name,
-                                "cfg": config["mcpServers"][name],
-                            }
+                    except Exception as e:
+                        logger.error(traceback.format_exc())
+                        return (
+                            Response()
+                            .error(f"启用 MCP 服务器 {name} 失败: {e!s}")
+                            .__dict__
                         )
-                else:
-                    # 如果要停用服务器
-                    if name in self.tool_mgr.mcp_client_dict:
-                        self.tool_mgr.mcp_service_queue.put_nowait(
-                            {
-                                "type": "terminate",
-                                "name": name,
-                            }
+                # 如果要停用服务器
+                elif name in self.tool_mgr.mcp_client_dict:
+                    try:
+                        await self.tool_mgr.disable_mcp_server(name, timeout=10)
+                    except TimeoutError:
+                        return (
+                            Response().error(f"停用 MCP 服务器 {name} 超时。").__dict__
+                        )
+                    except Exception as e:
+                        logger.error(traceback.format_exc())
+                        return (
+                            Response()
+                            .error(f"停用 MCP 服务器 {name} 失败: {e!s}")
+                            .__dict__
                         )
 
                 return Response().ok(None, f"成功更新 MCP 服务器 {name}").__dict__
-            else:
-                return Response().error("保存配置失败").__dict__
+            return Response().error("保存配置失败").__dict__
         except Exception as e:
             logger.error(traceback.format_exc())
-            return Response().error(f"更新 MCP 服务器失败: {str(e)}").__dict__
+            return Response().error(f"更新 MCP 服务器失败: {e!s}").__dict__
 
     async def delete_mcp_server(self):
         try:
@@ -241,50 +236,119 @@ class ToolsRoute(Route):
             if not name:
                 return Response().error("服务器名称不能为空").__dict__
 
-            config = self.load_mcp_config()
+            config = self.tool_mgr.load_mcp_config()
 
             if name not in config["mcpServers"]:
                 return Response().error(f"服务器 {name} 不存在").__dict__
 
-            # 删除服务器配置
             del config["mcpServers"][name]
 
-            if self.save_mcp_config(config):
-                # 关闭并删除MCP客户端
+            if self.tool_mgr.save_mcp_config(config):
                 if name in self.tool_mgr.mcp_client_dict:
-                    self.tool_mgr.mcp_service_queue.put_nowait(
-                        {
-                            "type": "terminate",
-                            "name": name,
-                        }
-                    )
-
+                    try:
+                        await self.tool_mgr.disable_mcp_server(name, timeout=10)
+                    except TimeoutError:
+                        return (
+                            Response().error(f"停用 MCP 服务器 {name} 超时。").__dict__
+                        )
+                    except Exception as e:
+                        logger.error(traceback.format_exc())
+                        return (
+                            Response()
+                            .error(f"停用 MCP 服务器 {name} 失败: {e!s}")
+                            .__dict__
+                        )
                 return Response().ok(None, f"成功删除 MCP 服务器 {name}").__dict__
+            return Response().error("保存配置失败").__dict__
+        except Exception as e:
+            logger.error(traceback.format_exc())
+            return Response().error(f"删除 MCP 服务器失败: {e!s}").__dict__
+
+    async def test_mcp_connection(self):
+        """测试 MCP 服务器连接"""
+        try:
+            server_data = await request.json
+            config = server_data.get("mcp_server_config", None)
+
+            if not isinstance(config, dict) or not config:
+                return Response().error("无效的 MCP 服务器配置").__dict__
+
+            if "mcpServers" in config:
+                keys = list(config["mcpServers"].keys())
+                if not keys:
+                    return Response().error("MCP 服务器配置不能为空").__dict__
+                if len(keys) > 1:
+                    return Response().error("一次只能配置一个 MCP 服务器配置").__dict__
+                config = config["mcpServers"][keys[0]]
+            elif not config:
+                return Response().error("MCP 服务器配置不能为空").__dict__
+
+            tools_name = await self.tool_mgr.test_mcp_server_connection(config)
+            return (
+                Response().ok(data=tools_name, message="🎉 MCP 服务器可用！").__dict__
+            )
+
+        except Exception as e:
+            logger.error(traceback.format_exc())
+            return Response().error(f"测试 MCP 连接失败: {e!s}").__dict__
+
+    async def get_tool_list(self):
+        """获取所有注册的工具列表"""
+        try:
+            tools = self.tool_mgr.func_list
+            tools_dict = [
+                {
+                    "name": tool.name,
+                    "description": tool.description,
+                    "parameters": tool.parameters,
+                    "active": tool.active,
+                }
+                for tool in tools
+            ]
+            return Response().ok(data=tools_dict).__dict__
+        except Exception as e:
+            logger.error(traceback.format_exc())
+            return Response().error(f"获取工具列表失败: {e!s}").__dict__
+
+    async def toggle_tool(self):
+        """启用或停用指定的工具"""
+        try:
+            data = await request.json
+            tool_name = data.get("name")
+            action = data.get("activate")  # True or False
+
+            if not tool_name or action is None:
+                return Response().error("缺少必要参数: name 或 action").__dict__
+
+            if action:
+                try:
+                    ok = self.tool_mgr.activate_llm_tool(tool_name, star_map=star_map)
+                except ValueError as e:
+                    return Response().error(f"启用工具失败: {e!s}").__dict__
             else:
-                return Response().error("保存配置失败").__dict__
+                ok = self.tool_mgr.deactivate_llm_tool(tool_name)
+
+            if ok:
+                return Response().ok(None, "操作成功。").__dict__
+            return Response().error(f"工具 {tool_name} 不存在或操作失败。").__dict__
+
         except Exception as e:
             logger.error(traceback.format_exc())
-            return Response().error(f"删除 MCP 服务器失败: {str(e)}").__dict__
-
-    async def get_mcp_markets(self):
-        page = request.args.get("page", 1, type=int)
-        page_size = request.args.get("page_size", 10, type=int)
-        BASE_URL = "https://api.soulter.top/astrbot/mcpservers?page={}&page_size={}".format(
-            page,
-            page_size,
-        )
+            return Response().error(f"操作工具失败: {e!s}").__dict__
+
+    async def sync_provider(self):
+        """同步 MCP 提供者配置"""
         try:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(f"{BASE_URL}") as response:
-                    if response.status == 200:
-                        data = await response.json()
-                        return Response().ok(data["data"]).__dict__
-                    else:
-                        return (
-                            Response()
-                            .error(f"获取市场数据失败: HTTP {response.status}")
-                            .__dict__
-                        )
-        except Exception as _:
+            data = await request.json
+            provider_name = data.get("name")  # modelscope, or others
+            match provider_name:
+                case "modelscope":
+                    access_token = data.get("access_token", "")
+                    await self.tool_mgr.sync_modelscope_mcp_servers(access_token)
+                case _:
+                    return Response().error(f"未知: {provider_name}").__dict__
+
+            return Response().ok(message="同步成功").__dict__
+        except Exception as e:
             logger.error(traceback.format_exc())
-        return Response().error("获取市场数据失败").__dict__
+            return Response().error(f"同步失败: {e!s}").__dict__