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

entari_plugin_hyw/history.py

@@ -75,7 +75,7 @@ class HistoryManager:
                 self._context_history[context_id] = []
             self._context_history[context_id].append(key)
 
-    def save_to_disk(self, key: str, save_root: str = "data/conversations", image_path: Optional[str] = None, web_results: Optional[List[Dict]] = None):
+    def save_to_disk(self, key: str, save_root: str = "data/conversations", image_path: Optional[str] = None, web_results: Optional[List[Dict]] = None, vision_trace: Optional[Dict] = None, instruct_traces: Optional[List[Dict]] = None):
         """Save conversation history to specific folder structure"""
         import os
         import time
@@ -198,51 +198,41 @@ class HistoryManager:
                 except Exception as e:
                     print(f"Failed to copy output image: {e}")
 
-            # 4. Save Full Log (Readme style)
-            timestamp = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
-            model_name = meta.get("model", "unknown")
-            code = self._key_to_code.get(key, "N/A")
-            
-            md_content = f"# Conversation Log: {folder_name}\n\n"
-            md_content += f"- **Time**: {timestamp}\n"
-            md_content += f"- **Code**: {code}\n"
-            md_content += f"- **Model**: {model_name}\n\n"
-
-            md_content += "## History\n\n"
-            
-            for msg in self._history[key]:
-                role = msg.get("role", "unknown").upper()
-                content = msg.get("content", "")
-                
-                md_content += f"### {role}\n\n"
+            # 4. Save Vision Log (if vision stage was used)
+            if vision_trace and not vision_trace.get("skipped"):
+                vision_md = "# Vision Stage Log\n\n"
+                vision_md += f"- **Model**: {vision_trace.get('model', 'unknown')}\n"
+                vision_md += f"- **Time**: {vision_trace.get('time', 0):.2f}s\n"
+                vision_md += f"- **Images Count**: {vision_trace.get('images_count', 0)}\n"
+                vision_md += f"- **Input Tokens**: {vision_trace.get('usage', {}).get('input_tokens', 0)}\n"
+                vision_md += f"- **Output Tokens**: {vision_trace.get('usage', {}).get('output_tokens', 0)}\n\n"
+                vision_md += "## Vision Description Output\n\n"
+                vision_md += f"```\n{vision_trace.get('output', '')}\n```\n"
                 
-                tool_calls = msg.get("tool_calls")
-                if tool_calls:
-                     try:
-                         tc_str = json.dumps(tool_calls, ensure_ascii=False, indent=2)
-                     except:
-                         tc_str = str(tool_calls)
-                     md_content += f"**Tool Calls**:\n```json\n{tc_str}\n```\n\n"
-                
-                if role == "TOOL":
-                    try:
-                        # Try parsing as JSON first
-                        if isinstance(content, str):
-                            parsed = json.loads(content)
-                            pretty = json.dumps(parsed, ensure_ascii=False, indent=2)
-                            md_content += f"**Output**:\n```json\n{pretty}\n```\n\n"
-                        else:
-                            md_content += f"**Output**:\n```text\n{content}\n```\n\n"
-                    except:
-                         md_content += f"**Output**:\n```text\n{content}\n```\n\n"
-                else:
-                    if content:
-                        md_content += f"{content}\n\n"
-                
-                md_content += "---\n\n"
+                with open(os.path.join(folder_path, "vision_log.md"), "w", encoding="utf-8") as f:
+                    f.write(vision_md)
             
-            with open(os.path.join(folder_path, "full_log.md"), "w", encoding="utf-8") as f:
-                f.write(md_content)
+            # 5. Save Instruct Log (all instruct rounds)
+            if instruct_traces:
+                instruct_md = "# Instruct Stage Log\n\n"
+                for i, trace in enumerate(instruct_traces):
+                    stage_name = trace.get("stage_name", f"Round {i+1}")
+                    instruct_md += f"## {stage_name}\n\n"
+                    instruct_md += f"- **Model**: {trace.get('model', 'unknown')}\n"
+                    instruct_md += f"- **Time**: {trace.get('time', 0):.2f}s\n"
+                    instruct_md += f"- **Tool Calls**: {trace.get('tool_calls', 0)}\n"
+                    instruct_md += f"- **Input Tokens**: {trace.get('usage', {}).get('input_tokens', 0)}\n"
+                    instruct_md += f"- **Output Tokens**: {trace.get('usage', {}).get('output_tokens', 0)}\n\n"
+                    
+                    output = trace.get("output", "")
+                    if output:
+                        instruct_md += "### Reasoning Output\n\n"
+                        instruct_md += f"```\n{output}\n```\n\n"
+                    
+                    instruct_md += "---\n\n"
+                
+                with open(os.path.join(folder_path, "instruct_log.md"), "w", encoding="utf-8") as f:
+                    f.write(instruct_md)
                 
         except Exception as e:
             print(f"Failed to save conversation: {e}")

