entari-plugin-hyw 0.3.5__py3-none-any.whl → 4.0.0rc14__py3-none-any.whl

entari_plugin_hyw/__init__.py

@@ -1,142 +1,1005 @@
-from dataclasses import dataclass
-import html
-from typing import List, Text, Union
-from typing_extensions import override
-from arclet.entari import metadata
-from arclet.entari import MessageChain, Session
-from arclet.entari.event.base import MessageEvent
-from loguru import logger
-from satori.exception import ActionFailed
-from arclet.entari import MessageChain, At, Image, Quote, Text
-from satori import Element
-import arclet.letoderea as leto
-from arclet.entari import MessageCreatedEvent, Session
-from arclet.entari import BasicConfModel, metadata, plugin_config
-import httpx
+"""
+entari-plugin-hyw - Entari Plugin for HYW
+
+Use large language models to interpret chat messages.
+"""
+
+from dataclasses import dataclass, field
+from importlib.metadata import version as get_version
+from typing import List, Dict, Any, Optional
 import asyncio
-import json
+import os
+import base64
 import re
-from arclet.alconna import (
-    Args,
-    Alconna,
-    AllParam,
-    MultiVar,
-    CommandMeta,
-)
-from arclet.entari import MessageChain, Session, command
-from satori.element import Custom, E
+import tempfile
 
-# 导入AI服务模块
-from .agent import  AgentService, HywConfig
+from arclet.alconna import Alconna, Args, AllParam, Arparma
+from arclet.entari import metadata, listen, Session, plugin_config, BasicConfModel, command
+from arclet.entari import MessageChain, Text, Image, MessageCreatedEvent, Quote, At
+from satori.element import Custom
+from loguru import logger
+from arclet.entari.event.command import CommandReceive
+from arclet.entari.event.lifespan import Cleanup
 
+# Import from internal hyw_core
+from hyw_core import HywCore, HywCoreConfig, QueryRequest
+from hyw_core.browser_control import (
+    ContentRenderer,
+    get_content_renderer,
+    set_global_renderer,
+    close_screenshot_service,
+)
+from hyw_core.browser_control.manager import close_shared_browser
 
-metadata(
-    name="hyw",
-    author=[{"name": "kumoSleeping", "email": "zjr2992@outlook.com"}],
-    version="0.1.0",
-    description="",
-    config=HywConfig,
+# Local modules
+from .history import HistoryManager
+from .misc import (
+    process_onebot_json, 
+    process_images, 
+    resolve_model_name, 
+    render_refuse_answer, 
+    render_image_unsupported,
+    parse_color,
+    RecentEventDeduper,
 )
+from .filters import parse_filter_syntax
+from .search_cache import SearchResultCache, parse_single_index, parse_multi_indices
+
+
+try:
+    __version__ = get_version("entari_plugin_hyw")
+except Exception:
+    __version__ = "4.0.0-rc8"
+
+
+_event_deduper = RecentEventDeduper()
+
+
+
+@dataclass
+class HywConfig(BasicConfModel):
+    """Plugin configuration"""
+    admins: List[str] = field(default_factory=list)
+    models: List[Dict[str, Any]] = field(default_factory=list)
+    question_command: str = "/q"
+    web_command: str = "/w"
+    help_command: str = "/h"
+    language: str = "Simplified Chinese"
+    temperature: float = 0.4
+    
+    model_name: Optional[str] = None
+    api_key: Optional[str] = None
+    base_url: str = "https://openrouter.ai/api/v1"
+    
+    search_engine: str = "duckduckgo"
+    
+    headless: bool = False
+    save_conversation: bool = False
+    reaction: bool = False
+    quote: bool = False
+    theme_color: str = "#ff0000"
+
+    # Main model configuration (used for summary/main LLM calls)
+    main: Optional[Dict[str, Any]] = None
+    
+    def __post_init__(self):
+        self.theme_color = parse_color(self.theme_color)
+    
+    def to_hyw_core_config(self) -> HywCoreConfig:
+        main_cfg = self.main or {}
+        
+        return HywCoreConfig.from_dict({
+            "models": self.models,
+            "model_name": self.model_name or "",
+            "api_key": self.api_key or "",
+            "base_url": self.base_url,
+            "temperature": self.temperature,
+            "search_engine": self.search_engine,
+            "headless": self.headless,
+            "language": self.language,
+            "theme_color": self.theme_color,
+            
+            # Map nested 'main' config to summary stage
+            "summary_model": main_cfg.get("model_name"),
+            "summary_api_key": main_cfg.get("api_key"),
+            "summary_base_url": main_cfg.get("base_url"),
+            "summary_extra_body": main_cfg.get("extra_body"),
+        })
+
 
 conf = plugin_config(HywConfig)
-agent_service = AgentService(conf)
-command_name_list = [conf.hyw_command_name] if isinstance(conf.hyw_command_name, str) else conf.hyw_command_name
-alc = Alconna(command_name_list, Args["all_param;?", AllParam], meta=CommandMeta(compact=True,))
-
-
-# Emoji到代码的映射字典
-EMOJI_TO_CODE = {
-    "🐳": "128051",
-    "❌": "10060",
-    "🍧": "127847",
-    "✨": "10024",
-    "📫": "128235"
-}
-
-async def download_image(url: str) -> bytes:
-    """下载图片"""
+history_manager = HistoryManager()
+renderer = ContentRenderer(headless=conf.headless)
+set_global_renderer(renderer)
+search_cache = SearchResultCache(ttl_seconds=600.0)  # 10 minutes
+
+# Initialize HywCore immediately at plugin load time (not lazy)
+# This avoids the 2s delay on first user request caused by AsyncOpenAI client creation
+_hyw_core: HywCore = HywCore(conf.to_hyw_core_config())
+
+def get_hyw_core() -> HywCore:
+    return _hyw_core
+
+
+@listen(Cleanup)
+async def cleanup_screenshot_service():
+    global _hyw_core
     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}")
