Undefined-bot 2.1.0__py3-none-any.whl

Undefined/skills/agents/social_agent/tools/video_random_recommend/handler.py

@@ -0,0 +1,21 @@
+from typing import Any, Dict
+import httpx
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+async def execute(args: Dict[str, Any], context: Dict[str, Any]) -> str:
+    url = "https://api.jkyai.top/API/jxhssp.php"
+
+    try:
+        async with httpx.AsyncClient(timeout=15.0, follow_redirects=True) as client:
+            # 我们只需要最终的 URL，所以我们触发请求并检查历史或 url
+            response = await client.get(url)
+            final_url = str(response.url)
+
+            return f"🎥 随机视频推荐:\n{final_url}"
+
+    except Exception as e:
+        logger.exception(f"获取视频失败: {e}")
+        return f"获取视频失败: {e}"

Undefined/skills/agents/web_agent/config.json

@@ -0,0 +1,17 @@
+{
+    "type": "function",
+    "function": {
+        "name": "web_agent",
+        "description": "网络搜索助手，提供网页搜索和网页内容获取功能，用于获取互联网上的最新信息。",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "prompt": {
+                    "type": "string",
+                    "description": "用户的搜索需求，例如：'搜索 Python 异步编程的最新发展'、'获取 https://example.com 的内容'"
+                }
+            },
+            "required": ["prompt"]
+        }
+    }
+}

Undefined/skills/agents/web_agent/handler.py

@@ -0,0 +1,221 @@
+from typing import Any, Dict, Callable
+import importlib.util
+import json
+import asyncio
+import aiofiles
+import logging
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class AgentToolRegistry:
+    """Agent 内部的工具注册表"""
+
+    def __init__(self, tools_dir: Path) -> None:
+        self.tools_dir: Path = (
+            tools_dir if isinstance(tools_dir, Path) else Path(tools_dir)
+        )
+        self._tools_schema: list[dict[str, Any]] = []
+        self._tools_handlers: dict[str, Callable[..., Any]] = {}
+        self.load_tools()
+
+    def load_tools(self) -> None:
+        """加载 agent 专属工具"""
+        if not self.tools_dir.exists():
+            logger.warning(f"Agent tools directory does not exist: {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)
+
+        logger.info(
+            f"Agent loaded {len(self._tools_schema)} tools: {list(self._tools_handlers.keys())}"
+        )
+
+    def _load_tool_from_dir(self, tool_dir: Path) -> None:
+        """从目录加载工具"""
+        config_path: Path = tool_dir / "config.json"
+        handler_path: Path = tool_dir / "handler.py"
+
+        if not config_path.exists() or not handler_path.exists():
+            return
+
+        try:
+            with open(config_path, "r", encoding="utf-8") as f:
+                config: dict[str, Any] = json.load(f)
+
+            if "function" not in config or "name" not in config.get("function", {}):
+                return
+
+            tool_name: str = config["function"]["name"]
+
+            spec = importlib.util.spec_from_file_location(
+                f"agent_tools.{tool_name}", handler_path
+            )
+            if spec is None or spec.loader is None:
+                return
+
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+
+            if not hasattr(module, "execute"):
+                return
+
+            self._tools_schema.append(config)
+            self._tools_handlers[tool_name] = module.execute
+
+        except Exception as e:
+            logger.error(f"Failed to load tool from {tool_dir}: {e}")
+
+    def get_tools_schema(self) -> list[dict[str, Any]]:
+        """获取工具 schema"""
+        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 not found: {tool_name}"
+
+        try:
+            if asyncio.iscoroutinefunction(handler):
+                result = await handler(args, context)
+            else:
+                result = handler(args, context)
+            return str(result)
+        except Exception as e:
+            logger.exception(f"Error executing tool {tool_name}")
+            return f"Error executing tool {tool_name}: {str(e)}"
+
+
+async def _load_prompt() -> str:
+    """从 prompt.md 文件加载系统提示词"""
+    prompt_path: Path = Path(__file__).parent / "prompt.md"
+    if prompt_path.exists():
+        async with aiofiles.open(prompt_path, "r", encoding="utf-8") as f:
+            return await f.read()
+    return _get_default_prompt()
+
+
+def _get_default_prompt() -> str:
+    """默认提示词"""
+    return "你是一个网络搜索助手..."
+
+
+async def execute(args: Dict[str, Any], context: Dict[str, Any]) -> str:
+    """执行 web_agent"""
+    user_prompt: str = args.get("prompt", "")
+
+    if not user_prompt:
+        return "请提供您的搜索需求"
+
+    agent_tools_dir: Path = Path(__file__).parent / "tools"
+    tool_registry = AgentToolRegistry(agent_tools_dir)
+
+    tools: list[dict[str, Any]] = tool_registry.get_tools_schema()
+
+    ai_client = context.get("ai_client")
+    if not ai_client:
+        return "AI client 未在上下文中提供"
+
+    agent_config = ai_client.agent_config
+
+
+    system_prompt: str = await _load_prompt()
+
+    messages: list[dict[str, Any]] = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": f"用户需求：{user_prompt}"},
+    ]
+
+    max_iterations: int = 20
+    iteration: int = 0
+
+    while iteration < max_iterations:
+        iteration += 1
+
+        try:
+            response = await ai_client._http_client.post(
+                agent_config.api_url,
+                headers={
+                    "Authorization": f"Bearer {agent_config.api_key}",
+                    "Content-Type": "application/json",
+                },
+                json=ai_client._build_request_body(
+                    model_config=agent_config,
+                    messages=messages,
+                    max_tokens=agent_config.max_tokens,
+                    tools=tools if tools else None,
+                    tool_choice="auto",
+                ),
+            )
+            response.raise_for_status()
+            result: dict[str, Any] = response.json()
+
+            choice: dict[str, Any] = result.get("choices", [{}])[0]
+            message: dict[str, Any] = choice.get("message", {})
+            content: str = message.get("content") or ""
+            tool_calls: list[dict[str, Any]] = message.get("tool_calls", [])
+
+            if content.strip() and tool_calls:
+                content = ""
+
+            if not tool_calls:
+                return content
+
+            messages.append(
+                {"role": "assistant", "content": content, "tool_calls": tool_calls}
+            )
+
+            # 准备并发执行工具
+            tool_tasks = []
+            tool_call_ids = []
+
+            for tool_call in tool_calls:
+                call_id: str = tool_call.get("id", "")
+                function: dict[str, Any] = tool_call.get("function", {})
+                function_name: str = function.get("name", "")
+                function_args_str: str = function.get("arguments", "{}")
+
+                logger.info(f"Agent preparing tool: {function_name}")
+
+                try:
+                    function_args: dict[str, Any] = json.loads(function_args_str)
+                except json.JSONDecodeError:
+                    function_args = {}
+
+                tool_call_ids.append(call_id)
+                tool_tasks.append(
+                    tool_registry.execute_tool(function_name, function_args, context)
+                )
+
+            # 并发执行
+            if tool_tasks:
+                logger.info(f"Agent executing {len(tool_tasks)} tools in parallel")
+                results = await asyncio.gather(*tool_tasks, return_exceptions=True)
+
+                for i, tool_result in enumerate(results):
+                    call_id = tool_call_ids[i]
+                    content_str: str = ""
+                    if isinstance(tool_result, Exception):
+                        content_str = f"Error: {str(tool_result)}"
+                    else:
+                        content_str = str(tool_result)
+
+                    messages.append(
+                        {
+                            "role": "tool",
+                            "tool_call_id": call_id,
+                            "content": content_str,
+                        }
+                    )
+
+        except Exception as e:
+            logger.exception(f"Agent execution failed: {e}")
+            return f"处理失败: {e}"
+
+    return "达到最大迭代次数"

