Undefined-bot 2.1.0__py3-none-any.whl

Undefined/skills/tools/__init__.py

@@ -0,0 +1,120 @@
+import json
+import logging
+import importlib.util
+import asyncio
+from pathlib import Path
+from typing import Dict, Any, List, Callable, Awaitable
+
+logger = logging.getLogger(__name__)
+
+
+class ToolRegistry:
+    def __init__(self, tools_dir: str | Path | None = None):
+        if tools_dir is None:
+            # 默认为此文件所在的目录
+            self.tools_dir = Path(__file__).parent
+        else:
+            self.tools_dir = Path(tools_dir)
+
+        self._tools_schema: List[Dict[str, Any]] = []
+        self._tools_handlers: Dict[
+            str, Callable[[Dict[str, Any], Dict[str, Any]], Awaitable[Any]]
+        ] = {}
+        self.load_tools()
+
+    def load_tools(self) -> None:
+        """从 tools 目录发现并加载工具。"""
+        self._tools_schema = []
+        self._tools_handlers = {}
+
+        if not self.tools_dir.exists():
+            logger.warning(f"工具目录不存在: {self.tools_dir}")
+            return
+
+        for item in self.tools_dir.iterdir():
+            if item.is_dir() and not item.name.startswith("_"):
+                self._load_tool_from_dir(item)
+
+        tool_names = list(self._tools_handlers.keys())
+        logger.info(
+            f"成功加载了 {len(self._tools_schema)} 个工具: {', '.join(tool_names)}"
+        )
+
+    def _load_tool_from_dir(self, tool_dir: Path) -> None:
+        """从目录加载单个工具。"""
+        config_path = tool_dir / "config.json"
+        handler_path = tool_dir / "handler.py"
+
+        if not config_path.exists() or not handler_path.exists():
+            logger.debug(
+                f"[工具加载] 目录 {tool_dir} 缺少 config.json 或 handler.py，跳过"
+            )
+            return
+
+        # 加载配置
+        try:
+            with open(config_path, "r", encoding="utf-8") as f:
+                config = json.load(f)
+
+            # 基本验证
+            if "name" not in config.get("function", {}):
+                logger.error(f"[工具错误] 工具配置无效 {tool_dir}: 缺少 function.name")
+                return
+
+            tool_name = config["function"]["name"]
+            logger.debug(f"[工具加载] 正在从 {tool_dir} 加载工具: {tool_name}")
+
+        except Exception as e:
+            logger.error(f"[工具错误] 从 {tool_dir} 加载工具配置失败: {e}")
+            return
+
+        # 加载处理器
+        try:
+            spec = importlib.util.spec_from_file_location(
+                f"tools.{tool_name}", handler_path
+            )
+            if spec is None or spec.loader is None:
+                logger.error(f"从 {handler_path} 加载工具处理器 spec 失败")
+                return
+
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+
+            if not hasattr(module, "execute"):
+                logger.error(f"工具 {tool_dir} 的处理器缺少 'execute' 函数")
+                return
+
+            self._tools_schema.append(config)
+            self._tools_handlers[tool_name] = module.execute
+
+        except Exception as e:
+            logger.error(f"从 {tool_dir} 加载工具处理器失败: {e}")
+
+    def get_tools_schema(self) -> List[Dict[str, Any]]:
+        """返回 AI 模型的工具定义列表。"""
+        return self._tools_schema
+
+    async def execute_tool(
+        self, tool_name: str, args: Dict[str, Any], context: Dict[str, Any]
+    ) -> str:
+        """根据名称执行工具。"""
+        handler = self._tools_handlers.get(tool_name)
+        if not handler:
+            return f"未找到工具: {tool_name}"
+
+        try:
+            # 检查处理器是否为协程
+            start_time = asyncio.get_event_loop().time()
+            if asyncio.iscoroutinefunction(handler):
+                result = await handler(args, context)
+            else:
+                # 我们预期工具是异步的，但也支持同步以防万一
+                # 注意：我们的类型提示是 Awaitable，所以这只是为了安全
+                result = handler(args, context)
+
+            duration = asyncio.get_event_loop().time() - start_time
+            logger.info(f"[工具执行] {tool_name} 执行成功, 耗时={duration:.4f}s")
+            return str(result)
+        except Exception as e:
+            logger.exception(f"[工具异常] 执行工具 {tool_name} 时出错")
+            return f"执行工具 {tool_name} 时出错: {str(e)}"

