Undefined-bot 2.1.0__py3-none-any.whl

Undefined/injection_response_agent.py

@@ -0,0 +1,131 @@
+"""注入攻击回复生成器
+
+用于根据 undefined 人设生成简短的嘲讽性回复
+"""
+
+import logging
+import httpx
+from typing import Any
+from pathlib import Path
+
+from .config import SecurityModelConfig
+
+logger = logging.getLogger(__name__)
+
+# 加载系统提示词
+PROMPT_PATH = Path("res/prompts/injection_response_agent.txt")
+try:
+    INJECTION_RESPONSE_SYSTEM_PROMPT = PROMPT_PATH.read_text(encoding="utf-8")
+except Exception as e:
+    logger.error(f"加载注入回复提示词失败: {e}")
+    INJECTION_RESPONSE_SYSTEM_PROMPT = "你是一个充满敌意的、说话带刺的 AI 助手。"
+
+
+class InjectionResponseAgent:
+    """注入攻击回复生成器"""
+
+    def __init__(self, security_config: SecurityModelConfig) -> None:
+        """初始化回复生成器
+
+        参数:
+            security_config: 安全模型配置
+        """
+        self.security_config = security_config
+        self._http_client = httpx.AsyncClient(timeout=120.0)
+
+    async def generate_response(self, user_message: str) -> str:
+        """生成嘲讽性回复
+
+        参数:
+            user_message: 用户的原始消息
+
+        返回:
+            生成的嘲讽性回复
+        """
+        try:
+            # 构造请求
+            request_body = self._build_request_body(
+                messages=[
+                    {"role": "system", "content": INJECTION_RESPONSE_SYSTEM_PROMPT},
+                    {
+                        "role": "user",
+                        "content": f"<user_message>{user_message}</user_message>",
+                    },
+                ],
+                max_tokens=self.security_config.max_tokens,
+            )
+
+            response = await self._http_client.post(
+                self.security_config.api_url,
+                headers={
+                    "Authorization": f"Bearer {self.security_config.api_key}",
+                    "Content-Type": "application/json",
+                },
+                json=request_body,
+            )
+            response.raise_for_status()
+            result = response.json()
+            content = self._extract_choices_content(result).strip()
+
+            # 去除所有换行符，确保 XML 格式正确
+            content = content.replace("\n", " ").replace("\r", " ")
+            # 去除多余空格
+            content = " ".join(content.split())
+
+            logger.debug(f"生成的嘲讽回复: {content}")
+
+            return content if content else "无聊。"
+        except Exception as e:
+            logger.exception(f"生成嘲讽回复失败: {e}")
+            # 失败时返回默认回复
+            return "有病？"
+
+    def _build_request_body(
+        self,
+        messages: list[dict[str, str]],
+        max_tokens: int,
+    ) -> dict[str, Any]:
+        """构建请求体"""
+        body: dict[str, Any] = {
+            "model": self.security_config.model_name,
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "temperature": 0.7,  # 稍微高一点的温度，让回复更有变化
+        }
+
+        # 添加 thinking 参数（如果启用）
+        if self.security_config.thinking_enabled:
+            body["thinking"] = {
+                "type": "enabled",
+                "budget_tokens": self.security_config.thinking_budget_tokens,
+            }
+        else:
+            # 禁用 thinking
+            body["thinking"] = {"enabled": False, "budget_tokens": 0}
+
+        return body
+
+    def _extract_choices_content(self, result: dict[str, Any]) -> str:
+        """从 API 响应中提取 choices 的内容"""
+        # 尝试从标准 OpenAI 格式提取
+        if "choices" in result and len(result["choices"]) > 0:
+            content = result["choices"][0]["message"]["content"]
+            if isinstance(content, str):
+                return content
+            return str(content)
+
+        # 尝试从 data.choices 提取
+        if "data" in result and isinstance(result["data"], dict):
+            data = result["data"]
+            if "choices" in data and len(data["choices"]) > 0:
+                content = data["choices"][0]["message"]["content"]
+                if isinstance(content, str):
+                    return content
+                return str(content)
+
+        # 如果都失败，抛出错误
+        raise KeyError(f"无法从 API 响应中提取 choices 内容: {result}")
+
+    async def close(self) -> None:
+        """关闭 HTTP 客户端"""
+        await self._http_client.aclose()

