entari-plugin-hyw 4.0.0rc7__py3-none-any.whl → 4.0.0rc9__py3-none-any.whl

entari_plugin_hyw/__init__.py

@@ -1,62 +1,137 @@
+"""
+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, Union
+from typing import List, Dict, Any, Optional
 import time
 import asyncio
+import os
+import secrets
+import base64
+import re
+import tempfile
 
-# 从 pyproject.toml 读取版本号，避免重复维护
-try:
-    __version__ = get_version("entari_plugin_hyw")
-except Exception:
-    __version__ = "0.0.0"
-
-from arclet.alconna import Alconna, Args, AllParam, CommandMeta, Option, Arparma, MultiVar, store_true
-from arclet.entari import metadata, listen, Session, plugin_config, BasicConfModel, plugin, command
-from arclet.letoderea import on
+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
-import arclet.letoderea as leto
 from arclet.entari.event.command import CommandReceive
-
-from .modular_pipeline import ModularPipeline
-from .history import HistoryManager
-from .render_vue import ContentRenderer, get_content_renderer
-from .misc import process_onebot_json, process_images, resolve_model_name, render_refuse_answer, render_image_unsupported, REFUSE_ANSWER_MARKDOWN
 from arclet.entari.event.lifespan import Cleanup
 
-import os
-import secrets
-import base64
+# 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
 
-import re
+# Local modules
+from .history import HistoryManager
+from .misc import (
+    process_onebot_json, 
+    process_images, 
+    resolve_model_name, 
+    render_refuse_answer, 
+    render_image_unsupported,
+)
+from .search_cache import SearchResultCache, parse_single_index, parse_multi_indices
 
 
-def parse_color(color: str) -> str:
+def parse_filter_syntax(query: str, max_count: int = 3):
     """