Undefined/skills/tools/debug/config.json

@@ -0,0 +1,17 @@
+{
+    "type": "function",
+    "function": {
+        "name": "debug",
+        "description": "记录调试信息，用于输出决策过程、思维路径、工具调用和结果等。仅在调试模式下使用（通过 debug:on 启用）。",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "content": {
+                    "type": "string",
+                    "description": "调试信息内容，包括触发条件判断、上下文分析、最终决策理由等"
+                }
+            },
+            "required": ["content"]
+        }
+    }
+}

Undefined/skills/tools/debug/handler.py

@@ -0,0 +1,35 @@
+import logging
+import uuid
+from pathlib import Path
+from typing import Any, Dict
+
+logger = logging.getLogger(__name__)
+
+# 调试数据保存目录
+DEBUG_DIR = Path("data/debug")
+
+
+async def execute(args: Dict[str, Any], context: Dict[str, Any]) -> str:
+    """执行 debug 工具，保存调试信息到文本文件"""
+    content = args.get("content", "")
+    if not content:
+        return "调试内容不能为空"
+    
+    # 确保目录存在
+    DEBUG_DIR.mkdir(parents=True, exist_ok=True)
+    
+    # 生成 UUID 作为文件名
+    file_uuid = uuid.uuid4()
+    filename = f"{file_uuid}.txt"
+    filepath = DEBUG_DIR / filename
+    
+    # 保存到文件
+    try:
+        with open(filepath, "w", encoding="utf-8") as f:
+            f.write(content)
+        
+        logger.info(f"调试信息已保存到: {filepath}")
+        return f"调试信息已保存（UUID: {file_uuid}）"
+    except Exception as e:
+        logger.error(f"保存调试信息失败: {e}")
+        return f"保存失败: {e}"

Undefined/skills/tools/end/config.json

@@ -0,0 +1,17 @@
+{
+    "type": "function",
+    "function": {
+        "name": "end",
+        "description": "结束对话。发送完所有消息后，必须且只能调用一次此工具来结束对话。如果这次做了什么或以后可能要做什么，必须填写summary参数记录下来。",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "summary": {
+                    "type": "string",
+                    "description": "记录这次做了什么或以后可能要做什么。如果只是end了不做事，不需要填写。如果做了什么或以后可能要做什么，必须填写。最多保留100条记录。"
+                }
+            },
+            "required": []
+        }
+    }
+}

Undefined/skills/tools/end/handler.py

@@ -0,0 +1,24 @@
+from typing import Any, Dict
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+async def execute(args: Dict[str, Any], context: Dict[str, Any]) -> str:
+    summary = args.get("summary", "")
+    if summary:
+        end_summaries = context.get("end_summaries")
+        if end_summaries is not None:
+            end_summaries.append(summary)
+            logger.info(f"保存end记录: {summary[:50]}...")
+
+            # 持久化保存
+            end_summary_storage = context.get("end_summary_storage")
+            if end_summary_storage:
+                # 转换 deque 为 list 进行序列化
+                end_summary_storage.save(list(end_summaries))
+
+    # 通知调用方对话应结束
+    context["conversation_ended"] = True
+
+    return "对话已结束"

Undefined/skills/tools/get_current_time/config.json

@@ -0,0 +1,12 @@
+{
+    "type": "function",
+    "function": {
+        "name": "get_current_time",
+        "description": "获取当前系统时间。",
+        "parameters": {
+            "type": "object",
+            "properties": {},
+            "required": []
+        }
+    }
+}

Undefined/skills/tools/get_current_time/handler.py

@@ -0,0 +1,5 @@
+from typing import Any, Dict
+from datetime import datetime
+
+async def execute(args: Dict[str, Any], context: Dict[str, Any]) -> str:
+    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

Undefined/skills/tools/get_forward_msg/config.json