Undefined/main.py

@@ -0,0 +1,126 @@
+"""程序入口"""
+
+import asyncio
+import logging
+import os
+import sys
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+from .ai import AIClient
+from .config import get_config
+from .faq import FAQStorage
+from .handlers import MessageHandler
+from .memory import MemoryStorage
+from .scheduled_task_storage import ScheduledTaskStorage
+from .end_summary_storage import EndSummaryStorage
+from .onebot import OneBotClient
+
+
+def setup_logging() -> None:
+    """设置日志（控制台 + 文件轮转）"""
+    load_dotenv()
+    log_level = os.getenv("LOG_LEVEL", "INFO").upper()
+    level = getattr(logging, log_level, logging.INFO)
+
+    # 日志格式
+    log_format = "%(asctime)s [%(levelname)s] %(name)s: %(message)s"
+    formatter = logging.Formatter(log_format)
+
+    # 根日志器
+    root_logger = logging.getLogger()
+    root_logger.setLevel(level)
+
+    # 控制台处理器
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(formatter)
+    root_logger.addHandler(console_handler)
+
+    # 日志文件配置
+    log_file_path = os.getenv("LOG_FILE_PATH", "logs/bot.log")
+    log_max_size = (
+        int(os.getenv("LOG_MAX_SIZE_MB", "10")) * 1024 * 1024
+    )  # 兆字节 -> 字节
+    log_backup_count = int(os.getenv("LOG_BACKUP_COUNT", "5"))
+
+    # 确保日志目录存在
+    log_dir = Path(log_file_path).parent
+    log_dir.mkdir(parents=True, exist_ok=True)
+
+    file_handler = RotatingFileHandler(
+        log_file_path,
+        maxBytes=log_max_size,
+        backupCount=log_backup_count,
+        encoding="utf-8",
+    )
+    file_handler.setFormatter(formatter)
+    root_logger.addHandler(file_handler)
+
+    logging.info(
+        f"[启动] 日志系统初始化完成。级别: {log_level}, 文件: {log_file_path} "
+        f"(最大 {log_max_size // 1024 // 1024}MB, 保留 {log_backup_count} 份)"
+    )
+
+
+async def main() -> None:
+    """主函数"""
+    setup_logging()
+    logger = logging.getLogger(__name__)
+    logger.info("[启动] 正在初始化 Undefined 机器人...")
+
+    try:
+        config = get_config()
+        logger.info(f"[配置] 机器人 QQ: {config.bot_qq}")
+        logger.info(f"[配置] 超级管理员: {config.superadmin_qq}")
+        logger.info(f"[配置] 管理员 QQ 列表: {config.admin_qqs}")
+    except ValueError as e:
+        logger.error(f"[配置错误] 加载配置失败: {e}")
+        sys.exit(1)
+
+    # 初始化组件
+    logger.info("[初始化] 正在加载核心组件...")
+    try:
+        onebot = OneBotClient(config.onebot_ws_url, config.onebot_token)
+        memory_storage = MemoryStorage(max_memories=100)
+        task_storage = ScheduledTaskStorage()
+        end_summary_storage = EndSummaryStorage()
+        ai = AIClient(
+            config.chat_model,
+            config.vision_model,
+            config.agent_model,
+            memory_storage,
+            end_summary_storage,
+        )
+        faq_storage = FAQStorage()
+
+        handler = MessageHandler(config, onebot, ai, faq_storage, task_storage)
+        onebot.set_message_handler(handler.handle_message)
+        logger.info("[初始化] 核心组件加载完成")
+    except Exception as e:
+        logger.exception(f"[初始化错误] 组件初始化期间发生异常: {e}")
+        sys.exit(1)
+
+    logger.info("[启动] 机器人已准备就绪，开始连接 OneBot 服务...")
+
+    try:
+        await onebot.run_with_reconnect()
+    except KeyboardInterrupt:
+        logger.info("[退出] 收到退出信号 (Ctrl+C)")
+    except Exception as e:
+        logger.exception(f"[异常] 运行期间发生未捕获的错误: {e}")
+    finally:
+        logger.info("[清理] 正在关闭机器人并释放资源...")
+        await onebot.disconnect()
+        await ai.close()
+        logger.info("[退出] 机器人已停止运行")
+
+
+def run() -> None:
+    """运行入口"""
+    asyncio.run(main())
+
+
+if __name__ == "__main__":
+    run()