+        if _hyw_core:
+            await _hyw_core.close()
+            _hyw_core = None
+        await close_screenshot_service()
+        close_shared_browser()
     except Exception as e:
-        raise ActionFailed(f"下载图片失败: {url}, 错误: {str(e)}")
+        logger.warning(f"Failed to cleanup: {e}")
 
 
-def process_onebot_json(json_data_str: str) -> str:
+async def react(session: Session, emoji: str):
+    if not conf.reaction: return
     try:
-        # 解码HTML实体
-        json_str = html.unescape(json_data_str)
-        return json_str
+        await session.reaction_create(emoji=emoji)
     except Exception as e:
-        return json_data_str
+        logger.warning(f"Reaction failed: {e}")
 
 
-@leto.on(MessageCreatedEvent)
-async def on_message_created(message_chain: MessageChain, session: Session[MessageEvent]):
-    async def react(emoji: str):
+async def process_request(
+    session: Session[MessageCreatedEvent],
+    all_param: Optional[MessageChain] = None,
+    selected_model: Optional[str] = None,
+) -> None:
+    mc = MessageChain(all_param)
+    if session.reply:
         try:
-            if session.event.login.platform == "onebot":
-                code = EMOJI_TO_CODE.get(emoji, "10024") 
-                await session.account.protocol.call_api("internal/set_group_reaction", {"group_id": int(session.guild.id), "message_id": int(session.event.message.id), "code": code, "is_add": True})
-            else:
-                await session.reaction_create(emoji=emoji)
-        except ActionFailed:
-            pass
+            reply_msg_id = str(session.reply.origin.id) if hasattr(session.reply.origin, 'id') else None
+            if not (reply_msg_id and history_manager.is_bot_message(reply_msg_id)):
+                mc.extend(MessageChain(" ") + session.reply.origin.message)
+        except Exception:
+            mc.extend(MessageChain(" ") + session.reply.origin.message)
+    
+    filtered = mc.get(Text) + mc.get(Image) + mc.get(Custom)
+    mc = MessageChain(filtered)
+    
+    text_content = str(mc.get(Text)).strip()
+    text_content = re.sub(r'<img[^>]+>', '', text_content, flags=re.IGNORECASE)
+    
+    if not text_content and not mc.get(Image) and not mc.get(Custom):
+        return
 
-    if session.reply:
+    hist_key = None
+    if session.reply and hasattr(session.reply.origin, 'id'):
+        hist_key = history_manager.get_conversation_id(str(session.reply.origin.id))
+    
+    hist_payload = history_manager.get_history(hist_key) if hist_key else []
+    context_id = f"guild_{session.guild.id}" if session.guild else f"user_{session.user.id}"
+
+    if conf.reaction: await react(session, "✨")
+
+    try:
+        msg_text = str(mc.get(Text)).strip() if mc.get(Text) else ""
+        msg_text = re.sub(r'<img[^>]+>', '', msg_text, flags=re.IGNORECASE)
+        
+        if not msg_text and (mc.get(Image) or mc.get(Custom)):
+            msg_text = "[图片]"
+        
+        for custom in [e for e in mc if isinstance(e, Custom)]:
+            if custom.tag == 'onebot:json':
+                if decoded := process_onebot_json(custom.attributes()): 
+                    msg_text += f"\n{decoded}"
+                break
+        
+        model = selected_model
+        if model:
+            resolved, _ = resolve_model_name(model, conf.models)
+            if resolved:
+                model = resolved
+
+        images, _ = await process_images(mc, None)
+        
+        # Prepare renderer
+        local_renderer = await get_content_renderer()
+        render_tab_task = asyncio.create_task(local_renderer.prepare_tab())
+
+        async def send_noti(msg: str):
+            try:
+                if conf.quote:
+                    await session.send([Quote(session.event.message.id), msg])
+                else:
+                    await session.send(msg)
+            except Exception as e:
+                logger.warning(f"Failed to send notification: {e}")
+
+        request = QueryRequest(
+            user_input=msg_text,
+            images=images,
+            conversation_history=hist_payload,
+            model_name=model,
+            send_notification=send_noti
+        )
+        
+        with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tf:
+            output_path = tf.name
+        
+        core = get_hyw_core()
+        # Use agent mode with tool-calling capability
+        # Agent can autonomously call web_tool up to 2 times, with IM notifications
+        response = await core.query_agent(request, output_path=None)
+        
+        # 2. Get the warmed-up tab
         try:
-            message_chain.extend(session.reply.origin.message)
+            tab_id = await render_tab_task
         except Exception:
-            pass
-    message_chain = message_chain.get(Text) + message_chain.get(Image) + message_chain.get(Custom)
-    res = alc.parse(message_chain)
-    if not res.matched:
-        # logger.info(res.error_info)
+            tab_id = None
+        
+        display_session_id = history_manager.generate_short_code()
+
+        if response.should_refuse:
+            render_ok = await render_refuse_answer(
+                renderer=local_renderer,
+                output_path=output_path,
+                reason=response.refuse_reason or 'Refused',
+                theme_color=conf.theme_color,
+                tab_id=tab_id,
+            )
+        elif not response.success:
+            await session.send(f"Error: {response.error}")
+            return
+        else:
+            # 3. Explicit External Render using the Parallel Tab
+            render_ok = await core.render(
+                markdown_content=response.content,
+                output_path=output_path,
+                stats={"total_time": response.total_time},
+                references=response.references,
+                page_references=response.page_references,
+                image_references=response.image_references,
+                stages_used=response.stages_used,
+                tab_id=tab_id
+            )
+            if render_ok:
+                response.image_path = output_path
+        
+        if render_ok:
+            with open(output_path, "rb") as f:
+                img_data = base64.b64encode(f.read()).decode()
+            
+            msg_chain = MessageChain(Image(src=f'data:image/png;base64,{img_data}'))
+            if conf.quote:
+                msg_chain = MessageChain(Quote(session.event.message.id)) + msg_chain
+            
+            sent = await session.send(msg_chain)
+            
+            sent_id = next((str(e.id) for e in sent if hasattr(e, 'id')), None) if sent else None
+            msg_id = str(session.event.message.id) if hasattr(session.event, 'message') else str(session.event.id)
+            
+            updated_history = hist_payload + [
+                {"role": "user", "content": msg_text},
+                {"role": "assistant", "content": response.content}
+            ]
+            
+            # Save to Memory
+            history_manager.remember(
+                sent_id, updated_history, [msg_id],
+                {"model": model}, context_id, code=display_session_id,
+            )
+            
+            # Save to Disk (Debug/Logging)
+            if conf.save_conversation:
+                # Extract traces from response
+                trace = response.stages_trace
+                instruct_traces = trace.get("instruct_rounds") if trace else None
+                
+                # Check for web_results in response (needs Core update)
+                web_results = getattr(response, "web_results", [])
+                
+                history_manager.save_to_disk(
+                    key=sent_id, 
+                    image_path=output_path,
+                    web_results=web_results,
+                    instruct_traces=instruct_traces,
+                    vision_trace=None # Vision integrated into Instruct now
+                )
+        
+        if os.path.exists(output_path):
+            os.remove(output_path)
+
+    except Exception as e:
+        logger.exception(f"Error: {e}")
+        await session.send(f"Error: {e}")
+
+
+
+alc = Alconna(conf.question_command, Args["all_param;?", AllParam])
+
+@command.on(alc)    
+async def handle_question_command(session: Session[MessageCreatedEvent], result: Arparma):
+    try:
+        mid = str(session.event.message.id) if getattr(session.event, "message", None) else str(session.event.id)
+        dedupe_key = f"{getattr(session.account, 'id', 'account')}:{mid}"
+        if _event_deduper.seen_recently(dedupe_key):
+            return
+    except Exception:
+        pass
+    
+    args = result.all_matched_args
+    all_param = args.get("all_param")
+    
+    # Extract query text
+    if all_param:
+        if isinstance(all_param, MessageChain):
+            query_text = str(all_param.get(Text)).strip()
+        else:
+            query_text = str(all_param).strip()
+    else:
+        query_text = ""
+    
+    # Check if replying to a cached search result
+    reply_msg_id = None
+    if session.reply and hasattr(session.reply.origin, 'id'):
+        reply_msg_id = str(session.reply.origin.id)
+    
+    # Quote mode: Use cached search results
+    if reply_msg_id:
+        cached = search_cache.get(reply_msg_id)
+        if cached:
+            # Parse indices if provided
+            indices = parse_multi_indices(query_text, max_count=3) if query_text else None
+            
+            # Check if too many indices requested (parse_multi_indices returns None if > max_count)
+            if query_text and indices is None:
+                # Check if it looks like indices but exceeded limit
+                if re.match(r'^[\d,、\s\-–]+$', query_text):
+                    await session.send("最多选择3个结果进行总结")
+                    search_cache.cleanup()
+                    return
+            
+            if conf.reaction:
+                asyncio.create_task(react(session, "✨"))
+            
+            core = get_hyw_core()
+            local_renderer = await get_content_renderer()
+            tab_task = asyncio.create_task(local_renderer.prepare_tab())
+            
+            # Collect screenshots for selected pages
+            screenshots = []
+            if indices:
+                # Screenshot mode: capture pages for selected indices
+                for idx in indices:
+                    if idx < len(cached.results):
+                        url = cached.results[idx].get("url", "")
+                        if url:
+                            b64_img = await core.screenshot(url)
+                            if b64_img:
+                                screenshots.append(b64_img)
+                
+                if not screenshots:
+                    try: await tab_task
+                    except: pass
+                    await session.send("无法截图所选页面")
+                    search_cache.cleanup()
+                    return
+                
+                user_query = f"总结关于 \"{cached.query}\" 的内容"
+            else:
+                # No indices - summarize based on cached snippets (no screenshots)
+                context_parts = []
+                for i, res in enumerate(cached.results[:10]):
+                    title = res.get("title", f"Result {i+1}")
+                    snippet = res.get("content", "") or res.get("snippet", "")
+                    context_parts.append(f"## {title}\n{snippet}")
+                
+                context_message = f"基于搜索 \"{cached.query}\" 的结果摘要回答用户问题:\n\n" + "\n\n".join(context_parts)
+                user_query = query_text if query_text else f"总结关于 \"{cached.query}\" 的搜索结果"
+            
+            # Build request with screenshots (if any)
+            if screenshots:
+                request = QueryRequest(
+                    user_input=user_query,
+                    images=screenshots,
+                    conversation_history=[],
+                    model_name=None,
+                )
+            else:
+                request = QueryRequest(
+                    user_input=f"{context_message}\n\n用户问题: {user_query}",
+                    images=[],
+                    conversation_history=[],
+                    model_name=None,
+                )
+            
+            with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tf:
+                output_path = tf.name
+            
+            response = await core.query(request, output_path=None)
+            
+            try:
+                tab_id = await tab_task
+            except Exception:
+                tab_id = None
+            
+            if response.success and response.content:
+                render_ok = await core.render(
+                    markdown_content=response.content,
+                    output_path=output_path,
+                    stats={"total_time": response.total_time},
+                    references=[],
+                    page_references=[],
+                    tab_id=tab_id
+                )
+                
+                if render_ok and os.path.exists(output_path):
+                    with open(output_path, "rb") as f:
+                        img_data = base64.b64encode(f.read()).decode()
+                    
+                    msg_chain = MessageChain(Image(src=f'data:image/png;base64,{img_data}'))
+                    if conf.quote:
+                        msg_chain = MessageChain(Quote(session.event.message.id)) + msg_chain
+                    
+                    await session.send(msg_chain)
+                    os.remove(output_path)
+                else:
+                    await session.send(response.content[:500])
+            else:
+                await session.send(f"总结失败: {response.error or 'Unknown error'}")
+            
+            search_cache.cleanup()
+            return
+    
+    # === URL Mode: Direct URL Screenshot + Summarize ===
+    # Detect URL in query and handle directly without Agent
+    url_match = re.search(r'https?://\S+', query_text)
+    if url_match:
+        url = url_match.group(0)
+        # Extract user intent (text before/after URL)
+        user_intent = query_text.replace(url, '').strip()
+        if not user_intent:
+            user_intent = "总结这个页面的内容"
+        
+        if conf.reaction:
+            asyncio.create_task(react(session, "✨"))
+        
+        core = get_hyw_core()
+        local_renderer = await get_content_renderer()
+        
+        # Run screenshot and prepare tab in parallel
+        screenshot_task = asyncio.create_task(core.screenshot(url))
+        tab_task = asyncio.create_task(local_renderer.prepare_tab())
+        
+        # Send notification
+        short_url = url[:40] + "..." if len(url) > 40 else url
+        await session.send(f"📸 正在截图: {short_url}")
+        
+        b64_img = await screenshot_task
+        
+        if not b64_img:
+            try: await tab_task
+            except: pass
+            await session.send(f"❌ 截图失败: {url}")
+            return
+        
+        # Summarize with screenshot
+        request = QueryRequest(
+            user_input=f"{user_intent}\n\nURL: {url}",
+            images=[b64_img],
+            conversation_history=[],
+            model_name=None,
+        )
+        
+        with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tf:
+            output_path = tf.name
+        
+        response = await core.query(request, output_path=None)
+        
+        try:
+            tab_id = await tab_task
+        except Exception:
+            tab_id = None
+        
+        if response.success and response.content:
+            render_ok = await core.render(
+                markdown_content=response.content,
+                output_path=output_path,
+                stats={"total_time": response.total_time},
+                references=[],
+                page_references=[{"url": url, "title": "截图页面", "raw_screenshot_b64": b64_img}],
+                tab_id=tab_id
+            )
+            
+            if render_ok and os.path.exists(output_path):
+                with open(output_path, "rb") as f:
+                    img_data = base64.b64encode(f.read()).decode()
+                
+                msg_chain = MessageChain(Image(src=f'data:image/png;base64,{img_data}'))
+                if conf.quote:
+                    msg_chain = MessageChain(Quote(session.event.message.id)) + msg_chain
+                
+                await session.send(msg_chain)
+                os.remove(output_path)
+            else:
+                await session.send(response.content[:500])
+        else:
+            await session.send(f"总结失败: {response.error or 'Unknown error'}")
+        
+        return
+    
+    # === Filter Mode: Search + Find matching links + Summarize ===
+    # Only trigger filter syntax for short queries (≤20 chars, excluding URLs), otherwise use Agent
+    filters = []
+    filter_error = None
+    # Calculate length excluding URLs
+    query_without_urls = re.sub(r'https?://\S+', '', query_text).strip()
+    if len(query_without_urls) <= 20:
+        filters, search_query, filter_error = parse_filter_syntax(query_text, max_count=3)
+    
+    if filter_error:
+        await session.send(filter_error)
+        return
+    
+    if filters:
+        if conf.reaction:
+            asyncio.create_task(react(session, "✨"))
+        
+        core = get_hyw_core()
+        local_renderer = await get_content_renderer()
+        
+        # Send pre-notification BEFORE search
+        filter_desc = ", ".join([f[1] if f[0] != 'index' else f"第{f[1]}个" for f in filters])
+        await session.send(f"🔍 正在搜索 \"{search_query}\" 并匹配 [{filter_desc}]...")
+        
+        # Run search and prepare tab in parallel
+        search_task = asyncio.create_task(core.search([search_query]))
+        tab_task = asyncio.create_task(local_renderer.prepare_tab())
+        
+        results = await search_task
+        flat_results = results[0] if results else []
+        
+        if not flat_results:
+            try: await tab_task
+            except: pass
+            await session.send("Search returned no results.")
+            return
+        
+        visible = [r for r in flat_results if not r.get("_hidden", False)]
+        
+        # Collect URLs to screenshot
+        urls_to_screenshot = []
+        for filter_type, filter_value, count in filters:
+            if filter_type == 'index':
+                idx = filter_value - 1
+                if 0 <= idx < len(visible):
+                    url = visible[idx].get("url", "")
+                    if url and url not in urls_to_screenshot:
+                        urls_to_screenshot.append(url)
+                else:
+                    try: await tab_task
+                    except: pass
+                    await session.send(f"⚠️ 序号 {filter_value} 超出范围 (1-{len(visible)})")
+                    return
+            else:
+                found_count = 0
+                for res in visible:
+                    url = res.get("url", "")
+                    title = res.get("title", "")
+                    # Match filter against both URL and title
+                    if (filter_value in url.lower() or filter_value in title.lower()) and url not in urls_to_screenshot:
+                        urls_to_screenshot.append(url)
+                        found_count += 1
+                        if found_count >= count:
+                            break
+                
+                if found_count == 0:
+                    try: await tab_task
+                    except: pass
+                    await session.send(f"⚠️ 未找到包含 \"{filter_value}\" 的链接")
+                    return
+        
+        if not urls_to_screenshot:
+            try: await tab_task
+            except: pass
+            await session.send("⚠️ 未找到匹配的链接")
+            return
+        
+        # Take screenshots with content extraction
+        screenshot_tasks = [core.screenshot_with_content(url) for url in urls_to_screenshot]
+        screenshot_results = await asyncio.gather(*screenshot_tasks)
+        
+        # Build page references for rendering (with screenshots)
+        # and collect text content for LLM
+        page_references = []
+        text_contents = []
+        successful_count = 0
+        
+        for url, result in zip(urls_to_screenshot, screenshot_results):
+            if isinstance(result, dict) and result.get("screenshot_b64"):
+                successful_count += 1
+                page_references.append({
+                    "url": url,
+                    "title": result.get("title", "截图页面"),
+                    "raw_screenshot_b64": result.get("screenshot_b64"),
+                })
+                # Collect text for LLM
+                content = result.get("content", "")
+                if content:
+                    text_contents.append(f"## 来源: {result.get('title', url)}\n\n{content}")
+        
+        if not page_references:
+            try: await tab_task
+            except: pass
+            await session.send("无法截图页面")
+            return
+        
+        # Send result notification
+        await session.send(f"🔍 搜索 \"{search_query}\" 并截图 {successful_count} 个匹配结果")
+        
+        # Pass TEXT content to LLM for summarization (not images)
+        combined_content = "\n\n---\n\n".join(text_contents) if text_contents else "无法提取网页内容"
+        user_query = f"总结关于 \"{search_query}\" 的内容。\n\n网页内容:\n{combined_content[:8000]}"
+        
+        request = QueryRequest(
+            user_input=user_query,
+            images=[],  # No images, use text content instead
+            conversation_history=[],
+            model_name=None,
+        )
+        
+        with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tf:
+            output_path = tf.name
+        
+        response = await core.query(request, output_path=None)
+        
+        try:
+            tab_id = await tab_task
+        except Exception:
+            tab_id = None
+        
+        if response.success and response.content:
+            render_ok = await core.render(
+                markdown_content=response.content,
+                output_path=output_path,
+                stats={"total_time": response.total_time},
+                references=[],
+                page_references=page_references,  # Pass screenshots for rendering
+                tab_id=tab_id
+            )
+            
+            if render_ok and os.path.exists(output_path):
+                with open(output_path, "rb") as f:
+                    img_data = base64.b64encode(f.read()).decode()
+                
+                msg_chain = MessageChain(Image(src=f'data:image/png;base64,{img_data}'))
+                if conf.quote:
+                    msg_chain = MessageChain(Quote(session.event.message.id)) + msg_chain
+                
+                await session.send(msg_chain)
+                os.remove(output_path)
+            else:
+                await session.send(response.content[:500])
+        else:
+            await session.send(f"总结失败: {response.error or 'Unknown error'}")
+        
+        return
+    
+    # Normal query mode (no cache context)
+    await process_request(session, all_param)
+
+
+# Search/Web Command (/w)
+alc_search = Alconna(conf.web_command, Args["query;?", AllParam])
+
+@command.on(alc_search)
+async def handle_web_command(session: Session[MessageCreatedEvent], result: Arparma):
+    """
+    Handle web command /w:
+    - If query is index + Quote -> Screenshot cached result
+    - If query is URL -> Screenshot
+    - If query is text -> Search
+    """
+    query = result.all_matched_args.get("query")
+    
+    # Extract query text
+    if query:
+        if isinstance(query, MessageChain):
+            query = str(query.get(Text)).strip()
+        query = str(query).strip()
+    else:
+        query = ""
+    
+    # Check if replying to a cached search result
+    reply_msg_id = None
+    if session.reply and hasattr(session.reply.origin, 'id'):
+        reply_msg_id = str(session.reply.origin.id)
+    
+    # Quote + Index mode: Screenshot specific cached result
+    if reply_msg_id:
+        cached = search_cache.get(reply_msg_id)
+        if cached:
+            # Parse index from query
+            idx = parse_single_index(query)
+            if idx is None:
+                # No valid index - show prompt
+                await session.send("请指定序号 (1-10)")
+                search_cache.cleanup()  # Lazy cleanup
+                return
+            
+            if idx >= len(cached.results):
+                await session.send(f"序号超出范围 (1-{len(cached.results)})")
+                search_cache.cleanup()
+                return
+            
+            # Screenshot the cached URL
+            target_result = cached.results[idx]
+            target_url = target_result.get("url", "")
+            if not target_url:
+                await session.send("该结果无有效URL")
+                search_cache.cleanup()
+                return
+            
+            if conf.reaction:
+                asyncio.create_task(react(session, "📸"))
+            
+            core = get_hyw_core()
+            b64_img = await core.screenshot(target_url)
+            
+            if b64_img:
+                msg_chain = MessageChain(Image(src=f'data:image/jpeg;base64,{b64_img}'))
+                if conf.quote:
+                    msg_chain = MessageChain(Quote(session.event.message.id)) + msg_chain
+                await session.send(msg_chain)
+            else:
+                await session.send(f"截图失败: {target_url}")
+            
+            search_cache.cleanup()
+            return
+        else:
+            # Reply to a non-cached message: append reply content to query
+            try:
+                # session.reply.origin.message is a list, wrap it in MessageChain
+                reply_msg = MessageChain(session.reply.origin.message)
+                reply_content = str(reply_msg.get(Text)).strip()
+                if reply_content:
+                    query = f"{query} {reply_content}".strip() if query else reply_content
+                    logger.info(f"/w appended reply content, new query: '{query}'")
+            except Exception as e:
+                logger.warning(f"/w failed to extract reply content: {e}")
+    
+    # No query and no cache context - nothing to do
+    if not query:
         return
 