@@ -0,0 +1,17 @@
+{
+    "type": "function",
+    "function": {
+        "name": "get_forward_msg",
+        "description": "获取合并转发消息的详情内容。当你在聊天记录中看到 [合并转发: ID] 时，可以使用此工具获取其包含的具体消息列表。",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "message_id": {
+                    "type": "string",
+                    "description": "合并转发消息的 ID"
+                }
+            },
+            "required": ["message_id"]
+        }
+    }
+}

Undefined/skills/tools/get_forward_msg/handler.py

@@ -0,0 +1,131 @@
+from typing import Any, Dict
+from datetime import datetime
+import logging
+import json
+
+logger = logging.getLogger(__name__)
+
+
+async def execute(args: Dict[str, Any], context: Dict[str, Any]) -> str:
+    message_id = args.get("message_id")
+    if not message_id:
+        return "错误：message_id 不能为空"
+
+    get_forward_msg_callback = context.get("get_forward_msg_callback")
+    if not get_forward_msg_callback:
+        return "错误：获取合并转发消息的回调未设置"
+
+    try:
+        nodes = await get_forward_msg_callback(message_id)
+        if not nodes:
+            return "未能获取到合并转发消息的内容或内容为空"
+
+        logger.info(f"成功获取合并转发内容，节点数: {len(nodes)}")
+
+        formatted_messages = []
+        for i, node in enumerate(nodes):
+            # 记录第一个节点的结构用于调试
+            if i == 0:
+                logger.debug(
+                    f"合并转发节点示例结构: {json.dumps(node, ensure_ascii=False)[:500]}"
+                )
+
+            sender = node.get("sender") or {}
+            # 兼容有些实现直接把发送者信息放在节点根部
+            sender_name = (
+                sender.get("nickname")
+                or node.get("nickname")
+                or sender.get("card")
+                or node.get("card")
+                or "未知用户"
+            )
+            sender_id = sender.get("user_id") or node.get("user_id") or "未知ID"
+
+            node_time = node.get("time")
+            if node_time:
+                try:
+                    timestamp = datetime.fromtimestamp(float(node_time)).strftime(
+                        "%Y-%m-%d %H:%M:%S"
+                    )
+                except (ValueError, TypeError):
+                    timestamp = str(node_time)
+            else:
+                timestamp = "未知时间"
+
+            # 激进的内容提取：尝试所有可能的字段
+            raw_content = (
+                node.get("content") or node.get("message") or node.get("raw_message")
+            )
+
+            text_parts = []
+            if raw_content is None:
+                text_parts.append("(消息内容字段缺失)")
+            elif isinstance(raw_content, str):
+                text_parts.append(raw_content)
+            elif isinstance(raw_content, dict):
+                # 单个消息段
+                raw_content = [raw_content]
+
+            if isinstance(raw_content, list):
+                for segment in raw_content:
+                    if isinstance(segment, str):
+                        text_parts.append(segment)
+                        continue
+                    if not isinstance(segment, dict):
+                        continue
+
+                    seg_type = segment.get("type")
+                    seg_data = segment.get("data", {})
+
+                    if seg_type == "text":
+                        text_parts.append(seg_data.get("text", ""))
+                    elif seg_type == "at":
+                        qq = seg_data.get("qq", "")
+                        text_parts.append(f"[@ {qq}]")
+                    elif seg_type == "image":
+                        file = seg_data.get("file", "") or seg_data.get("url", "")
+                        text_parts.append(f"[图片: {file}]")
+                    elif seg_type == "forward":
+                        inner_id = seg_data.get("id")
+                        text_parts.append(f"[合并转发: {inner_id}]")
+                    elif seg_type == "reply":
+                        text_parts.append("[引用]")
+                    elif seg_type == "face":
+                        text_parts.append("[表情]")
+                    elif seg_type == "json":
+                        # 尝试从 JSON 中提取描述
+                        try:
+                            j_data = json.loads(seg_data.get("data", "{}"))
+                            desc = (
+                                j_data.get("meta", {})
+                                .get("detail", {})
+                                .get("desc", "JSON消息")
+                            )
+                            text_parts.append(f"[{desc}]")
+                        except Exception:
+                            text_parts.append("[JSON消息]")
+                    elif seg_type == "xml":
+                        text_parts.append("[XML消息]")
+                    elif seg_type:
+                        text_parts.append(f"[{seg_type}]")
+
+            text = "".join(text_parts).strip()
+            if not text:
+                # 如果还是空，把整个节点键名返回给 AI 辅助判断
+                keys = list(node.keys())
+                text = f"(无法解析内容，节点键名: {keys})"
+
+            # 格式：XML 标准化
+            formatted_messages.append(f"""<message sender="{sender_name}" sender_id="{sender_id}" location="合并转发" time="{timestamp}">
+<content>{text}</content>
+</message>""")
+
+        result = "\n---\n".join(formatted_messages)
+        logger.info(
+            f"get_forward_msg 处理完成，返回数据样例 (前500字符): {result[:500]}..."
+        )
+        return result
+
+    except Exception as e:
+        logger.exception(f"解析合并转发消息时出错: {e}")
+        return f"解析合并转发消息时出错: {str(e)}"