Undefined/memory.py

@@ -0,0 +1,120 @@
+"""AI 记忆存储管理模块"""
+
+import json
+import logging
+from dataclasses import dataclass, asdict
+from datetime import datetime
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# 记忆数据存储路径
+MEMORY_FILE_PATH = Path("data/memory.json")
+
+
+@dataclass
+class Memory:
+    """单条记忆数据"""
+
+    fact: str  # 记忆内容
+    created_at: str  # 创建时间
+
+
+class MemoryStorage:
+    """AI 记忆存储管理器"""
+
+    def __init__(self, max_memories: int = 100) -> None:
+        """初始化记忆存储
+
+        参数:
+            max_memories: 最大记忆数量
+        """
+        self.max_memories = max_memories
+        self._memories: list[Memory] = []
+        self._load()
+
+    def _load(self) -> None:
+        """从文件加载记忆"""
+        if not MEMORY_FILE_PATH.exists():
+            self._memories = []
+            return
+
+        try:
+            with open(MEMORY_FILE_PATH, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            self._memories = [Memory(**item) for item in data]
+            logger.info(f"已加载 {len(self._memories)} 条记忆")
+        except Exception as e:
+            logger.warning(f"加载记忆失败: {e}")
+            self._memories = []
+
+    def _save(self) -> None:
+        """保存记忆到文件"""
+        try:
+            MEMORY_FILE_PATH.parent.mkdir(parents=True, exist_ok=True)
+            with open(MEMORY_FILE_PATH, "w", encoding="utf-8") as f:
+                json.dump(
+                    [asdict(m) for m in self._memories], f, ensure_ascii=False, indent=2
+                )
+            logger.debug(f"已保存 {len(self._memories)} 条记忆")
+        except Exception as e:
+            logger.error(f"保存记忆失败: {e}")
+
+    def add(self, fact: str) -> bool:
+        """添加一条记忆
+
+        参数:
+            fact: 记忆内容
+
+        返回:
+            是否添加成功
+        """
+        if not fact or not fact.strip():
+            logger.warning("尝试添加空记忆，已忽略")
+            return False
+
+        # 检查是否已存在相同记忆
+        for existing in self._memories:
+            if existing.fact == fact.strip():
+                logger.debug(f"记忆已存在，忽略: {fact[:50]}...")
+                return False
+
+        memory = Memory(
+            fact=fact.strip(), created_at=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        )
+
+        # 添加到列表末尾
+        self._memories.append(memory)
+
+        # 如果超过上限，移除最旧的（最早的）
+        if len(self._memories) > self.max_memories:
+            removed = self._memories.pop(0)
+            logger.info(f"记忆数量超过上限，移除最旧记忆: {removed.fact[:50]}...")
+
+        self._save()
+        logger.info(
+            f"已添加记忆: {fact[:50]}... (当前 {len(self._memories)}/{self.max_memories})"
+        )
+        return True
+
+    def get_all(self) -> list[Memory]:
+        """获取所有记忆
+
+        返回:
+            记忆列表（按时间顺序，最早的在前）
+        """
+        return self._memories.copy()
+
+    def clear(self) -> None:
+        """清空所有记忆"""
+        self._memories = []
+        self._save()
+        logger.info("已清空所有记忆")
+
+    def count(self) -> int:
+        """获取记忆数量
+
+        返回:
+            当前记忆数量
+        """
+        return len(self._memories)