entari-plugin-hyw 3.3.1__py3-none-any.whl → 3.3.2__py3-none-any.whl

entari_plugin_hyw/utils/__init__.py

@@ -0,0 +1,2 @@
+from .prompts import AGENT_SP
+from .misc import process_onebot_json, process_images

entari_plugin_hyw/utils/browser.py

@@ -0,0 +1,40 @@
+from typing import Any
+from loguru import logger
+from crawl4ai import AsyncWebCrawler
+from crawl4ai.async_configs import CrawlerRunConfig
+from crawl4ai.cache_context import CacheMode
+
+
+class BrowserTool:
+    """Crawl4AI-based page fetcher."""
+
+    def __init__(self, config: Any):
+        self.config = config
+
+    async def navigate(self, url: str) -> str:
+        """Fetch URL content via Crawl4AI and return markdown."""
+        if not url:
+            return "Error: missing url"
+        try:
+            async with AsyncWebCrawler() as crawler:
+                result = await crawler.arun(
+                    url=url,
+                    config=CrawlerRunConfig(
+                        wait_until="networkidle",
+                        wait_for_images=True,
+                        cache_mode=CacheMode.BYPASS,
+                        word_count_threshold=1,
+                        screenshot=False,
+                    ),
+                )
+            if not result.success:
+                return f"Error navigating to {url}: {result.error_message or result.status_code}"
+
+            content = result.markdown or result.extracted_content or result.cleaned_html or result.html or ""
+            return content[:8000]
+        except Exception as e:
+            logger.error(f"HTTP navigation failed: {e}")
+            return f"Error navigating to {url}: {e}"
+
+    async def close(self):
+        return None

entari_plugin_hyw/utils/misc.py