Undefined/skills/agents/web_agent/intro.md

@@ -0,0 +1,14 @@
+# 网络搜索助手
+
+## 能力
+- **网页搜索**：使用搜索引擎获取互联网最新信息
+- **网页爬取**：获取指定 URL 的网页内容并转换为 Markdown
+
+## 适用场景
+- 用户询问的问题需要实时联网搜索时（如新闻、最新技术文档）
+- 用户提供 URL 让你阅读或总结网页内容时
+- 知识库中没有相关信息时
+
+## 参数说明
+- `query` (搜索): 搜索关键词
+- `url` (爬取): 目标网页链接

Undefined/skills/agents/web_agent/prompt.md

@@ -0,0 +1,16 @@
+你是一个网络搜索助手，专门帮助用户在互联网上查找信息。
+
+你的任务是根据用户需求，选择合适的工具来完成任务：
+
+1. **网页搜索** → web_search
+2. **获取网页内容** → crawl_webpage
+
+注意事项：
+- 搜索结果可能包含广告或无关内容
+- 网页内容可能会被截断
+- 保持回答简洁，提供关键信息
+- 标注信息来源和链接
+
+如果用户需求不明确，请先询问用户澄清问题。
+
+如果问题涉及时间，立刻调用时间工具获取。

Undefined/skills/agents/web_agent/tools/__init__.py

@@ -0,0 +1 @@
+# Web Agent Tools

Undefined/skills/agents/web_agent/tools/crawl_webpage/config.json