-    Parse color from hex or RGB tuple to hex format.
-    Supports: #ff0000, ff0000, (255, 0, 0), 255,0,0
+    Parse enhanced filter syntax supporting:
+    - Chinese/English colons (: ：) and commas (, ，)
+    - Multiple filters: "mcmod=2, github=1 : xxx" 
+    - Index lists: "1, 2, 3 : xxx"
+    - Max total selections
+    
+    Returns:
+        (filters, search_query, error_msg)
+        filters: list of (filter_type, filter_value, count) tuples
+                 filter_type: 'index' or 'link'
+                 count: how many to get (default 1)
+        search_query: the actual search query
+        error_msg: error message if exceeded max
     """
+    if not query:
+        return [], query, None
+    
+    # Normalize Chinese punctuation to English
+    normalized = query.replace('：', ':').replace('，', ',').replace('、', ',')
+    
+    # Handle escaped colons: \: or /: -> placeholder
+    normalized = re.sub(r'[/\\]:', '\x00COLON\x00', normalized)
+    
+    # Split by colon - last part is the search query
+    parts = normalized.split(':')
+    if len(parts) < 2:
+        # No colon found, restore escaped colons and return as-is
+        return [], query.replace('\\:', ':').replace('/:', ':'), None
+    
+    # Everything after the last colon is the search query
+    search_query = parts[-1].strip().replace('\x00COLON\x00', ':')
+    
+    # Everything before is the filter specification
+    filter_spec = ':'.join(parts[:-1]).strip().replace('\x00COLON\x00', ':')
+    
+    if not filter_spec or not search_query:
+        return [], query.replace('\\:', ':').replace('/:', ':'), None
+    
+    # Parse filter specifications (comma-separated)
+    filter_items = [f.strip() for f in filter_spec.split(',') if f.strip()]
+    
+    filters = []
+    for item in filter_items:
+        # Check for "filter=count" pattern (e.g., "mcmod=2")
+        eq_match = re.match(r'^(\w+)\s*=\s*(\d+)$', item)
+        if eq_match:
+            filter_name = eq_match.group(1).lower()
+            count = int(eq_match.group(2))
+            filters.append(('link', filter_name, count))
+        elif item.isdigit():
+            # Pure index
+            filters.append(('index', int(item), 1))
+        else:
+            # Filter name without count (default count=1)
+            filters.append(('link', item.lower(), 1))
+    
+    # Calculate total count
+    total = sum(f[2] for f in filters)
+    if total > max_count:
+        return [], search_query, f"最多选择{max_count}个结果 (当前选择了{total}个)"
+    
+    return filters, search_query, None
+
+
+try:
+    __version__ = get_version("entari_plugin_hyw")
+except Exception:
+    __version__ = "4.0.0-rc8"
+
+
+def parse_color(color: str) -> str:
     if not color:
         return "#ef4444"
-    
     color = str(color).strip()
-    
-    # Hex format: #fff or #ffffff or ffffff
     if color.startswith('#') and len(color) in [4, 7]:
         return color
     if re.match(r'^[0-9a-fA-F]{6}$', color):
         return f'#{color}'
-    
-    # RGB tuple: (r, g, b) or r,g,b
     rgb_match = re.match(r'^\(?(\d+)[,\s]+(\d+)[,\s]+(\d+)\)?$', color)
     if rgb_match:
         r, g, b = (max(0, min(255, int(x))) for x in rgb_match.groups())
         return f'#{r:02x}{g:02x}{b:02x}'
-    
-    logger.warning(f"Invalid color '{color}', using default #ef4444")
     return "#ef4444"
 
+
 class _RecentEventDeduper:
     def __init__(self, ttl_seconds: float = 30.0, max_size: int = 2048):
         self.ttl_seconds = ttl_seconds
@@ -77,158 +152,104 @@ class _RecentEventDeduper:
         expired = [k for k, ts in self._seen.items() if now - ts > self.ttl_seconds]
         for k in expired:
             self._seen.pop(k, None)
-        if len(self._seen) > self.max_size:
-            for k, _ in sorted(self._seen.items(), key=lambda kv: kv[1])[: len(self._seen) - self.max_size]:
-                self._seen.pop(k, None)
 
 _event_deduper = _RecentEventDeduper()
 
-@dataclass
-class ModelConfig:
-    """Model configuration for a specific stage."""
-    model_name: Optional[str] = None
-    api_key: Optional[str] = None
-    base_url: Optional[str] = None
-    extra_body: Optional[Dict[str, Any]] = None
-    model_provider: Optional[str] = None
-    input_price: Optional[float] = None
-    output_price: Optional[float] = None
-    image_input: bool = True
-
 
 @dataclass
 class HywConfig(BasicConfModel):
-    # Core Settings
+    """Plugin configuration"""
     admins: List[str] = field(default_factory=list)
     models: List[Dict[str, Any]] = field(default_factory=list)
     question_command: str = "/q"
     language: str = "Simplified Chinese"
     temperature: float = 0.4
     
-    # Root-level defaults (backward compatible)
     model_name: Optional[str] = None
     api_key: Optional[str] = None
     base_url: str = "https://openrouter.ai/api/v1"
-    extra_body: Optional[Dict[str, Any]] = None
-    model_provider: Optional[str] = None
-    input_price: Optional[float] = None
-    output_price: Optional[float] = None
-    
-    # Nested Stage Configs
-    instruct: Optional[ModelConfig] = None
-    qa: Optional[ModelConfig] = None
-    main: Optional[ModelConfig] = None  # Summary stage
-    vision: Optional[ModelConfig] = None  # Vision description stage
-    
-    # Search/Fetch Settings
+    
     search_engine: str = "google"
     
-    # Rendering Settings
     headless: bool = False
-    render_timeout_ms: int = 6000
-    render_image_timeout_ms: int = 3000
-    
-    # Bot Behavior
     save_conversation: bool = False
     reaction: bool = False
     quote: bool = False
-    
-    # UI Theme
     theme_color: str = "#ff0000"
+
+    # Nested configurations
+    main: Optional[Dict[str, Any]] = None
+    instruct: Optional[Dict[str, Any]] = None
+    vision: Optional[Dict[str, Any]] = None
+    deepsearch_instruct: Optional[Dict[str, Any]] = None
+    deepsearch_agent: Optional[Dict[str, Any]] = None
     
     def __post_init__(self):
-        """Parse and normalize theme color after initialization."""
         self.theme_color = parse_color(self.theme_color)
-        # Convert dicts to ModelConfig if needed
-        if isinstance(self.instruct, dict):
-            self.instruct = ModelConfig(**self.instruct)
-        if isinstance(self.qa, dict):
-            self.qa = ModelConfig(**self.qa)
-        if isinstance(self.main, dict):
-            self.main = ModelConfig(**self.main)
-        if isinstance(self.vision, dict):
-            self.vision = ModelConfig(**self.vision)
     
-    def get_model_config(self, stage: str) -> Dict[str, Any]:
-        """
-        Get resolved model config for a stage.
-        
-        Args:
-            stage: "instruct", "qa", or "main" (summary)
-        
-        Returns:
-            Dict with model_name, api_key, base_url, extra_body, etc.
-        """
-        # Determine primary and secondary config sources
-        primary = None
-        secondary = None
-        
-        if stage == "instruct":
-            primary = self.instruct
-            secondary = self.main # Fallback to main
-        elif stage == "qa":
-            # QA fallback to main as well if ever used
-            primary = self.qa
-            secondary = self.main
-        elif stage == "main":
-            primary = self.main
-        elif stage == "vision":
-            primary = self.vision
-            secondary = self.main  # Fallback to main if vision not fully configured
-            
-        # Build result with fallback logic
-        def resolve(field_name: str, is_essential: bool = True):
-            """Resolve a field with fallback: Primary -> Secondary -> Root."""
-            # 1. Try Primary
-            val = getattr(primary, field_name, None) if primary else None
-            
-            # 2. Try Secondary (if value missing)
-            if val is None and secondary:
-                val = getattr(secondary, field_name, None)
-                
-            # 3. Try Root (if value still missing)
-            if val is None:
-                val = getattr(self, field_name, None)
-            return val
+    def to_hyw_core_config(self) -> HywCoreConfig:
+        main_cfg = self.main or {}
+        instruct_cfg = self.instruct 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"),
+            
+            # Map nested 'instruct' config to instruct stage
+            "instruct_model": instruct_cfg.get("model_name"),
+            "instruct_api_key": instruct_cfg.get("api_key"),
+            "instruct_base_url": instruct_cfg.get("base_url"),
+            "instruct_extra_body": instruct_cfg.get("extra_body"),
+        })
+    
+    def get_model_config(self, stage: str) -> Dict[str, Any]:
         return {
-            "model_name": resolve("model_name"),
-            "api_key": resolve("api_key"),
-            "base_url": resolve("base_url"),
-            "extra_body": resolve("extra_body", is_essential=False),
-            "model_provider": resolve("model_provider", is_essential=False),
-            "input_price": resolve("input_price", is_essential=False),
-            "output_price": resolve("output_price", is_essential=False),
+            "model_name": self.model_name,
+            "api_key": self.api_key,
+            "base_url": self.base_url,
         }
 
 
 conf = plugin_config(HywConfig)
 history_manager = HistoryManager()
 renderer = ContentRenderer(headless=conf.headless)
-from .render_vue import set_global_renderer
 set_global_renderer(renderer)
+search_cache = SearchResultCache(ttl_seconds=600.0)  # 10 minutes
 
-# Pre-start Crawl4AI browser for fast fetching/screenshots
-from .browser.service import prestart_browser, close_screenshot_service
-# prestart_browser(headless=conf.headless)  # Removed to avoid RuntimeError: no running event loop
-
-
-class GlobalCache:
-    models_image_path: Optional[str] = None
+_hyw_core: Optional[HywCore] = None
 
-global_cache = GlobalCache()
+def get_hyw_core() -> HywCore:
+    global _hyw_core
+    if _hyw_core is None:
+        _hyw_core = HywCore(conf.to_hyw_core_config())
+    return _hyw_core
 
 
 @listen(Cleanup)
 async def cleanup_screenshot_service():
-    """Cleanup shared browser on shutdown."""
+    global _hyw_core
     try:
+        if _hyw_core:
+            await _hyw_core.close()
+            _hyw_core = None
         await close_screenshot_service()
-        # Also close the shared browser manager
-        from .browser.manager import close_shared_browser
-        await close_shared_browser()
+        close_shared_browser()
     except Exception as e:
-        logger.warning(f"Failed to cleanup browser services: {e}")
+        logger.warning(f"Failed to cleanup: {e}")
+
 
 async def react(session: Session, emoji: str):
     if not conf.reaction: return
@@ -237,52 +258,35 @@ async def react(session: Session, emoji: str):
     except Exception as e:
         logger.warning(f"Reaction failed: {e}")
 
+
 async def process_request(
     session: Session[MessageCreatedEvent],
     all_param: Optional[MessageChain] = None,
     selected_model: Optional[str] = None,
-    selected_vision_model: Optional[str] = None,
-    conversation_key_override: Optional[str] = None,
-    local_mode: bool = False,
 ) -> None:
     mc = MessageChain(all_param)
     if session.reply:
         try:
-            # Check if reply is from self (the bot)
-            # 1. Check by Message ID (reliable for bot's own messages if recorded)
             reply_msg_id = str(session.reply.origin.id) if hasattr(session.reply.origin, 'id') else None
-            is_bot = False
-            
-            if reply_msg_id and history_manager.is_bot_message(reply_msg_id):
-                is_bot = True
-
-            if is_bot:
-                pass  # Reply is from bot - ignoring
-            else:
+            if not (reply_msg_id and history_manager.is_bot_message(reply_msg_id)):
                 mc.extend(MessageChain(" ") + session.reply.origin.message)
-        except Exception as e:
-            logger.warning(f"Failed to process reply origin: {e}")
+        except Exception:
             mc.extend(MessageChain(" ") + session.reply.origin.message)
     
-    # Filter and reconstruct MessageChain
-    filtered_elements = mc.get(Text) + mc.get(Image) + mc.get(Custom)
-    mc = MessageChain(filtered_elements)
-
-
+    filtered = mc.get(Text) + mc.get(Image) + mc.get(Custom)
+    mc = MessageChain(filtered)
+    
     text_content = str(mc.get(Text)).strip()
-    # Remove HTML image tags from text content to prevent "unreasonable code behavior"
     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
 
-    # History & Context
-    hist_key = conversation_key_override
-    if not hist_key and session.reply and hasattr(session.reply.origin, 'id'):
+    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 []
-    meta = history_manager.get_metadata(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, "✨")
@@ -291,87 +295,29 @@ async def process_request(
         msg_text = str(mc.get(Text)).strip() if mc.get(Text) else ""
         msg_text = re.sub(r'<img[^>]+>', '', msg_text, flags=re.IGNORECASE)
         
-        # If message is empty but has images, use a placeholder
         if not msg_text and (mc.get(Image) or mc.get(Custom)):
-             msg_text = "[图片]"
+            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}"
+                if decoded := process_onebot_json(custom.attributes()): 
+                    msg_text += f"\n{decoded}"
                 break
         
-        # Model Selection (Step 1)
-        # Resolve model names from config if they are short names/keywords
-        model = selected_model or meta.get("model")
-        if model and model != "off":
-            resolved, err = resolve_model_name(model, conf.models)
+        model = selected_model
+        if model:
+            resolved, _ = resolve_model_name(model, conf.models)
             if resolved:
                 model = resolved
-            elif err:
-                logger.warning(f"Model resolution warning for {model}: {err}")
 
-        vision_model = selected_vision_model or meta.get("vision_model")
-        if vision_model and vision_model != "off":
-            resolved_v, err_v = resolve_model_name(vision_model, conf.models)
-            if resolved_v:
-                vision_model = resolved_v
-            elif err_v:
-                logger.warning(f"Vision model resolution warning for {vision_model}: {err_v}")
-
-        images, err = await process_images(mc, vision_model)
-        
-        # Check image input support
-        model_cfg_dict = next((m for m in conf.models if m.get("name") == model), None)
-        image_input_supported = True
-        if model_cfg_dict:
-            image_input_supported = model_cfg_dict.get("image_input", True)
+        images, _ = await process_images(mc, None)
         
-        # Log inferenced content mode
-        inferred_content_mode = "image" if image_input_supported else "text"
-        logger.info(f"Process Request: Model '{model}' Image Input: {image_input_supported} -> Mode: {inferred_content_mode}")
-        
-        if images and not image_input_supported:
-            logger.warning(f"Model '{model}' does not support images, but user sent {len(images)} images.")
-            
-            # Start renderer for the unsupported card
-            renderer = await get_content_renderer()
-            render_tab_task = asyncio.create_task(renderer.prepare_tab())
-            
-            # Wait for tab and render unsupported
-            try:
-                tab_id = await render_tab_task
-            except Exception as e:
-                tab_id = None
-                
-            import tempfile
-            with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tf:
-                output_path = tf.name
-                
-            render_ok = await render_image_unsupported(
-                renderer=renderer,
-                output_path=output_path,
-                theme_color=conf.theme_color,
-                tab_id=tab_id
-            )
-            
-            if render_ok:
-                with open(output_path, "rb") as f:
-                    img_data = base64.b64encode(f.read()).decode()
-                await session.send(MessageChain(Image(src=f'data:image/png;base64,{img_data}')))
-                if os.path.exists(output_path):
-                    os.remove(output_path)
-            return
-
-        renderer = await get_content_renderer()
-        render_tab_task = asyncio.create_task(renderer.prepare_tab())
-        tab_id = None
+        # Prepare renderer
+        local_renderer = await get_content_renderer()
+        render_tab_task = asyncio.create_task(local_renderer.prepare_tab())
 
-        # Call Pipeline directly
-        safe_input = msg_text
-        
         async def send_noti(msg: str):
             try:
-                # Send simple text notification
                 if conf.quote:
                     await session.send([Quote(session.event.message.id), msg])
                 else:
@@ -379,215 +325,601 @@ async def process_request(
             except Exception as e:
                 logger.warning(f"Failed to send notification: {e}")
 
-        pipeline = ModularPipeline(conf, send_func=send_noti)
-        try:
-            resp = await pipeline.execute(
-                safe_input,
-                hist_payload,
-                model_name=model,
-                images=images,
-                selected_vision_model=vision_model,
-            )
-        finally:
-            await pipeline.close()
-        
-        # Step 1 Results
-        step1_vision_model = resp.get("vision_model_used")
-        step1_model = resp.get("model_used")
-        step1_history = resp.get("conversation_history", [])
-        step1_stats = resp.get("stats", {})
-        
-        final_resp = resp
+        request = QueryRequest(
+            user_input=msg_text,
+            images=images,
+            conversation_history=hist_payload,
+            model_name=model,
+            send_notification=send_noti
+        )
         
-        # Step 2 (Optional)
-
-            
+        with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tf:
+            output_path = tf.name
         
-        # Extract Response Data
-        content = final_resp.get("llm_response", "")
-        structured = final_resp.get("structured_response", {})
+        core = get_hyw_core()
+        # 1. Query ONLY (no render path provided)
+        # Pass output_path=None so it returns raw response without internal rendering
+        response = await core.query(request, output_path=None)
         
-        # Wait for tab preparation if needed (should be ready by now)
+        # 2. Get the warmed-up tab
         try:
             tab_id = await render_tab_task
-        except Exception as e:
-            logger.warning(f"Failed to prepare render tab: {e}")
+        except Exception:
             tab_id = None
         
-        # Render
-        import tempfile
-        with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tf:
-            output_path = tf.name
-        model_used = final_resp.get("model_used")
+        display_session_id = history_manager.generate_short_code()
 
-        # Determine session short code
-        if hist_key:
-            display_session_id = history_manager.get_code_by_key(hist_key)
-            if not display_session_id:
-                display_session_id = history_manager.generate_short_code()
-        else:
-            display_session_id = history_manager.generate_short_code()
-
-        # Use stats_list if available, otherwise standard stats
-        stats_to_render = final_resp.get("stats_list", final_resp.get("stats", {}))
-        
-        # Check if refuse_answer was triggered
-        if final_resp.get("refuse_answer"):
-            logger.info(f"Refuse answer triggered. Rendering refuse image. Reason: {final_resp.get('refuse_reason', '')}")
+        if response.should_refuse:
             render_ok = await render_refuse_answer(
-                renderer=renderer,
+                renderer=local_renderer,
                 output_path=output_path,
-                reason=final_resp.get('refuse_reason', 'Instruct 专家分配此任务流程失败，请尝试提出其他问题~'),
+                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:
-            logger.info(f"Rendering card with {len(structured.get('references', []))} references...")
-            render_ok = await renderer.render(
-                markdown_content=content,
+            # 3. Explicit External Render using the Parallel Tab
+            render_ok = await core.render(
+                markdown_content=response.content,
                 output_path=output_path,
-                tab_id=tab_id,
-                stats=stats_to_render,
-                references=structured.get("references", []),
-                page_references=structured.get("page_references", []),
-                image_references=structured.get("image_references", []),
-                stages_used=final_resp.get("stages_used", []),
-                theme_color=conf.theme_color,
+                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
             )
-            logger.info(f"Render completed: {render_ok}")
+            if render_ok:
+                response.image_path = output_path
         
-        # Send & Save
-        if not render_ok:
-            logger.error("Render failed; skipping reply.")
-            if os.path.exists(output_path):
-                try:
-                    os.remove(output_path)
-                except Exception as exc:
-                    logger.warning(f"Failed to delete render output {output_path}: {exc}")
-            sent = None
-        else:
-            # Convert to base64
+        if render_ok:
             with open(output_path, "rb") as f:
                 img_data = base64.b64encode(f.read()).decode()
-                
-            # Build single reply chain (image only now)
-            elements = []
-            elements.append(Image(src=f'data:image/png;base64,{img_data}'))
-
-            msg_chain = MessageChain(*elements)
             
+            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
-                
-            # Use reply_to instead of manual Quote insertion to avoid ActionFailed errors
+            
             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)
-        related = [msg_id] + ([str(session.reply.origin.id)] if session.reply and hasattr(session.reply.origin, 'id') else [])
-        
-        history_manager.remember(
-            sent_id,
-            final_resp.get("conversation_history", []),
-            related,
-            {
-                "model": model_used,
-                "trace_markdown": final_resp.get("trace_markdown"),
-            },
-            context_id,
-            code=display_session_id,
-        )
-        
-        if conf.save_conversation and sent_id:
-            try:
-                # Pass web_results to save fetched pages as markdown, and output image
-                # Also pass vision_trace and instruct_traces for dedicated logs
+            
+            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(
-                    sent_id, 
-                    web_results=final_resp.get("web_results"),
-                    image_path=output_path if 'output_path' in locals() else None,
-                    vision_trace=final_resp.get("vision_trace"),
-                    instruct_traces=final_resp.get("instruct_traces"),
+                    key=sent_id, 
+                    image_path=output_path,
+                    web_results=web_results,
+                    instruct_traces=instruct_traces,
+                    vision_trace=None # Vision integrated into Instruct now
                 )
-            except Exception as e:
-                logger.warning(f"Failed to save conversation: {e}")
         
-        # Cleanup temp image
-        if 'output_path' in locals() and output_path and os.path.exists(output_path):
-            try:
-                os.remove(output_path)
-            except Exception:
-                pass
-        
-
-
+        if os.path.exists(output_path):
+            os.remove(output_path)
 
     except Exception as e:
         logger.exception(f"Error: {e}")
-        err_msg = f"Error: {e}"
-        if conf.quote:
-             await session.send([Quote(session.event.message.id), err_msg])
-        else:
-             await session.send(err_msg)
-        
-        # Save conversation on error if response was generated
-        if 'resp' in locals() and resp and conf.save_conversation:
-            try:
-                # Use a temporary ID for error cases
-                error_id = f"error_{int(time.time())}_{secrets.token_hex(4)}"
-                
-                # Try to salvage history
-                partial_hist = []
-                if 'resp' in locals() and resp:
-                    partial_hist = resp.get("conversation_history", [])
-                elif 'context' in locals() and context and hasattr(context, 'instruct_history'):
-                    partial_hist = context.instruct_history
-                    
-                related_ids = []
-                if 'session' in locals():
-                     msg_id = str(session.event.message.id) if hasattr(session.event, 'message') else str(session.event.id)
-                     related_ids = [msg_id]
+        await session.send(f"Error: {e}")
 
-                history_manager.remember(error_id, partial_hist, related_ids, {"model": "error", "error": str(e)}, context_id, code=display_session_id if 'display_session_id' in locals() else None)
-                
-                # Save debug data on error
-                web_res = context.web_results if 'context' in locals() and context else []
-                
-                history_manager.save_to_disk(
-                    error_id,
-                    web_results=web_res
-                )
 
-            except Exception as save_err:
-                logger.error(f"Failed to save error conversation: {save_err}")
 
-
-alc = Alconna(
-    conf.question_command,
-    Args["all_param;?", AllParam],
-)
+alc = Alconna(conf.question_command, Args["all_param;?", AllParam])
 
 @command.on(alc)    
 async def handle_question_command(session: Session[MessageCreatedEvent], result: Arparma):
-    """Handle main Question command"""
     try:
-        logger.info(f"Question Command Triggered. Message: {result}")
         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):
-            logger.warning(f"Duplicate command event ignored: {dedupe_key}")
             return
     except Exception:
         pass
-
-    logger.info(f"Question Command Triggered. Message: {session.event.message}")
     
     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
+                import re
+                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
+    
+    # === Filter Mode: Search + Find matching links + Summarize ===
+    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()
+        
+        # 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", "")
+                    if filter_value in url.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 concurrently
+        screenshot_tasks = [core.screenshot(url) for url in urls_to_screenshot]
+        screenshot_results = await asyncio.gather(*screenshot_tasks)
+        screenshots = [b64 for b64 in screenshot_results if b64]
+        
+        if not screenshots:
+            try: await tab_task
+            except: pass
+            await session.send("无法截图页面")
+            return
+        
+        # Pass screenshots to LLM for summarization
+        user_query = f"总结关于 \"{search_query}\" 的内容"
+        
+        request = QueryRequest(
+            user_input=user_query,
+            images=screenshots,
+            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'}")
+        
+        return
     
-    await process_request(session, args.get("all_param"), selected_model=None, selected_vision_model=None, conversation_key_override=None)
+    # Normal query mode (no cache context)
+    await process_request(session, all_param)
 
-metadata("hyw", author=[{"name": "kumoSleeping", "email": "zjr2992@outlook.com"}], version=__version__, config=HywConfig)
 
+# Search/Web Command (/w)
+alc_search = Alconna("/w", 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
+    
+    # No query and no cache context - nothing to do
+    if not query:
+        return
+
+    try:
+        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
+                
+                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
+        
+        # Search first
+        search_task = asyncio.create_task(core.search([search_query]))
+        
+        if conf.reaction: 
+            asyncio.create_task(react(session, "🔍"))
+        
+        results = await search_task
+        flat_results = results[0] if results else []
+        
+        if not flat_results:
+            await session.send("Search returned no results.")
+            return
+
+        visible = [r for r in flat_results if not r.get("_hidden", False)]
+        
+        if not visible:
+            await session.send("Search returned no visible results.")
+            return
+        
+        # === Filter Mode: Screenshot matching links ===
+        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", "")
+                        if filter_value in url.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: Screenshot search results page ===
+        search_service = core._search_service
+        search_url = search_service._build_search_url(search_query)
+        
+        # Handle address bar search marker
+        if search_url.startswith("__ADDRESS_BAR_SEARCH__:"):
+            import urllib.parse
+            encoded_query = urllib.parse.quote_plus(search_query)
+            search_url = f"https://www.google.com/search?q={encoded_query}"
+        
+        b64_img = await core.screenshot(search_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
+            
+            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)
+        else:
+            await session.send(f"截图搜索页面失败: {search_url}")
+        
+        search_cache.cleanup()  # Lazy cleanup
+
+    except Exception as 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)
 
 @listen(CommandReceive)
 async def remove_at(content: MessageChain):