-    mc = MessageChain(res.all_param) # type: ignore
     try:
-        # 获取文本和图片
-        msg = mc.get(Text).strip() if mc.get(Text) else ""
-        logger.info(msg)
-        
-        # 检查是否有 onebot:json 元素（QQ小程序分享）
-        if mc.get(Custom):
-            custom_elements = [e for e in mc if isinstance(e, Custom)]
-            
-            # 删除 当前QQ版本不支持此应用，请升级 这句话
-            for i in msg:
-                i = str(i).replace("当前QQ版本不支持此应用，请升级", "")
-                logger.info("删除不支持应用提示")
+        core = get_hyw_core()
+        
+        # 1. URL Detection
+        url_pattern = re.compile(r'^https?://(?:[-\w./?=&%#]+)')
+        if url_pattern.match(query):
+            # === URL Screenshot Mode ===
+            if conf.reaction: asyncio.create_task(react(session, "📸"))
+            
+            with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tf:
+                output_path = tf.name
+
+            b64_img = await core.screenshot(query)
+            
+            if b64_img:
+                with open(output_path, "wb") as f:
+                    f.write(base64.b64decode(b64_img))
+                    
+                msg_chain = MessageChain(Image(src=f'data:image/jpeg;base64,{b64_img}'))
+                if conf.quote:
+                    msg_chain = MessageChain(Quote(session.event.message.id)) + msg_chain
                 