@@ -0,0 +1,21 @@
+{
+    "type": "function",
+    "function": {
+        "name": "crawl_webpage",
+        "description": "获取指定网页的内容，返回结构化的 Markdown 格式文本。支持获取网页的标题、正文、链接等信息。",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "url": {
+                    "type": "string",
+                    "description": "要获取的网页 URL"
+                },
+                "max_chars": {
+                    "type": "integer",
+                    "description": "返回的最大字符数（默认为 4096）"
+                }
+            },
+            "required": ["url"]
+        }
+    }
+}

Undefined/skills/agents/web_agent/tools/crawl_webpage/handler.py

@@ -0,0 +1,102 @@
+from typing import Any, Dict
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+
+async def execute(args: Dict[str, Any], context: Dict[str, Any]) -> str:
+    url = args.get("url", "")
+    if not url:
+        return "URL 不能为空"
+
+    # 从 context 标志检查可用性或尝试导入
+    if not context.get("crawl4ai_available", False):
+        return "网页获取功能未启用（crawl4ai 未安装）"
+
+    try:
+        from crawl4ai import AsyncWebCrawler, BrowserConfig, CrawlerRunConfig
+
+        try:
+            from crawl4ai import ProxyConfig
+
+            _PROXY_CONFIG_AVAILABLE = True
+        except ImportError:
+            _PROXY_CONFIG_AVAILABLE = False
+
+    except ImportError:
+        return "网页获取功能未启用（crawl4ai 未安装）"
+
+    max_chars = args.get("max_chars", 4096)
+
+    try:
+        use_proxy = os.getenv("USE_PROXY", "true").lower() == "true"
+        proxy = (
+            os.getenv("http_proxy")
+            or os.getenv("https_proxy")
+            or os.getenv("HTTP_PROXY")
+            or os.getenv("HTTPS_PROXY")
+        )
+
+        browser_config = BrowserConfig(
+            headless=True,
+            user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+            viewport_width=1280,
+            viewport_height=720,
+        )
+
+        run_config_kwargs = {
+            "word_count_threshold": 1,
+            "cache_mode": "bypass",
+            "page_timeout": 30000,
+            "wait_for": "body",
+            "delay_before_return_html": 2.0,
+        }
+
+        if use_proxy and proxy:
+            logger.info(f"使用代理: {proxy}")
+            if _PROXY_CONFIG_AVAILABLE:
+                run_config_kwargs["proxy_config"] = ProxyConfig(server=proxy)
+            else:
+                run_config_kwargs["proxy_config"] = proxy
+        elif use_proxy and not proxy:
+            logger.warning("USE_PROXY=true 但未找到代理配置，将不使用代理")
+
+        run_config = CrawlerRunConfig(**run_config_kwargs)
+
+        async with AsyncWebCrawler(config=browser_config) as crawler:
+            result = await crawler.arun(url=url, config=run_config)
+
+            if result.success:
+                content = "# 网页解析结果\n\n"
+                content += f"**URL**: {result.url}\n\n"
+
+                if hasattr(result, "title") and result.title:
+                    content += f"**标题**: {result.title}\n\n"
+
+                if hasattr(result, "description") and result.description:
+                    content += f"**描述**: {result.description}\n\n"
+
+                content += "---\n\n## 内容\n\n"
+
+                markdown_text = result.markdown or ""
+                if max_chars > 0 and len(markdown_text) > max_chars:
+                    markdown_text = markdown_text[:max_chars] + "\n\n...（内容已截断）"
+
+                content += markdown_text
+                return content
+            else:
+                error_msg = getattr(result, "error_message", "未知错误")
+                logger.error(f"抓取失败: {error_msg}")
+                return f"网页抓取失败: {error_msg}"
+
+    except RuntimeError as e:
+        if "ERR_NETWORK_CHANGED" in str(e) or "ERR_CONNECTION" in str(e):
+            logger.error(f"网络连接错误: {e}")
+            return f"网络连接错误，可能是代理配置问题。请检查代理设置或设置 USE_PROXY=false 禁用代理。错误: {e}"
+        else:
+            logger.error(f"抓取网页时发生错误: {e}")
+            return f"抓取网页时发生错误: {e}"
+    except Exception as e:
+        logger.error(f"网页获取失败: {e}")
+        return f"网页获取失败: {e}"

Undefined/skills/agents/web_agent/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/agents/web_agent/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/agents/web_agent/tools/web_search/config.json

@@ -0,0 +1,21 @@
+{
+    "type": "function",
+    "function": {
+        "name": "web_search",
+        "description": "使用 SearXNG 搜索引擎进行网页搜索，获取互联网上的信息。用于回答需要最新信息或你不确定的问题。",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": "搜索关键词"
+                },
+                "num_results": {
+                    "type": "integer",
+                    "description": "返回结果数量（默认为 5）"
+                }
+            },
+            "required": ["query"]
+        }
+    }
+}

