PyPI - Undefined-bot - Versions diffs - 2.1.0__py3-none-any.whl - Mend

Undefined-bot 2.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (211) hide show

Undefined/render.py ADDED Viewed

@@ -0,0 +1,123 @@
+import markdown
+import asyncio
+from playwright.async_api import async_playwright
+from typing import Any
+async def render_markdown_to_html(md_text: str) -> str:
+    # 定义同步的解析逻辑
+    def _parse() -> str:
+        extensions = [
+            "toc",
+            "tables",
+            "fenced_code",
+            "codehilite",
+            "md_in_html",
+            "attr_list",
+            "pymdownx.superfences",
+            "pymdownx.arithmatex",
+            "pymdownx.tasklist",
+            "pymdownx.tilde",
+            "pymdownx.emoji",
+        ]
+        extension_configs: dict[str, dict[str, Any]] = {
+            "pymdownx.superfences": {
+                "custom_fences": [
+                    {
+                        "name": "mermaid",
+                        "class": "mermaid",
+                        "format": lambda source,
+                        language,
+                        css_class,
+                        options,
+                        md,
+                        **kwargs: f'<pre class="{css_class}">{source}</pre>',
+                    }
+                ]
+            },
+            "pymdownx.arithmatex": {
+                "generic": True,
+            },
+        }
+        return str(
+            markdown.markdown(
+                md_text, extensions=extensions, extension_configs=extension_configs
+            )
+        )
+    # 使用 to_thread 在独立的线程中运行同步的 markdown 解析，避免阻塞主循环
+    html_content = await asyncio.to_thread(_parse)
+    # 拼接 HTML 模板（这部分是纯字符串操作，速度极快，无需放进线程）
+    full_html = f"""
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <meta charset="utf-8">
+        <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/github-markdown-css/5.2.0/github-markdown.min.css">
+        <style>
+            body {{ background-color: white; padding: 45px; }}
+            .markdown-body {{ box-sizing: border-box; min-width: 200px; max-width: 980px; margin: 0 auto; }}
+            .mermaid {{ background: transparent !important; border: none !important; }}
+        </style>
+        <script id="MathJax-script" async src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-chtml.js"></script>
+        <script>
+        window.MathJax = {{
+          tex: {{ inlineMath: [['$', '$'], ['\\\\(', '\\\\)']] }}
+        }};
+        </script>
+        <script src="https://cdn.jsdelivr.net/npm/mermaid@11.1.0/dist/mermaid.min.js"></script>
+    </head>
+    <body>
+        <article class="markdown-body">
+            {html_content}
+        </article>
+        <script>
+            mermaid.initialize({{
+                startOnLoad: true,
+                theme: 'default',
+                securityLevel: 'loose',
+                fontFamily: 'arial'
+            }});
+        </script>
+    </body>
+    </html>
+    """
+    return full_html
+async def render_html_to_image(html_content: str, output_path: str) -> None:
+    """
+    将 HTML 字符串转换为 PNG 图片
+    参数:
+        html_content: 完整的 HTML 字符串
+        output_path: 输出图片路径 (例如 'result.png')
+    """
+    async with async_playwright() as p:
+        # 启动无头浏览器
+        browser = await p.chromium.launch(headless=True)
+        # 设置上下文，可以指定缩放比例(device_scale_factor)，2代表2倍清晰度(Retina)
+        context = await browser.new_context(device_scale_factor=2)
+        page = await context.new_page()
+        # 设置页面内容
+        await page.set_content(html_content)
+        # --- 关键：等待渲染完成 ---
+        # 1. 等待网络空闲（确保 CDN 上的 MathJax/Mermaid 脚本加载完）
+        await page.wait_for_load_state("networkidle")
+        # 2. 如果有 Mermaid，给它一点时间执行 JS 绘图
+        # 如果页面里没有 mermaid 脚本，这行会很快跳过
+        await asyncio.sleep(1)  # 等待 1 秒钟让 Mermaid 渲染完成
+        # 3. 自动调整视口大小以匹配内容
+        # 如果你想截取整个页面，使用 full_page=True
+        # 如果只想截取特定容器，可以定位 element = page.locator(".container")
+        await page.screenshot(path=output_path, full_page=True)
+        await browser.close()

Undefined/scheduled_task_storage.py ADDED Viewed