entari_plugin_hyw/misc.py

@@ -133,3 +133,37 @@ async def render_refuse_answer(
         theme_color=theme_color,
     )
 
+
+IMAGE_UNSUPPORTED_MARKDOWN = """
+<summary>
+当前模型不支持图片输入，请使用支持视觉能力的模型或仅发送文本。
+</summary>
+"""
+
+async def render_image_unsupported(
+    renderer,
+    output_path: str,
+    theme_color: str = "#ef4444",
+    tab_id: str = None
+) -> bool:
+    """
+    Render a card indicating that the model does not support image input.
+    """
+    markdown = f"""
+# 图片输入不支持
+
+> 当前选择的模型不支持图片输入。
+> 请切换到支持视觉的模型，或仅发送文本内容。
+"""
+    return await renderer.render(
+        markdown_content=markdown,
+        output_path=output_path,
+        stats={},
+        references=[],
+        page_references=[],
+        image_references=[],
+        stages_used=[],
+        image_timeout=1000,
+        theme_color=theme_color,
+        tab_id=tab_id
+    )

entari_plugin_hyw/modular_pipeline.py

@@ -7,15 +7,16 @@ Simpler flow with self-correction/feedback loop.
 
 import asyncio
 import time
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Callable, Awaitable
 
 from loguru import logger
 from openai import AsyncOpenAI
 
 from .stage_base import StageContext
 from .stage_instruct import InstructStage
-from .stage_instruct_review import InstructReviewStage
+from .stage_instruct_deepsearch import InstructDeepsearchStage
 from .stage_summary import SummaryStage
+from .stage_vision import VisionStage
 from .search import SearchService
 
 
@@ -24,20 +25,27 @@ class ModularPipeline:
     Modular Pipeline.
     
     Flow:
-    1. Instruct (Round 1): Initial Discovery.
-    2. Instruct Review (Round 2): Review & Refine.
+    1. Instruct: Initial Discovery + Mode Decision (fast/deepsearch).
+    2. [Deepsearch only] Instruct Deepsearch Loop: Supplement info (max 3 iterations).
     3. Summary: Generate final response.
     """
     
-    def __init__(self, config: Any):
+    def __init__(self, config: Any, send_func: Optional[Callable[[str], Awaitable[None]]] = None):
         self.config = config
+        self.send_func = send_func
         self.search_service = SearchService(config)
         self.client = AsyncOpenAI(base_url=config.base_url, api_key=config.api_key)
         
         # Initialize stages
-        self.instruct_stage = InstructStage(config, self.search_service, self.client)
-        self.instruct_review_stage = InstructReviewStage(config, self.search_service, self.client)
+        self.instruct_stage = InstructStage(config, self.search_service, self.client, send_func=send_func)
+        self.instruct_deepsearch_stage = InstructDeepsearchStage(config, self.search_service, self.client)
         self.summary_stage = SummaryStage(config, self.search_service, self.client)
+        self.vision_stage = VisionStage(config, self.search_service, self.client)
+    
+    def _has_vision_model(self) -> bool:
+        """Check if a vision model is configured."""
+        vision_cfg = self.config.get_model_config("vision")
+        return bool(vision_cfg.get("model_name"))
     
     async def execute(
         self,
@@ -53,6 +61,9 @@ class ModularPipeline:
         stats = {"start_time": start_time}
         usage_totals = {"input_tokens": 0, "output_tokens": 0}
         active_model = model_name or self.config.model_name
+        if not active_model:
+             # Fallback to instruct model for logging/context
+             active_model = self.config.get_model_config("instruct").get("model_name")
         
         context = StageContext(
             user_input=user_input,
@@ -60,6 +71,16 @@ class ModularPipeline:
             conversation_history=conversation_history,
         )
         
+        # Determine if model supports image input
+        model_cfg_dict = next((m for m in self.config.models if m.get("name") == active_model), None)
+        if model_cfg_dict:
+            context.image_input_supported = model_cfg_dict.get("image_input", True)
+        else:
+             context.image_input_supported = True # Default to True if unknown
+             
+        logger.info(f"Pipeline Execution: Model '{active_model}' Image Input Supported: {context.image_input_supported}")
+
+        
         trace: Dict[str, Any] = {
             "instruct_rounds": [],
             "summary": None,
@@ -68,6 +89,24 @@ class ModularPipeline:
         try:
             logger.info(f"Pipeline: Processing '{user_input[:30]}...'")
             
+            # === Stage 0: Vision (if images and vision model configured) ===
+            if images and self._has_vision_model():
+                logger.info("Pipeline: Stage 0 - Vision (generating image description)")
+                vision_result = await self.vision_stage.execute(context, images)
+                
+                if vision_result.success and vision_result.data.get("description"):
+                    context.vision_description = vision_result.data["description"]
+                    logger.info(f"Pipeline: Vision description generated ({len(context.vision_description)} chars)")
+                    
+                    # Add vision trace
+                    trace["vision"] = vision_result.trace
+                    usage_totals["input_tokens"] += vision_result.usage.get("input_tokens", 0)
+                    usage_totals["output_tokens"] += vision_result.usage.get("output_tokens", 0)
+                    
+                    # Clear images since we have the description now
+                    # (don't pass raw images to later stages when using vision model)
+                    images = []
+            
             # === Stage 1: Instruct (Initial Discovery) ===
             logger.info("Pipeline: Stage 1 - Instruct")
             instruct_result = await self.instruct_stage.execute(context)
@@ -82,30 +121,95 @@ class ModularPipeline:
             if context.should_refuse:
                 return self._build_refusal_response(context, conversation_history, active_model, stats)
 
-            # === Stage 2: Instruct Review (Refine) ===
-            logger.info("Pipeline: Stage 2 - Instruct Review")
-            review_result = await self.instruct_review_stage.execute(context)
+            # === Stage 2: Deepsearch Loop (if mode is deepsearch) ===
+            if context.selected_mode == "deepsearch":
+                MAX_DEEPSEARCH_ITERATIONS = 3
+                logger.info(f"Pipeline: Mode is 'deepsearch', starting loop (max {MAX_DEEPSEARCH_ITERATIONS} iterations)")
+                
+                for i in range(MAX_DEEPSEARCH_ITERATIONS):
+                    logger.info(f"Pipeline: Stage 2 - Deepsearch Iteration {i + 1}")
+                    deepsearch_result = await self.instruct_deepsearch_stage.execute(context)
+                    
+                    # Trace & Usage
+                    deepsearch_result.trace["stage_name"] = f"Deepsearch (Iteration {i + 1})"
+                    trace["instruct_rounds"].append(deepsearch_result.trace)
+                    usage_totals["input_tokens"] += deepsearch_result.usage.get("input_tokens", 0)
+                    usage_totals["output_tokens"] += deepsearch_result.usage.get("output_tokens", 0)
+                    
+                    # Check if should stop
+                    if deepsearch_result.data.get("should_stop"):
+                        logger.info(f"Pipeline: Deepsearch loop ended at iteration {i + 1}")
+                        break
+            else:
+                logger.info("Pipeline: Mode is 'fast', skipping deepsearch stage")
+            
+            # === Parallel Execution: Summary Generation + Image Prefetching ===
+            # We run image prefetching concurrently with Summary generation to save time.
+            
+            # 1. Prepare candidates for prefetch (all images in search results)
+            all_candidate_urls = set()
+            for r in context.web_results:
+                # Add images from search results/pages
+                if r.get("images"):
+                    for img in r["images"]:
+                        if img and isinstance(img, str) and img.startswith("http"):
+                            all_candidate_urls.add(img)
+            
+            prefetch_list = list(all_candidate_urls)
+            logger.info(f"Pipeline: Starting parallel execution (Summary + Prefetch {len(prefetch_list)} images)")
+            
+            # 2. Define parallel tasks with timing
+            async def timed_summary():
+                t0 = time.time()
+                # Collect page screenshots if image mode
+                summary_input_images = list(images) if images else []
+                if context.image_input_supported:
+                    # Collect pre-rendered screenshots from web_results
+                    for r in context.web_results:
+                        if r.get("_type") == "page" and r.get("screenshot_b64"):
+                            summary_input_images.append(r["screenshot_b64"])
+                
+                res = await self.summary_stage.execute(
+                    context,
+                    images=summary_input_images if summary_input_images else None
+                )
+                duration = time.time() - t0
+                return res, duration
+
+            async def timed_prefetch():
+                t0 = time.time()
+                if not prefetch_list:
+                    return {}, 0.0
+                try:
+                    from .image_cache import get_image_cache
+                    cache = get_image_cache()
+                    # Start prefetch (non-blocking kickoff)
+                    cache.start_prefetch(prefetch_list)
+                    # Wait for results (blocking until done)
+                    res = await cache.get_all_cached(prefetch_list)
+                    duration = time.time() - t0
+                    return res, duration
+                except Exception as e:
+                    logger.warning(f"Pipeline: Prefetch failed: {e}")
+                    return {}, time.time() - t0
+
+            # 3. Execute concurrently
+            summary_task = asyncio.create_task(timed_summary())
+            prefetch_task = asyncio.create_task(timed_prefetch())
+            
+            # Wait for both to complete
+            await asyncio.wait([summary_task, prefetch_task])
+            
+            # 4. Process results and log timing
+            summary_result, summary_time = await summary_task
+            cached_map, prefetch_time = await prefetch_task
+            
+            time_diff = abs(summary_time - prefetch_time)
+            if summary_time > prefetch_time:
+                logger.info(f"Pipeline: Image Prefetch finished first ({prefetch_time:.2f}s). Summary took {summary_time:.2f}s. (Waited {time_diff:.2f}s for Summary)")
+            else:
+                logger.info(f"Pipeline: Summary finished first ({summary_time:.2f}s). Image Prefetch took {prefetch_time:.2f}s. (Waited {time_diff:.2f}s for Prefetch)")
             
-            # Trace & Usage
-            review_result.trace["stage_name"] = "Instruct Review (Round 2)"
-            trace["instruct_rounds"].append(review_result.trace)
-            usage_totals["input_tokens"] += review_result.usage.get("input_tokens", 0)
-            usage_totals["output_tokens"] += review_result.usage.get("output_tokens", 0)
-            
-            # === Stage 3: Summary ===
-            # Collect page screenshots if image mode (already rendered in InstructStage)
-            all_images = list(images) if images else []
-            
-            if getattr(self.config, "page_content_mode", "text") == "image":
-                # Collect pre-rendered screenshots from web_results
-                for r in context.web_results:
-                    if r.get("_type") == "page" and r.get("screenshot_b64"):
-                        all_images.append(r["screenshot_b64"])
-            
-            summary_result = await self.summary_stage.execute(
-                context,
-                images=all_images if all_images else None
-            )
             trace["summary"] = summary_result.trace
             usage_totals["input_tokens"] += summary_result.usage.get("input_tokens", 0)
             usage_totals["output_tokens"] += summary_result.usage.get("output_tokens", 0)
@@ -116,34 +220,34 @@ class ModularPipeline:
             stats["total_time"] = time.time() - start_time
             structured = self._parse_response(summary_content, context)
             
-            # === Image Caching (Prefetch images for UI) ===
-            try:
-                from .image_cache import get_image_cache
-                cache = get_image_cache()
-                
-                # 1. Collect all image URLs from structured response
-                all_image_urls = []
-                for ref in structured.get("references", []):
-                    if ref.get("images"):
-                        all_image_urls.extend([img for img in ref["images"] if img and img.startswith("http")])
-                
-                if all_image_urls:
-                    # 2. Prefetch (wait for them as we are about to render)
-                    cached_map = await cache.get_all_cached(all_image_urls)
-                    
-                    # 3. Update structured response with cached (base64) URLs
+            # === Apply Cached Images ===
+            # Update structured response using the map from parallel prefetch
+            if cached_map:
+                try:
+                    total_replaced = 0
                     for ref in structured.get("references", []):
                         if ref.get("images"):
-                            # Filter: Only keep images that were successfully cached (starts with data:)
-                            # Discard original URLs if download failed, to prevent broken images in UI
                             new_images = []
                             for img in ref["images"]:
+                                # 1. Already Base64 -> Keep it
+                                if img.startswith("data:"):
+                                    new_images.append(img)
+                                    continue
+                                
+                                # 2. Check cache
                                 cached_val = cached_map.get(img)
                                 if cached_val and cached_val.startswith("data:"):
                                     new_images.append(cached_val)
+                                    total_replaced += 1
+                                # 3. Else -> DROP IT (as per policy)
                             ref["images"] = new_images
-            except Exception as e:
-                logger.warning(f"Pipeline: Image caching failed: {e}")
+                    logger.debug(f"Pipeline: Replaced {total_replaced} images with cached versions")
+                except Exception as e:
+                    logger.warning(f"Pipeline: Applying cached images failed: {e}")
+            
+            # Debug: Log image counts
+            total_ref_images = sum(len(ref.get("images", []) or []) for ref in structured.get("references", []))
+            logger.info(f"Pipeline: Final structured response has {len(structured.get('references', []))} refs with {total_ref_images} images total")
             
             stages_used = self._build_stages_ui(trace, context, images)
             
@@ -164,6 +268,8 @@ class ModularPipeline:
                 },
                 "stages_used": stages_used,
                 "web_results": context.web_results,
+                "vision_trace": trace.get("vision"),
+                "instruct_traces": trace.get("instruct_rounds", []),
             }
 
         except Exception as e:
@@ -281,6 +387,27 @@ class ModularPipeline:
                 "references": search_refs,
                 "description": f"Found {len(search_refs)} results."
             })
+        
+        # 2. Vision Stage (if used)
+        if trace.get("vision"):
+            v = trace["vision"]
+            if not v.get("skipped"):
+                usage = v.get("usage", {})
+                vision_cfg = self.config.get_model_config("vision")
+                input_price = vision_cfg.get("input_price") or 0
+                output_price = vision_cfg.get("output_price") or 0
+                cost = (usage.get("input_tokens", 0) * input_price + usage.get("output_tokens", 0) * output_price) / 1_000_000
+                
+                stages.append({
+                    "name": "Vision",
+                    "model": v.get("model"),
+                    "icon_config": "google",
+                    "provider": "Vision",
+                    "time": v.get("time", 0),
+                    "description": f"Analyzed {v.get('images_count', 0)} image(s).",
+                    "usage": usage,
+                    "cost": cost
+                })
             
         # 2. Instruct Rounds
         for i, t in enumerate(trace.get("instruct_rounds", [])):

entari_plugin_hyw/search.py

@@ -8,7 +8,9 @@ from loguru import logger
 from .browser.service import get_screenshot_service
 # New engines
 from .browser.engines.bing import BingEngine
-from .browser.engines.searxng import SearXNGEngine
+from .browser.engines.duckduckgo import DuckDuckGoEngine
+from .browser.engines.google import GoogleEngine
+from .browser.engines.default import DefaultEngine
 
 class SearchService:
     def __init__(self, config: Any):
@@ -20,12 +22,21 @@ class SearchService:
         # Domain blocking
         self._blocked_domains = getattr(config, "blocked_domains", []) or []
         
-        # Select Engine
-        self._engine_name = getattr(config, "search_engine", "bing").lower()
+        # Select Engine - DefaultEngine when not specified
+        self._engine_name = getattr(config, "search_engine", None)
+        if self._engine_name:
+            self._engine_name = self._engine_name.lower()
+        
         if self._engine_name == "bing":
             self._engine = BingEngine()
+        elif self._engine_name == "google":
+            self._engine = GoogleEngine()
+        elif self._engine_name == "duckduckgo":
+            self._engine = DuckDuckGoEngine()
         else:
-            self._engine = SearXNGEngine()
+            # Default: use browser address bar search (Google-based)
+            self._engine = DefaultEngine()
+            self._engine_name = "default"
         
         logger.info(f"SearchService initialized with engine: {self._engine_name}")
 
@@ -33,51 +44,82 @@ class SearchService:
         return self._engine.build_url(query, self._default_limit)
 
     async def search_batch(self, queries: List[str]) -> List[List[Dict[str, Any]]]:
-        """Execute multiple searches concurrently."""
+        """Execute multiple searches concurrently using standard URL navigation."""
+        logger.info(f"SearchService: Batch searching {len(queries)} queries in parallel...")
         tasks = [self.search(q) for q in queries]
         return await asyncio.gather(*tasks)
 
     async def search(self, query: str) -> List[Dict[str, Any]]:
         """
         Main search entry point. 