Undefined/skills/tools/get_group_member_info/config.json

@@ -0,0 +1,38 @@
+{
+    "type": "function",
+    "function": {
+        "name": "get_group_member_info",
+        "description": "获取群聊成员的详细信息。可以指定要获取的字段和字段数目，支持获取：群昵称、QQ昵称、QQ号(cqid)、加群时间、入群时间戳、等级、活跃度、最后发言时间、最后活跃时间戳、历史消息数量等。",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "group_id": {
+                    "type": "integer",
+                    "description": "群号"
+                },
+                "user_id": {
+                    "type": "integer",
+                    "description": "群成员的QQ号"
+                },
+                "fields": {
+                    "type": "array",
+                    "description": "指定要获取的字段列表。可选字段：nickname(QQ昵称)、card(群昵称)、user_id(QQ号)、join_time(加群时间)、last_sent_time(最后发言时间)、level(等级)、role(角色)、unfriendly(是否不友好)、title(头衔)、title_expire_time(头衔过期时间)、shut_up_timestamp(禁言截止时间)",
+                    "items": {
+                        "type": "string",
+                        "enum": ["nickname", "card", "user_id", "join_time", "last_sent_time", "level", "role", "unfriendly", "title", "title_expire_time", "shut_up_timestamp"]
+                    }
+                },
+                "limit": {
+                    "type": "integer",
+                    "description": "限制返回的字段数量（当 fields 未指定时有效），默认返回所有字段"
+                },
+                "no_cache": {
+                    "type": "boolean",
+                    "description": "是否不使用缓存获取最新信息，默认 false",
+                    "default": false
+                }
+            },
+            "required": ["group_id", "user_id"]
+        }
+    }
+}

Undefined/skills/tools/get_group_member_info/handler.py