@@ -0,0 +1,93 @@
+import json
+import base64
+import httpx
+from typing import Dict, Any, List, Optional
+from loguru import logger
+from arclet.entari import MessageChain, Image
+from typing import Tuple
+import asyncio
+from satori.exception import ActionFailed
+
+def process_onebot_json(data: Dict[str, Any]) -> str:
+    """Process OneBot JSON elements"""
+    try:
+        if "data" in data:
+            json_str = data["data"]
+            if isinstance(json_str, str):
+                json_str = json_str.replace(""", '"').replace(",", ",")
+                content = json.loads(json_str)
+                if "meta" in content and "detail_1" in content["meta"]:
+                    detail = content["meta"]["detail_1"]
+                    if "desc" in detail and "qqdocurl" in detail:
+                        return f"[Shared Document] {detail['desc']}: {detail['qqdocurl']}"
+    except Exception as e:
+        logger.warning(f"Failed to process JSON element: {e}")
+    return ""
+
+
+
+
+
+async def download_image(url: str) -> bytes:
+    """下载图片"""
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            resp = await client.get(url)
+            if resp.status_code == 200:
+                return resp.content
+            else:
+                raise ActionFailed(f"下载图片失败，状态码: {resp.status_code}")
+    except Exception as e:
+        raise ActionFailed(f"下载图片失败: {url}, 错误: {str(e)}")
+
+async def process_images(mc: MessageChain, vision_model: Optional[str] = None) -> Tuple[List[str], Optional[str]]:
+    # If vision model is explicitly set to "off", skip image processing
+    if vision_model == "off":
+        return [], None
+        
+    has_images = bool(mc.get(Image))
+    images = []
+    if has_images:
+        urls = mc[Image].map(lambda x: x.src)
+        tasks = [download_image(url) for url in urls]
+        raw_images = await asyncio.gather(*tasks)
+        import base64
+        images = [base64.b64encode(img).decode('utf-8') for img in raw_images]
+    
+    return images, None
+
+
+def resolve_model_name(name: str, models_config: List[Dict[str, Any]]) -> Tuple[Optional[str], Optional[str]]:
+    """
+    Resolve a user input model name to the full API model name from config.
+    Supports partial matching if unique.
+    """
+    if not name:
+        return None, "No model name provided"
+        
+    name = name.lower()
+    
+    # 1. Exact match (name or id or shortname)
+    for m in models_config:
+        if m.get("name") == name or m.get("id") == name:
+            return m.get("name"), None
+            
+    # 2. Key/Shortcut match
+    # Assuming the config might have keys like 'gpt4' mapping to full name
+    # But usually models list is [{'name': '...', 'provider': '...'}, ...]
+    
+    # Check if 'name' matches any model 'name' partially?
+    # Or just return the name itself if it looks like a valid model ID (contains / or -)
+    if "/" in name or "-" in name or "." in name:
+        return name, None
+        
+    # If not found in config specific list, and doesn't look like an ID, maybe return error
+    # But let's look for partial match in config names
+    matches = [m["name"] for m in models_config if name in m.get("name", "").lower()]
+    if len(matches) == 1:
+        return matches[0], None
+    elif len(matches) > 1:
+        return None, f"Model name '{name}' is ambiguous. Matches: {', '.join(matches[:3])}..."
+        
+    # Default: assume it's a valid ID passed directly
+    return name, None

entari_plugin_hyw/utils/playwright_tool.py

@@ -0,0 +1,36 @@
+from typing import Any
+from loguru import logger
+from crawl4ai.async_configs import CrawlerRunConfig
+from crawl4ai.cache_context import CacheMode
+from .search import get_shared_crawler
+
+
+class PlaywrightTool:
+    """
+    Backwards-compatible wrapper now powered by Crawl4AI.
+    """
+    def __init__(self, config: Any):
+        self.config = config
+
+    async def navigate(self, url: str) -> str:
+        if not url:
+            return "Error: Missing url"
+
+        try:
+            crawler = await get_shared_crawler()
+            result = await crawler.arun(
+                url=url,
+                config=CrawlerRunConfig(
+                    wait_until="networkidle",
+                    wait_for_images=True,
+                    cache_mode=CacheMode.BYPASS,
+                    word_count_threshold=1,
+                    screenshot=False,
+                ),
+            )
+            if not result.success:
+                return f"Error: crawl failed ({result.error_message or result.status_code})"
+            return (result.markdown or result.extracted_content or result.cleaned_html or result.html or "")[:8000]
+        except Exception as e:
+            logger.warning(f"Crawl navigation failed: {e}")
+            return f"Error: Crawl navigation failed: {e}"

entari_plugin_hyw/utils/prompts.py

@@ -0,0 +1,129 @@
+VISION_SP = """# 你是一个专业的视觉转文字专家.
+
+# 核心任务
+- 智能分析图片内容, 转述成文本, 除此之外不要添加任何内容
+- 文字优先: 若包含清晰文字（文档、截图等）, 必须完整准确转录, 不要遗漏.
+- 视觉补充: 若无文字, 重点描述视觉内容（物体、场景、氛围）.
+- 用户要求: 根据用户消息中提示侧重转文本的偏向, 若无或无关联则不理会常规完成.
+
+## 用户消息
+```text
+{user_msgs}
+```
+"""
+
+INTRUCT_SP = """# 你是一个专业的指导专家.
+
+## 核心任务
+- 决定预处理工具:
+  - 用户消息包含链接: 调用 crawl_page 获取内容, 无需其他工具
+  - 用户消息包含典型名词、可能的专有名词组合: 调用 internal_web_search 
+    - 提炼出关键词搜索关键词本身, 不添加任何其他助词, 搜索效果最好
+    - 同时调用 internal_image_search
+  - 用户消息不需要搜索: 不调用工具
+- 调用 set_mode:
+  - 绝大部分常规问题: standard
+  - 用户要求研究/深度搜索: agent
+  - 需要获取页面具体信息才能回答问题: agent
+> 所有工具需要在本次对话同时调用
+
+## 调用工具
+- 使用工具时, 必须通过 function_call / tool_call 机制调用.
+{tools_desc}
+
+## 你的回复
+调用工具后无需额外文本.
+
+## 用户消息
+```
+{user_msgs}
+```
+"""
+
+
+INTRUCT_SP_VISION_ADD = """
+## 视觉专家消息
+```text
+{vision_msgs}
+```
+"""
+
+AGENT_SP = """# 你是一个 Agent 总控专家, 你需要理解用户意图, 根据已有信息给出最终回复.
+> 请确保你输出的任何消息有着准确的来源, 减少输出错误信息.
+
+当前模式: {mode}, {mode_desc}
+
+## 最终回复格式要求
+- 直接输出 Markdown 正文.
+
+当不调用工具发送文本, 即会变成最终回复, 请遵守: 
+- 语言: 简体中文, 百科式风格, 语言严谨不啰嗦.
+- 正文格式: 使用 Markdown格式, [hightlight, katex], 有大标题, 内容丰富突出重点.
+- 工具引用: 
+  - 搜索摘要引用: 使用 `search:数字id` 如 `search:3`
+  - 页面内容引用: 使用 `page:数字id` 如 `page:5`
+  - 每个引用必须分开标注
+  - 在正文底部添加 references 代码块:
+    - 用不到的条目不写, 没有专家给信息就不写.
+    ```references
+    [1] [search] [文本描述](url)
+    [3] [search] [文本描述](url)
+    [5] [page] [页面标题](url)
+    [7] [page] [页面标题](url)
+    ```
+
+## 用户消息
+```text
+{user_msgs}
+```
+"""
+
+# PS: agent 无搜索图片权限
+AGENT_SP_TOOLS_STANDARD_ADD = """
+你需要整合已有的信息, 提炼用户消息中的关键词, 进行最终回复.
+"""
+
+
+AGENT_SP_TOOLS_AGENT_ADD = """
+- 你现在可以使用工具: {tools_desc}
+  - 你需要判断顺序或并发使用工具获取信息:
+    - 0-1 次 internal_web_search
+    - 0-1 次 internal_image_search (如果用户需要图片, 通常和 internal_web_search 并发执行)
+    - 1-2 次 crawl_page
+- 使用工具时, 必须通过 function_call / tool_call 机制调用.
+"""
+
+
+
+AGENT_SP_INTRUCT_VISION_ADD = """
+## 视觉专家消息
+```text
+{vision_msgs}
+```
+"""
+
+AGENT_SP_SEARCH_ADD = """
+## 搜索专家消息
+```text
+{search_msgs}
+```
+
+
+"""
+
+AGENT_SP_PAGE_ADD = """
+## 页面内容专家消息
+```text
+{page_msgs}
+```
+- 引用页面内容时, 必须使用 `page:id` 格式
+"""
+
+AGENT_SP_IMAGE_SEARCH_ADD = """
+## 图像搜索专家消息
+```text
+{image_search_msgs}
+```
+- 每进行一次 internal_image_search, 挑选 1 张图像插入正文
+"""
+

entari_plugin_hyw/utils/search.py

@@ -0,0 +1,241 @@
+import urllib.parse
+from typing import List, Dict, Optional, Any
+from loguru import logger
+from crawl4ai import AsyncWebCrawler
+from crawl4ai.async_configs import CrawlerRunConfig
+from crawl4ai.cache_context import CacheMode
+
+# Shared crawler instance to avoid repeated init
+_shared_crawler: Optional[AsyncWebCrawler] = None
+
+
+async def get_shared_crawler() -> AsyncWebCrawler:
+    global _shared_crawler
+    if _shared_crawler is None:
+        _shared_crawler = AsyncWebCrawler()
+        await _shared_crawler.start()
+    return _shared_crawler
+
+
+async def close_shared_crawler():
+    global _shared_crawler
+    if _shared_crawler:
+        try:
+            await _shared_crawler.close()
+        except Exception:
+            pass
+        _shared_crawler = None
+
+class SearchService:
+    """
+    Crawl4AI-backed search & fetch service.
+    Uses the configured search engine results page (SERP) URL and parses links from the HTML.
+    """
+    def __init__(self, config: Any):
+        self.config = config
+        self._default_limit = 8
+        self._crawler: Optional[AsyncWebCrawler] = None
+
+    def _build_search_url(self, query: str) -> str:
+        encoded_query = urllib.parse.quote(query)
+        base = getattr(self.config, "search_base_url", "https://lite.duckduckgo.com/lite/?q={query}")
+        if "{query}" in base:
+            return base.replace("{query}", encoded_query).replace("{limit}", str(self._default_limit))
+        sep = "&" if "?" in base else "?"
+        return f"{base}{sep}q={encoded_query}"
+
+    def _build_image_url(self, query: str) -> str:
+        encoded_query = urllib.parse.quote(query)
+        base = getattr(self.config, "image_search_base_url", "https://duckduckgo.com/?q={query}&iax=images&ia=images")
+        if "{query}" in base:
+            return base.replace("{query}", encoded_query).replace("{limit}", str(self._default_limit))
+        sep = "&" if "?" in base else "?"
+        return f"{base}{sep}q={encoded_query}&iax=images&ia=images"
+
+    async def search(self, query: str) -> List[Dict[str, str]]:
+        """
+        Crawl the configured SERP using Crawl4AI and return parsed results.
+        """
+        if not query:
+            return []
+
+        url = self._build_search_url(query)
+        logger.info(f"SearchService(Crawl4AI): fetching {url}")
+
+        try:
+            crawler = await self._get_crawler()
+            result = await crawler.arun(
+                url=url,
+                config=CrawlerRunConfig(
+                    wait_until="domcontentloaded",
+                    wait_for="article",
+                    cache_mode=CacheMode.BYPASS,
+                    word_count_threshold=1,
+                    screenshot=False,
+                    capture_console_messages=False,
+                    capture_network_requests=False,
+                ),
+            )
+            return self._parse_markdown_result(result, limit=self._default_limit)
+        except Exception as e:
+            logger.error(f"Crawl4AI search failed: {e}")
+            return []
+
+    def _parse_markdown_result(self, result, limit: int = 8) -> List[Dict[str, str]]:
+        """Parse Crawl4AI result into search items without manual HTML parsing."""
+        md = (result.markdown or result.extracted_content or "").strip()
+        lines = [ln.strip() for ln in md.splitlines() if ln.strip()]
+        links = result.links.get("external", []) if getattr(result, "links", None) else []
+        seen = set()
+        results: List[Dict[str, str]] = []
+
+        def find_snippet(url: str, domain: str) -> str:
+            for ln in lines:
+                if url in ln or (domain and domain in ln):
+                    return ln[:400]
+            # fallback to first non-empty line
+            return lines[0][:400] if lines else ""
+
+        for link in links:
+            url = link.get("href") or ""
+            if not url or url in seen:
+                continue
+            seen.add(url)
+            domain = urllib.parse.urlparse(url).hostname or ""
+            title = link.get("title") or link.get("text") or url
+            snippet = find_snippet(url, domain)
+            results.append({
+                "title": title.strip(),
+                "url": url,
+                "domain": domain,
+                "content": snippet or title,
+            })
+            if len(results) >= limit:
+                break
+
+        if not results:
+            logger.warning(f"SearchService: no results parsed; md_length={len(md)}, links={len(links)}")
+        else:
+            logger.info(f"SearchService: parsed {len(results)} results via Crawl4AI links")
+        return results
+
+    async def fetch_page(self, url: str) -> Dict[str, str]:
+        """
+        Fetch a single page via Crawl4AI and return cleaned markdown/text plus metadata.
+        """
+        if not url:
+            return {"content": "Error: missing url", "title": "Error", "url": ""}
+
+        try:
+            crawler = await self._get_crawler()
+            result = await crawler.arun(
+                url=url,
+                config=CrawlerRunConfig(
+                    wait_until="networkidle",
+                    wait_for_images=False,  # Faster: skip image loading
+                    cache_mode=CacheMode.BYPASS,
+                    word_count_threshold=1,
+                    screenshot=False,
+                    capture_console_messages=False,
+                    capture_network_requests=False,
+                ),
+            )
+            if not result.success:
+                return {"content": f"Error: crawl failed ({result.error_message or 'unknown'})", "title": "Error", "url": url}
+            
+            content = result.markdown or result.extracted_content or result.cleaned_html or result.html or ""
+            # Extract metadata if available, otherwise fallback
+            title = "No Title"
+            if result.metadata:
+                title = result.metadata.get("title") or result.metadata.get("og:title") or title
+            
+            # If metadata title is missing/generic, try to grab from links or url? No, metadata is best.
+            if title == "No Title" and result.links:
+                 # Minimal fallback not really possible without parsing HTML again or regex
+                 pass
+
+            return {
+                "content": content[:8000], 
+                "title": title, 
+                "url": result.url or url 
+            }
+        except Exception as e:
+            logger.error(f"Crawl4AI fetch failed: {e}")
+            return {"content": f"Error: crawl failed ({e})", "title": "Error", "url": url}
+
+    async def _get_crawler(self) -> AsyncWebCrawler:
+        # Prefer shared crawler to minimize INIT logs; fall back to local if needed
+        try:
+            return await get_shared_crawler()
+        except Exception as e:
+            logger.warning(f"Shared crawler unavailable, creating local: {e}")
+            if self._crawler is None:
+                self._crawler = AsyncWebCrawler()
+                await self._crawler.start()
+            return self._crawler
+
+    async def close(self):
+        if self._crawler:
+            try:
+                await self._crawler.close()
+            except Exception:
+                pass
+            self._crawler = None
+
+    async def image_search(self, query: str) -> List[Dict[str, str]]:
+        """
+        Image search via Crawl4AI media extraction.
+        """
+        if not query:
+            return []
+
+        url = self._build_image_url(query)
+        logger.info(f"SearchService(Crawl4AI Image): fetching {url}")
+
+        try:
+            # Use image crawler (text_mode=False) for image search
+            crawler = await self._get_crawler()
+            result = await crawler.arun(
+                url=url,
+                config=CrawlerRunConfig(
+                    wait_until="networkidle",
+                    wait_for_images=True,
+                    wait_for="img",
+                    cache_mode=CacheMode.BYPASS,
+                    word_count_threshold=1,
+                    screenshot=False,
+                    capture_console_messages=False,
+                    capture_network_requests=False,
+                ),
+            )
+            images = []
+            seen = set()
+            for img in result.media.get("images", []):
+                src = img.get("src") or ""
+                if not src:
+                    continue
+                if src.startswith("//"):
+                    src = "https:" + src
+                if not src.startswith("http"):
+                    continue
+                if src in seen:
+                    continue
+                seen.add(src)
+                alt = (img.get("alt") or img.get("desc") or "").strip()
+                domain = urllib.parse.urlparse(src).hostname or ""
+                images.append({
+                    "title": alt or "Image",
+                    "url": src,
+                    "domain": domain,
+                    "content": alt or "Image",
+                })
+                if len(images) >= self._default_limit:
+                    break
+            if not images:
+                logger.warning(f"SearchService: no images parsed; media_count={len(result.media.get('images', []))}")
+            else:
+                logger.info(f"SearchService: parsed {len(images)} images via Crawl4AI media")
+            return images
+        except Exception as e:
+            logger.error(f"Crawl4AI image search failed: {e}")
+            return []

{entari_plugin_hyw-3.3.1.dist-info → entari_plugin_hyw-3.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: entari_plugin_hyw
-Version: 3.3.1
+Version: 3.3.2
 Summary: Use large language models to interpret chat messages
 Author-email: kumoSleeping <zjr2992@outlook.com>
 License: MIT
@@ -19,9 +19,9 @@ Description-Content-Type: text/markdown
 Requires-Dist: arclet-entari[full]>=0.16.5
 Requires-Dist: openai
 Requires-Dist: httpx
-Provides-Extra: playwright
-Requires-Dist: playwright>=1.56.0; extra == "playwright"
-Requires-Dist: trafilatura>=2.0.0; extra == "playwright"
+Requires-Dist: markdown>=3.10
+Requires-Dist: crawl4ai>=0.7.8
+Requires-Dist: jinja2>=3.0
 Provides-Extra: dev
 Requires-Dist: entari-plugin-server>=0.5.0; extra == "dev"
 Requires-Dist: satori-python-adapter-onebot11>=0.2.5; extra == "dev"
@@ -38,6 +38,10 @@ Requires-Dist: satori-python-adapter-onebot11>=0.2.5; extra == "dev"
 
 </div>
 
+# v3.3 迎来大幅度改动、现在图文不符
+
+
+
 ## 🎑 效果展示
 
 
@@ -47,12 +51,9 @@ Requires-Dist: satori-python-adapter-onebot11>=0.2.5; extra == "dev"
 </div>
 
 ## ✨ 功能特性
-- **关于搜索**：
-  - 如果不设置 jina token, 模型会根据提示词优先使用 jina / playwright(成功率较低) 获取渲染 bing / google 混合搜索结果。
-  - 存在 jina token 时，模型会获得一个 web search 工具，~~但我没试过我喜欢白嫖~~。
-  - 也可以 OpenRouter 的 `:online` 参数，该参数会优先使用模型提供商的搜索、其次 `exa`(较贵) 进行网页搜索。
-- 给予 `Alconna` 与 `MessageChain` 混合处理, 深度优化触发体验`。
-- **网页获取**：支持通过 **Jina AI** 或 **Playwright** 进行实时页面获取。
+- **关于搜索**：一次性触发 Bing 网页与图片搜索，组合结果后再回应。
+- 给予 `Alconna` 与 `MessageChain` 混合处理, 深度优化触发体验。
+- **网页获取**：使用 Playwright 进行实时页面获取。
 - **多模态理解**：支持图片视觉分析。
 - **上下文感知**：维护对话历史记录，支持连续的多轮对话。
 - `reaction` 表情, 表示任务开始。
@@ -67,12 +68,8 @@ Requires-Dist: satori-python-adapter-onebot11>=0.2.5; extra == "dev"
 pip install entari-plugin-hyw
 ```
 
-### 启用 Playwright 支持
-如果你希望使用 Playwright 进行本地网页渲染（而非仅使用 Jina AI）：
-```bash
-pip install entari-plugin-hyw[playwright]
-playwright install chromium
-```
+### 搜索
+默认通过 HTTP 请求搜索引擎（DuckDuckGo，可在配置中自定义完整搜索链接，如 `https://duckduckgo.com/?q={query}`）。
 
 ## ⚙️ 配置
 
@@ -86,7 +83,6 @@ plugins:
     command_name_list: ["zssm", "hyw"]
     
     # 主 LLM 模型配置（必需）, 如 x-ai/grok-4.1-fast:online、perplexity/sonar
-    # 如果模型不自带搜索 模型会根据提示词优先使用 jina / playwright(成功率较低) 获取渲染 bing / google 混合搜索结果
     model_name: "gx-ai/grok-4.1-fast:free"
     api_key: "your-api-key"
 
@@ -94,19 +90,8 @@ plugins:
     base_url: "openai-compatible-url"  
     
     # --- 浏览器与搜索 ---
-    # 网页浏览工具: "jina" (默认) 或 "playwright"
-    browser_tool: "jina"
-    
-    # 可选: Jina AI API Key (配置以获得更高限额)(免费方案20/min)
-    # 配置此项同时会启用 web search 工具
-    jina_api_key: "jina_..."
-    
-    # Playwright 设置
     headless: true
     
-    # 浏览器回退: 当首选 browser_tool 失败时，尝试使用备用 browser_tool (默认: false)
-    enable_browser_fallback: false
-    
     # --- 视觉配置 (可选) ---
     # 如果未设置，将回退使用主模型
     vision_model_name: "qwen-vl-plus"
@@ -118,6 +103,10 @@ plugins:
       reasoning:
         effort: low
     
+    # --- 交互体验 ---
+    # 是否开启表情反应 (默认: true)
+    reaction: true
+
     # --- 调试 ---
     save_conversation: false
 ```
@@ -148,3 +137,6 @@ hyw -t 一大段话。
 ### 引用回复
 支持引用消息进行追问，机器人会自动读取被引用的消息作为上下文：
 - **引用 + 命令**：机器人将理解被引用消息的内容（包括图片）通过 `MessageChain` 操作拼接 `Text`、`Image` 与部分 `Custom`。
+
+UncleCode. (2024). Crawl4AI: Open-source LLM Friendly Web Crawler & Scraper [Computer software]. 
+GitHub. https://github.com/unclecode/crawl4ai