-        Returns parsed results + 1 raw page item (marked hidden).
+        Returns parsed search results only.
         """
         if not query:
             return []
 
         # Apply blocking
         final_query = query
-        enable_blocking = getattr(self.config, "enable_domain_blocking", True)
-        if enable_blocking and self._blocked_domains and "-site:" not in query:
+        if self._blocked_domains and "-site:" not in query:
              exclusions = " ".join([f"-site:{d}" for d in self._blocked_domains])
              final_query = f"{query} {exclusions}"
 
         url = self._build_search_url(final_query)
-        logger.info(f"Search: '{query}' -> {url}")
-
+        
         results = []
         try:
-            # Fetch - Search parsing doesn't need screenshot, only HTML
-            page_data = await self.fetch_page_raw(url, include_screenshot=False)
+            # Check if this is an address bar search (DefaultEngine)
+            if url.startswith("__ADDRESS_BAR_SEARCH__:"):
+                # Extract query from marker
+                search_query = url.replace("__ADDRESS_BAR_SEARCH__:", "")
+                logger.info(f"Search: '{query}' -> [Address Bar Search]")
+                
+                # Use address bar input method
+                service = get_screenshot_service(headless=self._headless)
+                page_data = await service.search_via_address_bar(search_query)
+            else:
+                logger.info(f"Search: '{query}' -> {url}")
+                # Standard URL navigation
+                page_data = await self.fetch_page_raw(url, include_screenshot=False)
+            
             content = page_data.get("html", "") or page_data.get("content", "")
             
-            # 1. Add Raw Page Item (Always)
-            # This allows history manager to save the raw search page for debugging
-            raw_item = {
-                "title": f"Raw Search: {query}",
-                "url": url,
-                "content": content,     # Keep original content
-                "type": "search_raw_page",   # Special type for history
-                "_hidden": False,        # Unhidden to allow LLM access if needed
-                "query": query,
-                "images": page_data.get("images", [])
-            }
-            results.append(raw_item)
+            # Debug: Log content length
+            logger.debug(f"Search: Raw content length = {len(content)} chars")
+            if len(content) < 500:
+                logger.warning(f"Search: Content too short, may be empty/blocked. First 500 chars: {content[:500]}")
 
-            # 2. Parse Results
+            # Parse Results (skip raw page - only return parsed results)
             if content and not content.startswith("Error"):
                 parsed = self._engine.parse(content)
+                
+                # Debug: Log parse result
+                logger.info(f"Search: Engine {self._engine_name} parsed {len(parsed)} results from {len(content)} chars")
+
+                # JAVASCRIPT IMAGE INJECTION
+                # Inject base64 images from JS extraction if available
+                # This provides robust fallback if HTTP URLs fail to load
+                js_images = page_data.get("images", [])
+                if js_images:
+                    logger.info(f"Search: Injecting {len(js_images)} base64 images into top results")
+                    for i, img_b64 in enumerate(js_images):
+                        if i < len(parsed):
+                            b64_src = f"data:image/jpeg;base64,{img_b64}" if not img_b64.startswith("data:") else img_b64
+                            if "images" not in parsed[i]: parsed[i]["images"] = []
+                            # Prepend to prioritize base64 (guaranteed render) over HTTP URLs
+                            parsed[i]["images"].insert(0, b64_src)
+
                 logger.info(f"Search parsed {len(parsed)} results for '{query}' using {self._engine_name}")
+                
+                # ALWAYS add raw search page as hidden item for debug saving
+                # (even when 0 results, so we can debug the parser)
+                results.append({
+                    "title": f"[DEBUG] Raw Search: {query}",
+                    "url": url,
+                    "content": content[:50000],  # Limit to 50KB
+                    "_type": "search_raw_page",
+                    "_hidden": True,  # Don't show to LLM
+                })
+                    
                 results.extend(parsed)
             else:
                 logger.warning(f"Search failed/empty for '{query}': {content[:100]}")

entari_plugin_hyw/stage_base.py

@@ -31,10 +31,17 @@ class StageContext:
     # Control flags
     should_refuse: bool = False
     refuse_reason: str = ""
+    selected_mode: str = "fast"  # "fast" or "deepsearch"
     
     # ID counter for unified referencing
     global_id_counter: int = 0
     
+    # Model capabilities
+    image_input_supported: bool = True
+    
+    # Vision description (from VisionStage)
+    vision_description: str = ""
+    
     def next_id(self) -> int:
         """Get next global ID."""
         self.global_id_counter += 1