@@ -0,0 +1,88 @@
+"""定时任务持久化存储模块"""
+import json
+import logging
+from dataclasses import dataclass, asdict
+from pathlib import Path
+from typing import Any, Dict, Optional
+logger = logging.getLogger(__name__)
+# 任务数据存储路径
+TASKS_FILE_PATH = Path("data/scheduled_tasks.json")
+@dataclass
+class ScheduledTask:
+    """定时任务数据模型"""
+    task_id: str
+    tool_name: str
+    tool_args: Dict[str, Any]
+    cron: str
+    target_id: Optional[int]
+    target_type: str
+    task_name: str
+    max_executions: Optional[int]
+    current_executions: int = 0
+    created_at: str = ""
+    def to_dict(self) -> Dict[str, Any]:
+        """转换为字典"""
+        return asdict(self)
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ScheduledTask":
+        """从字典创建实例"""
+        return cls(**data)
+class ScheduledTaskStorage:
+    """定时任务存储管理器"""
+    def __init__(self) -> None:
+        """初始化存储"""
+        self._load()
+    def _load(self) -> Dict[str, ScheduledTask]:
+        """从文件加载所有任务"""
+        if not TASKS_FILE_PATH.exists():
+            return {}
+        try:
+            with open(TASKS_FILE_PATH, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            return {
+                task_id: ScheduledTask.from_dict(task_data)
+                for task_id, task_data in data.items()
+            }
+        except Exception as e:
+            logger.error(f"加载定时任务数据失败: {e}")
+            return {}
+    def save_all(self, tasks: Dict[str, Any]) -> None:
+        """保存所有任务到文件"""
+        try:
+            TASKS_FILE_PATH.parent.mkdir(parents=True, exist_ok=True)
+            # 确保保存的是基础类型字典
+            data_to_save = {}
+            for task_id, task_info in tasks.items():
+                if isinstance(task_info, ScheduledTask):
+                    data_to_save[task_id] = task_info.to_dict()
+                elif isinstance(task_info, dict):
+                    # 兼容 TaskScheduler 内部的 dict 格式
+                    data_to_save[task_id] = task_info
+                else:
+                    logger.warning(f"未知任务数据格式: {task_id}")
+            with open(TASKS_FILE_PATH, "w", encoding="utf-8") as f:
+                json.dump(data_to_save, f, ensure_ascii=False, indent=2)
+            logger.debug(f"已保存 {len(data_to_save)} 个定时任务")
+        except Exception as e:
+            logger.error(f"保存定时任务数据失败: {e}")
+    def load_tasks(self) -> Dict[str, Any]:
+        """读取所有任务（返回原始字典格式以适配现有代码）"""
+        tasks = self._load()
+        return {task_id: task.to_dict() for task_id, task in tasks.items()}

Undefined/services/__init__.py ADDED Viewed

	@@ -0,0 +1 @@
1	+ """服务层初始化"""

Undefined/services/queue_manager.py ADDED Viewed

@@ -0,0 +1,206 @@
+"""AI 请求队列管理服务"""
+import asyncio
+import logging
+import time
+from typing import Any, Callable, Coroutine
+logger = logging.getLogger(__name__)
+class QueueManager:
+    """负责 AI 请求的队列管理和调度"""
+    def __init__(self, ai_request_interval: float = 1.0) -> None:
+        self.ai_request_interval = ai_request_interval
+        # AI 请求队列（四个队列）
+        self._superadmin_queue: asyncio.Queue[dict[str, Any]] = (
+            asyncio.Queue()
+        )  # 超级管理员私聊队列（最高优先级）
+        self._private_queue: asyncio.Queue[dict[str, Any]] = (
+            asyncio.Queue()
+        )  # 普通私聊队列（高优先级）
+        self._group_mention_queue: asyncio.Queue[dict[str, Any]] = (
+            asyncio.Queue()
+        )  # 群聊被@队列（中等优先级）
+        self._group_normal_queue: asyncio.Queue[dict[str, Any]] = (
+            asyncio.Queue()
+        )  # 群聊普通队列（最低优先级）
+        self._processor_task: asyncio.Task[None] | None = None
+        self._request_handler: (
+            Callable[[dict[str, Any]], Coroutine[Any, Any, None]] | None
+        ) = None
+    def start(
+        self, request_handler: Callable[[dict[str, Any]], Coroutine[Any, Any, None]]
+    ) -> None:
+        """启动队列处理任务
+        参数:
+            request_handler: 处理单个请求的异步回调函数
+        """
+        self._request_handler = request_handler
+        if self._processor_task is None or self._processor_task.done():
+            self._processor_task = asyncio.create_task(self._process_queue_loop())
+            logger.info("[队列服务] 队列处理主循环已启动")
+    async def stop(self) -> None:
+        """停止队列处理任务"""
+        if self._processor_task and not self._processor_task.done():
+            logger.info("[队列服务] 正在停止队列处理任务...")
+            self._processor_task.cancel()
+            try:
+                await self._processor_task
+            except asyncio.CancelledError:
+                pass
+            self._processor_task = None
+            logger.info("[队列服务] 队列处理任务已停止")
+    async def add_superadmin_request(self, request: dict[str, Any]) -> None:
+        """添加超级管理员请求"""
+        await self._superadmin_queue.put(request)
+        logger.info(
+            f"[队列入队] 超级管理员私聊: 队列长度={self._superadmin_queue.qsize()}"
+        )
+    async def add_private_request(self, request: dict[str, Any]) -> None:
+        """添加普通私聊请求"""
+        await self._private_queue.put(request)
+        logger.info(f"[队列入队] 普通私聊: 队列长度={self._private_queue.qsize()}")
+    async def add_group_mention_request(self, request: dict[str, Any]) -> None:
+        """添加群聊被@请求"""
+        await self._group_mention_queue.put(request)
+        logger.info(f"[队列入队] 群聊被@: 队列长度={self._group_mention_queue.qsize()}")
+    async def add_group_normal_request(self, request: dict[str, Any]) -> None:
+        """添加群聊普通请求 (会自动裁剪)"""
+        self._trim_normal_queue()
+        await self._group_normal_queue.put(request)
+        logger.info(f"[队列入队] 群聊普通: 队列长度={self._group_normal_queue.qsize()}")
+    def _trim_normal_queue(self) -> None:
+        """如果群聊普通队列超过10个，仅保留最新的2个"""
+        queue_size = self._group_normal_queue.qsize()
+        if queue_size > 10:
+            logger.info(
+                f"[队列修剪] 群聊普通队列长度 {queue_size} 超过阈值(10)，正在修剪..."
+            )
+            # 取出所有元素
+            all_requests: list[dict[str, Any]] = []
+            while not self._group_normal_queue.empty():
+                all_requests.append(self._group_normal_queue.get_nowait())
+            # 只保留最新的2个
+            latest_requests = all_requests[-2:]
+            # 放回队列
+            for req in latest_requests:
+                self._group_normal_queue.put_nowait(req)
+            logger.info(f"[队列修剪] 修剪完成，保留最新 {len(latest_requests)} 个请求")
+    async def _process_queue_loop(self) -> None:
+        """队列处理主循环"""
+        queues = [
+            self._superadmin_queue,
+            self._private_queue,
+            self._group_mention_queue,
+            self._group_normal_queue,
+        ]
+        queue_names = ["超级管理员私聊", "私聊", "群聊被@", "群聊普通"]
+        current_queue_idx = 0
+        current_queue_processed = 0
+        last_transfer_to_normal = False
+        transfer_count = 0
+        try:
+            while True:
+                try:
+                    current_queue = queues[current_queue_idx]
+                    if current_queue.empty():
+                        all_empty = all(q.empty() for q in queues)
+                        if all_empty:
+                            await asyncio.sleep(0.2)
+                            continue
+                        current_queue_idx = (current_queue_idx + 1) % 4
+                        current_queue_processed = 0
+                        transfer_count += 1
+                        continue
+                    request = await current_queue.get()
+                    request_type = request.get("type", "unknown")
+                    logger.info(
+                        f"[队列处理] 正在处理 {queue_names[current_queue_idx]} 请求: {request_type} "
+                        f"(剩余={current_queue.qsize()})"
+                    )
+                    try:
+                        start_time = time.perf_counter()
+                        if self._request_handler:
+                            await self._request_handler(request)
+                        duration = time.perf_counter() - start_time
+                        logger.info(
+                            f"[队列处理] {queue_names[current_queue_idx]} 请求处理完成, 耗时={duration:.2f}s"
+                        )
+                    except Exception as e:
+                        logger.exception(f"[队列处理] 处理请求失败: {e}")
+                    finally:
+                        current_queue.task_done()
+                    current_queue_processed += 1
+                    # 调度逻辑：每个高优先级队列处理2个后切换
+                    if current_queue_processed >= 2:
+                        next_queue_idx = (current_queue_idx + 1) % 4
+                        logger.info(
+                            f"QueueManager: {queue_names[current_queue_idx]}队列已处理2条，"
+                            f"转移到{queue_names[next_queue_idx]}队列"
+                        )
+                        if next_queue_idx == 3:
+                            last_transfer_to_normal = True
+                        else:
+                            last_transfer_to_normal = False
+                        current_queue_idx = next_queue_idx
+                        current_queue_processed = 0
+                        transfer_count += 1
+                    # 防饿死逻辑：强制处理普通队列
+                    if (
+                        transfer_count > 0
+                        and transfer_count % 2 == 0
+                        and not last_transfer_to_normal
+                    ):
+                        if not self._group_normal_queue.empty():
+                            normal_request = await self._group_normal_queue.get()
+                            normal_type = normal_request.get("type", "unknown")
+                            logger.info(
+                                f"QueueManager: 强制处理群聊普通请求: {normal_type}"
+                            )
+                            try:
+                                if self._request_handler:
+                                    await self._request_handler(normal_request)
+                            except Exception as e:
+                                logger.exception(
+                                    f"QueueManager: 处理群聊普通请求失败: {e}"
+                                )
+                            finally:
+                                self._group_normal_queue.task_done()
+                        transfer_count = 0
+                    await asyncio.sleep(self.ai_request_interval)
+                except asyncio.CancelledError:
+                    raise
+                except Exception as e:
+                    logger.exception(f"QueueManager: 队列循环异常: {e}")
+                    await asyncio.sleep(1.0)
+        except asyncio.CancelledError:
+            logger.info("QueueManager: 任务被取消")
+        finally:
+            logger.info("QueueManager: 任务已退出")

Undefined/skills/README.md ADDED Viewed

@@ -0,0 +1,53 @@
+# 技能目录 (Skills Directory)
+技能目录，包含基础工具（tools）和工具集合（agents）。
+## 目录结构
+```
+skills/
+├── tools/          # 基础小工具，直接暴露给 AI 调用
+│   ├── __init__.py
+│   ├── send_message/
+│   ├── send_private_message/
+│   └── ...
+│
+└── agents/         # 工具集合，AI Agent 封装
+    ├── __init__.py
+    ├── code_analysis_agent/
+    ├── web_agent/
+    ├── social_agent/
+    ├── entertainment_agent/
+    └── info_agent/
+```
+## Tools vs Agents
+### Tools（工具）
+- 单一功能，直接暴露给主 AI
+- 使用 OpenAI function calling 格式
+- 示例：`send_message`, `get_current_time`, `analyze_multimodal`
+### Agents（代理）
+- 工具集合，内部可调用多个子工具
+- 使用 OpenAI function calling 格式暴露
+- 参数统一为 `prompt`，由 Agent 内部解析
+- 支持自动发现子工具并注册
+- 适用于复杂场景和领域特定任务
+## 添加新工具
+### 添加 Tools
+1. 在 `skills/tools/` 下创建新目录
+2. 添加 `config.json`（工具定义）
+3. 添加 `handler.py`（执行逻辑）
+4. 自动被 `ToolRegistry` 发现和注册
+### 添加 Agents
+1. 在 `skills/agents/` 下创建新目录
+2. 添加 `intro.md`（给主 AI 看的能力说明）
+3. 添加 `prompt.md`（Agent 系统提示词）
+4. 添加 `config.json`（Agent 定义）
+5. 添加 `handler.py`（Agent 执行逻辑）
+6. 在 `tools/` 子目录中添加子工具
+7. 自动被 `AgentRegistry` 发现和注册

Undefined/skills/__init__.py ADDED Viewed

@@ -0,0 +1,10 @@
+"""
+Skills Package
+包含基础工具（tools）和 AI 代理（agents）的技能目录。
+"""
+from .tools import ToolRegistry
+from .agents import AgentRegistry
+__all__ = ["ToolRegistry", "AgentRegistry"]

Undefined/skills/agents/README.md ADDED Viewed

@@ -0,0 +1,144 @@
+# Agent 目录 (Agents Directory)
+AI Agent 目录，每个 Agent 是一个工具集合。
+## Agent 结构
+每个 Agent 是一个目录，包含：
+```
+agent_name/
+├── intro.md          # 给主 AI 看的能力说明
+├── prompt.md         # Agent 系统提示词（从文件加载）
+├── config.json       # Agent 定义（OpenAI function calling 格式）
+├── handler.py        # Agent 执行逻辑
+└── tools/            # Agent 专属子工具目录
+    ├── tool1/
+    ├── tool2/
+    └── __init__.py
+```
+## 模型配置
+Agent 使用独立的模型配置，通过环境变量设置：
+```env
+# Agent 模型配置 (用于执行 agents)
+AGENT_MODEL_API_URL=          # API 地址
+AGENT_MODEL_API_KEY=          # API 密钥
+AGENT_MODEL_NAME=             # 模型名称
+AGENT_MODEL_MAX_TOKENS=4096   # 最大 token 数
+AGENT_MODEL_THINKING_ENABLED=false     # 是否启用 thinking（思维链）
+AGENT_MODEL_THINKING_BUDGET_TOKENS=0    # thinking budget tokens
+```
+### 配置说明
+| 环境变量 | 说明 | 默认值 |
+|---------|------|-------|
+| `AGENT_MODEL_API_URL` | Agent 模型 API 地址 | 无（必填） |
+| `AGENT_MODEL_API_KEY` | Agent 模型 API 密钥 | 无（必填） |
+| `AGENT_MODEL_NAME` | Agent 模型名称 | 无（必填） |
+| `AGENT_MODEL_MAX_TOKENS` | 单次响应最大 token 数 | 4096 |
+| `AGENT_MODEL_THINKING_ENABLED` | 是否启用思维链 | false |
+| `AGENT_MODEL_THINKING_BUDGET_TOKENS` | 思维链预算 token 数量 | 0 |
+## 核心文件说明
+### intro.md
+给主 AI 参考的 Agent 能力说明，包括：
+- Agent 的功能概述
+- 支持的能力列表
+- 使用方式和参数说明
+- 返回格式
+**这是主 AI 看到的核心描述**，系统会自动将 `intro.md` 的内容作为 Agent 的 description 传递给 AI。
+示例：
+```markdown
+# XXX 助手
+## 能力
+- 功能1
+- 功能2
+## 使用方式
+- 提供 xxx 参数
+```
+### prompt.md
+Agent 内部的系统提示词，**从文件加载**，指导 Agent 如何选择和使用工具。
+文件位置：`skills/agents/{agent_name}/prompt.md`
+示例：
+```markdown
+你是一个 XXX 助手...
+## 你的任务
+1. 理解用户需求
+2. 选择合适的工具
+3. 返回结果
+```
+### config.json
+Agent 的 OpenAI function calling 定义。
+**注意**：description 字段可选，不建议手动填写。系统会自动从 `intro.md` 读取内容作为 description 传递给 AI。
+现有配置中的 description 仅用于向后兼容，未来将逐步移除。
+```json
+{
+    "type": "function",
+    "function": {
+        "name": "agent_name",
+        "description": "Agent 描述（无需填写，将自动从 intro.md 覆盖）",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "prompt": {
+                    "type": "string",
+                    "description": "用户需求描述"
+                }
+            },
+            "required": ["prompt"]
+        }
+    }
+}
+```
+### handler.py
+Agent 的执行逻辑，负责：
+1. 从 `prompt.md` 加载系统提示词
+2. 使用 `AGENT_MODEL_*` 配置调用模型
+3. 通过 `AgentToolRegistry` 调用子工具
+4. 返回结果给主 AI
+## 添加新 Agent
+### 1. 创建 Agent 目录
+```bash
+mkdir -p skills/agents/my_agent/tools
+```
+### 2. 创建必要文件
+- `intro.md` - Agent 能力说明
+- `prompt.md` - Agent 系统提示词
+- `config.json` - Agent 定义
+- `handler.py` - Agent 执行逻辑
+### 3. 添加子工具
+将工具目录移动到 `tools/` 下：
+```bash
+mv skills/tools/my_tool skills/agents/my_agent/tools/
+```
+或添加工具。
+### 4. 自动发现
+重启后 `AgentRegistry` 会自动发现并加载新 Agent。
+## 自动发现
+`AgentRegistry` 会自动发现 `skills/agents/` 下的所有 Agent 并加载。
+每个 Agent 内部的子工具由 `AgentToolRegistry` 自动发现。