Undefined/skills/agents/web_agent/tools/web_search/handler.py

@@ -0,0 +1,29 @@
+from typing import Any, Dict
+import logging
+
+logger = logging.getLogger(__name__)
+
+async def execute(args: Dict[str, Any], context: Dict[str, Any]) -> str:
+    query = args.get("query", "")
+    if not query:
+        return "搜索关键词不能为空"
+    
+    search_wrapper = context.get("search_wrapper")
+    if not search_wrapper:
+        return "搜索功能未启用（SEARXNG_URL 未配置或 langchain_community 未安装）"
+    
+    num_results = args.get("num_results", 5)
+    
+    try:
+        results = search_wrapper.run(
+            query,
+            num_results=num_results
+        )
+
+        if results:
+            return f"搜索结果:\n{results}"
+        else:
+            return "搜索未返回结果"
+    except Exception as e:
+        logger.error(f"搜索执行失败: {e}")
+        return f"搜索执行失败: {e}"

Undefined/skills/tools/README.md

@@ -0,0 +1,85 @@
+# NagaAgent 机器人工具系统
+
+本项目采用模块化工具架构，所有工具都位于 `src/Undefined/tools/` 目录下。每个工具都是一个独立的文件夹，包含配置和实现逻辑。
+
+## 目录结构
+
+```text
+tools/
+├── __init__.py          # 工具注册表 (ToolRegistry)
+├── README.md            # 本说明文件
+└── tool_name/           # 工具名称
+    ├── config.json      # 工具定义 (OpenAI 格式)
+    └── handler.py       # 工具逻辑实现
+```
+
+## 如何添加一个新工具
+
+### 1. 创建工具目录
+在 `src/Undefined/tools/` 下创建一个新文件夹，例如 `my_new_tool`。
+
+### 2. 编写 `config.json`
+该文件定义了工具的名称、描述和参数结构（遵循 OpenAI function calling 格式）。
+
+```json
+{
+    "type": "function",
+    "function": {
+        "name": "my_new_tool",
+        "description": "这里写工具的功能描述",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "arg1": {
+                    "type": "string",
+                    "description": "参数1的描述"
+                }
+            },
+            "required": ["arg1"]
+        }
+    }
+}
+```
+
+### 3. 编写 `handler.py`
+实现工具的具体逻辑。必须包含一个异步函数 `execute(args, context)`。
+
+```python
+from typing import Any, Dict
+
+async def execute(args: Dict[str, Any], context: Dict[str, Any]) -> str:
+    # 1. 获取参数
+    val = args.get("arg1")
+    
+    # 2. 执行逻辑
+    result = f"处理结果: {val}"
+    
+    # 3. 返回字符串结果给 AI
+    return result
+```
+
+## 关于 Context 对象
+
+`context` 参数包含了机器人运行时的上下文和回调函数，常用的有：
+
+| 键名 | 类型 | 说明 |
+| :--- | :--- | :--- |
+| `send_message_callback` | `Callable` | 发送群消息的回调 |
+| `send_private_message_callback` | `Callable` | 发送私聊消息的回调 |
+| `send_image_callback` | `Callable` | 发送图片的回调 |
+| `get_recent_messages_callback` | `Callable` | 获取历史消息的回调 |
+| `memory_storage` | `MemoryStorage` | 记忆存储实例 |
+| `ai_client` | `AIClient` | AI 客户端实例（用于调用图片描述等） |
+| `sender` | `MessageSender` | 统一消息发送接口（自动记录历史） |
+| `history_manager` | `MessageHistoryManager` | 统一历史记录管理器 |
+| `base_path` | `Path` | 默认的基础路径 (通常锁定在 `code/NagaAgent`) |
+
+## 自动发现
+
+工具注册表 (`ToolRegistry`) 会在初始化时自动扫描目录下的所有文件夹。只要文件夹内同时存在 `config.json` 和 `handler.py`，工具就会被自动加载并提供给 AI 使用，**无需手动修改任何导入代码**。
+
+## 开发建议
+
+1. **返回字符串**：工具的返回值必须是字符串。如果是复杂数据，请将其转为 JSON 字符串或格式化的文本。
+2. **错误处理**：在 `handler.py` 中使用 `try...except` 捕获异常并返回友好的错误信息，这样 AI 可以理解发生了什么并尝试修复。
+3. **安全限制**：如果涉及文件操作，务必校验路径是否在 `base_path` 范围内，防止路径穿越攻击。