-            for custom in custom_elements:
-                if custom.tag == 'onebot:json':
-                    # await react("📫")
-                    decoded_json = process_onebot_json(custom.attributes())
-                    msg += decoded_json
-                    # 这里假设都是小程序分享，直接返回第一个(只有可能是一个)
-                    break
-        images = None
-        if mc.get(Image):
-            urls = mc[Image].map(lambda x: x.src)
-            tasks = [download_image(url) for url in urls]
-            images = await asyncio.gather(*tasks)
-            await react("🍧")
-        await react("✨")
-        # 调用AI服务
-        res_agent = await agent_service.unified_completion(str(msg), images)
-        # await react("🐳")
-        # 发送回复
-        response_content = str(res_agent.content) if hasattr(res_agent, 'content') else ""
-        if not response_content.strip():
-            response_content = "[KEY] :: 信息处理 | 内容获取\n>> [search enable]\n抱歉，获取到的内容可能包含敏感信息，暂时无法显示完整结果。\n[LLM] :: 安全过滤"
-        await session.send([Quote(session.event.message.id), response_content])
+                await session.send(msg_chain)
+                
+                if conf.save_conversation:
+                    mid = str(session.event.message.id) if getattr(session.event, "message", None) else str(session.event.id)
+                    context_id = f"guild_{session.guild.id}" if session.guild else "user"
+                    history_manager.remember(mid, [{"role": "user", "content": f"/w {query}"}], [], {}, context_id=context_id)
+                    history_manager.save_to_disk(mid, image_path=output_path, web_results=[{"url": query, "title": "Screenshot", "_type": "screenshot"}])
+
+                os.remove(output_path)
+            else:
+                await session.send(f"Failed to screenshot URL: {query}")
+            return
+
+        # 2. Search Mode (Fallthrough)
+        
+        # Parse enhanced filter syntax
+        filters, search_query, filter_error = parse_filter_syntax(query, max_count=3)
+        
+        if filter_error:
+            await session.send(filter_error)
+            return
+        
+        # Start search first
+        local_renderer = await get_content_renderer()
+        search_task = asyncio.create_task(core.search([search_query]))
+        
+        # Only pre-warm tab if NOT in filter mode (filter mode = screenshots only, no card render)
+        tab_task = None
+        if not filters:
+            tab_task = asyncio.create_task(local_renderer.prepare_tab())
+        
+        if conf.reaction: 
+            asyncio.create_task(react(session, "🔍"))
+        
+        results = await search_task
+        flat_results = results[0] if results else []
+        
+        if not flat_results:
+            if tab_task:
+                try: await tab_task
+                except: pass
+            await session.send("Search returned no results.")
+            return
+
+        visible = [r for r in flat_results if not r.get("_hidden", False)]
+        
+        if not visible:
+            if tab_task:
+                try: await tab_task
+                except: pass
+            await session.send("Search returned no visible results.")
+            return
+        
+        # === Filter Mode: Screenshot matching links (NO tab needed) ===
+        if filters:
+            
+            urls_to_screenshot = []
+            
+            for filter_type, filter_value, count in filters:
+                if filter_type == 'index':
+                    # Index-based (1-based)
+                    idx = filter_value - 1
+                    if 0 <= idx < len(visible):
+                        url = visible[idx].get("url", "")
+                        if url and url not in urls_to_screenshot:
+                            urls_to_screenshot.append(url)
+                    else:
+                        await session.send(f"⚠️ 序号 {filter_value} 超出范围 (1-{len(visible)})")
+                        return
+                else:
+                    # Link filter: find URLs containing filter term
+                    found_count = 0
+                    for res in visible:
+                        url = res.get("url", "")
+                        title = res.get("title", "")
+                        # Match filter against both URL and title
+                        if (filter_value in url.lower() or filter_value in title.lower()) and url not in urls_to_screenshot:
+                            urls_to_screenshot.append(url)
+                            found_count += 1
+                            if found_count >= count:
+                                break
+                    
+                    if found_count == 0:
+                        await session.send(f"⚠️ 未找到包含 \"{filter_value}\" 的链接")
+                        return
+            
+            if not urls_to_screenshot:
+                await session.send("⚠️ 未找到匹配的链接")
+                return
+            
+            if conf.reaction:
+                asyncio.create_task(react(session, "📸"))
+            
+            # Take screenshots concurrently
+            screenshot_tasks = [core.screenshot(url) for url in urls_to_screenshot]
+            screenshot_results = await asyncio.gather(*screenshot_tasks)
+            
+            images = [Image(src=f'data:image/jpeg;base64,{b64}') for b64 in screenshot_results if b64]
+            
+            if images:
+                msg_chain = MessageChain(images)
+                if conf.quote:
+                    msg_chain = MessageChain(Quote(session.event.message.id)) + msg_chain
+                await session.send(msg_chain)
+                
+                if conf.save_conversation:
+                    mid = str(session.event.message.id) if getattr(session.event, "message", None) else str(session.event.id)
+                    context_id = f"guild_{session.guild.id}" if session.guild else "user"
+                    history_manager.remember(mid, [{"role": "user", "content": f"/w {query}"}], [], {}, context_id=context_id)
+            else:
+                await session.send("截图失败")
+            return
+             
+        # === Normal Search Mode: Render search results as Sources card ===
+        
+        # Build references from search results for Sources card
+        references = []
+        for i, res in enumerate(visible[:10]):
+            references.append({
+                "title": res.get("title", f"Result {i+1}"),
+                "url": res.get("url", ""),
+                "snippet": res.get("content", "") or res.get("snippet", ""),
+                "original_idx": i + 1,
+            })
+        
+        try:
+            tab_id = await tab_task
+        except Exception:
+            tab_id = None
+        
+        with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tf:
+            output_path = tf.name
+        
+        # Render Sources card with search results (no markdown content, just references)
+        render_ok = await core.render(
+            markdown_content=f"# 搜索结果: {search_query}",
+            output_path=output_path,
+            stats={"total_time": 0},
+            references=references,
+            page_references=[],
+            stages_used=[{"name": "search", "description": f"搜索 \"{search_query}\"", "time": 0}],
+            tab_id=tab_id
+        )
+        
+        if render_ok and os.path.exists(output_path):
+            with open(output_path, "rb") as f:
+                img_data = base64.b64encode(f.read()).decode()
+            
+            msg_chain = MessageChain(Image(src=f'data:image/png;base64,{img_data}'))
+            if conf.quote:
+                msg_chain = MessageChain(Quote(session.event.message.id)) + msg_chain
+            
+            sent = await session.send(msg_chain)
+            
+            # Store in cache for future /w and /q lookups
+            sent_id = next((str(e.id) for e in sent if hasattr(e, 'id')), None) if sent else None
+            if sent_id:
+                search_cache.store(sent_id, visible[:10], search_query)
+            
+            if conf.save_conversation:
+                mid = str(session.event.message.id) if getattr(session.event, "message", None) else str(session.event.id)
+                context_id = f"guild_{session.guild.id}" if session.guild else "user"
+                history_manager.remember(mid, [{"role": "user", "content": f"/w {query}"}], [], {}, context_id=context_id)
+            
+            os.remove(output_path)
+        else:
+            await session.send("渲染搜索结果失败")
+        
+        search_cache.cleanup()  # Lazy cleanup
+
     except Exception as e:
-        await react("❌")
-        raise e
+        logger.error(f"Search command failed: {e}")
+        await session.send(f"Search error: {e}")
+
+
+metadata("hyw", author=[{"name": "kumoSleeping", "email": "zjr2992@outlook.com"}], version=__version__, config=HywConfig)
+
+# Help command (/h)
+alc_help = Alconna(conf.help_command)
+
+@command.on(alc_help)
+async def handle_help_command(session: Session[MessageCreatedEvent], result: Arparma):
+    """Display help information for all commands."""
+    help_text = f"""HYW Plugin v{__version__}
+
+Question Agent:
+  • {conf.question_command} tell me...
+  • {conf.question_command} [picture] tell me...
+  • [quote] {conf.question_command} tell me...
+Question Filter:
+  • {conf.question_command} github: fastapi
+  • {conf.question_command} 1,2: minecraft
+  • {conf.question_command} mcmod=2: forge mod
+Question Context:
+  • [quote: question] + {conf.question_command} tell me more...
+Web_tool Search:
+  • {conf.web_command} query
+Web_tool Screenshot:
+  • {conf.web_command} https://example.com
+Web_tool Filter(search and screenshot):
+  • {conf.web_command} github: fastapi
+  • {conf.web_command} 1,2: minecraft
+  • {conf.web_command} mcmod=2: forge mod
+Web_tool Context(screenshot):
+  • [quote: web_tool search] + {conf.web_command} 1
+  • [quote: web_tool search] + {conf.web_command} 1, 3
+Web_tool Context(question):
+  • [quote: web_tool screenshot] + {conf.question_command} tell me...
+  • [quote: web_tool search] + {conf.question_command} tell me...
+"""
+    
+    await session.send(help_text)
 
-    
+@listen(CommandReceive)
+async def remove_at(content: MessageChain):
+    return content.lstrip(At)