@@ -0,0 +1,142 @@
+from typing import Any, Dict
+import logging
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+FIELD_MAPPING = {
+    "nickname": "QQ昵称",
+    "card": "群昵称",
+    "user_id": "QQ号",
+    "join_time": "加群时间",
+    "last_sent_time": "最后发言时间",
+    "level": "等级",
+    "role": "角色",
+    "unfriendly": "是否不友好",
+    "title": "头衔",
+    "title_expire_time": "头衔过期时间",
+    "shut_up_timestamp": "禁言截止时间",
+}
+
+
+async def execute(args: Dict[str, Any], context: Dict[str, Any]) -> str:
+    """获取群聊成员的详细信息
+
+    参数:
+        args: 工具参数，包含 group_id、user_id、fields、limit、no_cache
+        context: 工具上下文，包含 onebot_client 等回调函数
+
+    返回:
+        群成员详细信息描述
+    """
+    group_id = args.get("group_id")
+    user_id = args.get("user_id")
+    fields = args.get("fields")
+    limit = args.get("limit")
+    no_cache = args.get("no_cache", False)
+
+    if group_id is None:
+        return "请提供群号（group_id参数）"
+    if user_id is None:
+        return "请提供要查询的群成员QQ号（user_id参数）"
+
+    try:
+        group_id = int(group_id)
+        user_id = int(user_id)
+    except (ValueError, TypeError):
+        return "参数类型错误：group_id 和 user_id 必须是整数"
+
+    onebot_client = context.get("onebot_client")
+    if not onebot_client:
+        return "获取群成员信息功能不可用（OneBot 客户端未设置）"
+
+    try:
+        member_info = await onebot_client.get_group_member_info(
+            group_id, user_id, no_cache
+        )
+
+        if not member_info:
+            return f"未找到群 {group_id} 中 QQ {user_id} 的成员信息，可能该用户已退群或群号不正确"
+
+        result_parts = []
+        nickname = member_info.get("nickname", "")
+        card = member_info.get("card", "")
+
+        result_parts.append(f"【群成员信息】群号: {group_id}")
+
+        display_name = card if card else nickname
+        if display_name:
+            result_parts.append(f"昵称: {display_name}")
+
+        if fields:
+            for field in fields:
+                if field in FIELD_MAPPING:
+                    value = member_info.get(field)
+                    if value is not None:
+                        if field in [
+                            "join_time",
+                            "last_sent_time",
+                            "title_expire_time",
+                            "shut_up_timestamp",
+                        ]:
+                            try:
+                                if isinstance(value, (int, float)):
+                                    dt = datetime.fromtimestamp(value)
+                                    value = dt.strftime("%Y-%m-%d %H:%M:%S")
+                            except (ValueError, TypeError, OSError):
+                                pass
+                        elif field == "role":
+                            role_map = {
+                                "owner": "群主",
+                                "admin": "管理员",
+                                "member": "成员",
+                            }
+                            value = role_map.get(str(value), str(value))
+                        elif field == "unfriendly":
+                            value = "是" if value else "否"
+                        result_parts.append(f"{FIELD_MAPPING[field]}: {value}")
+        else:
+            for field, display_name_field in FIELD_MAPPING.items():
+                value = member_info.get(field)
+                if value is not None:
+                    if field in [
+                        "join_time",
+                        "last_sent_time",
+                        "title_expire_time",
+                        "shut_up_timestamp",
+                    ]:
+                        try:
+                            if isinstance(value, (int, float)):
+                                dt = datetime.fromtimestamp(value)
+                                value = dt.strftime("%Y-%m-%d %H:%M:%S")
+                        except (ValueError, TypeError, OSError):
+                            pass
+                    elif field == "role":
+                        role_map = {
+                            "owner": "群主",
+                            "admin": "管理员",
+                            "member": "成员",
+                        }
+                        value = role_map.get(str(value), str(value))
+                    elif field == "unfriendly":
+                        value = "是" if value else "否"
+                    result_parts.append(f"{display_name_field}: {value}")
+
+        if limit and len(result_parts) > limit:
+            result_parts = result_parts[:limit]
+
+        result_str = "\n".join(result_parts)
+        return f"{result_str}\n✅ 信息获取成功"
+
+    except Exception as e:
+        logger.exception(f"获取群成员信息失败: {e}")
+        error_msg = str(e)
+
+        if "retcode=100" in error_msg:
+            return "获取失败：群号或QQ号不存在"
+        elif "retcode=140" in error_msg:
+            return "获取失败：无法获取非好友的群成员信息"
+        elif "retcode=150" in error_msg:
+            return "获取失败：群成员信息获取频率过高"
+        else:
+            return f"获取失败：{error_msg}"

Undefined/skills/tools/get_messages_by_time/config.json

@@ -0,0 +1,30 @@
+{
+    "type": "function",
+    "function": {
+        "name": "get_messages_by_time",
+        "description": "根据时间范围检索消息。用于查找特定时间段内的聊天记录。",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "chat_id": {
+                    "type": "string",
+                    "description": "聊天ID（群号或QQ号）"
+                },
+                "type": {
+                    "type": "string",
+                    "description": "聊天类型（group 或 private）",
+                    "enum": ["group", "private"]
+                },
+                "start_time": {
+                    "type": "string",
+                    "description": "开始时间（格式：YYYY-MM-DD HH:MM:SS，例如：2025-12-29 10:00:00）"
+                },
+                "end_time": {
+                    "type": "string",
+                    "description": "结束时间（格式：YYYY-MM-DD HH:MM:SS，例如：2025-12-29 12:00:00）"
+                }
+            },
+            "required": ["chat_id", "type", "start_time", "end_time"]
+        }
+    }
+}