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

entari_plugin_hyw/__init__.py

@@ -22,7 +22,7 @@ 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, REFUSE_ANSWER_MARKDOWN
+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
@@ -93,6 +93,7 @@ class ModelConfig:
     model_provider: Optional[str] = None
     input_price: Optional[float] = None
     output_price: Optional[float] = None
+    image_input: bool = True
 
 
 @dataclass
@@ -119,9 +120,7 @@ class HywConfig(BasicConfModel):
     main: Optional[ModelConfig] = None  # Summary stage
     
     # Search/Fetch Settings
-    search_engine: str = "bing"
-    enable_domain_blocking: bool = True
-    page_content_mode: str = "text"
+    search_engine: str = "google"
     
     # Rendering Settings
     headless: bool = False
@@ -131,10 +130,10 @@ class HywConfig(BasicConfModel):
     # Bot Behavior
     save_conversation: bool = False
     reaction: bool = False
-    quote: bool = True
+    quote: bool = False
     
     # UI Theme
-    theme_color: str = "#ef4444"
+    theme_color: str = "#ff0000"
     
     def __post_init__(self):
         """Parse and normalize theme color after initialization."""
@@ -315,7 +314,48 @@ async def process_request(
 
         images, err = await process_images(mc, vision_model)
         
-        # Start preparing render tab (async)
+        # 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)
+        
+        # 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

entari_plugin_hyw/browser/engines/{searxng.py → duckduckgo.py}

@@ -5,9 +5,9 @@ from typing import List, Dict, Any
 from loguru import logger
 from .base import SearchEngine
 
-class SearXNGEngine(SearchEngine):
+class DuckDuckGoEngine(SearchEngine):
     """
-    Parser for DuckDuckGo and SearXNG results.
+    Parser for DuckDuckGo Lite results.
     Handles both Markdown (from Crawl4AI) and HTML (fallback).
     """
     
@@ -83,7 +83,7 @@ class SearXNGEngine(SearchEngine):
                 })
                 seen_urls.add(href)
                 
-        logger.info(f"SearXNG Parser(HTML) found {len(results)} results.")
+        logger.info(f"DuckDuckGo Parser(HTML) found {len(results)} results.")
         return results
 
     def _parse_markdown(self, content: str) -> List[Dict[str, Any]]:
@@ -133,5 +133,5 @@ class SearXNGEngine(SearchEngine):
         if current_result:
              results.append(current_result)
         
-        logger.info(f"SearXNG Parser(Markdown) found {len(results)} results.")
+        logger.info(f"DuckDuckGo Parser(Markdown) found {len(results)} results.")
         return results

entari_plugin_hyw/browser/engines/google.py

@@ -0,0 +1,155 @@
+
+import urllib.parse
+import re
+from typing import List, Dict, Any
+from loguru import logger
+from .base import SearchEngine
+
+
+class GoogleEngine(SearchEngine):
+    """
+    Search engine implementation for Google.
+    Parses Google Search HTML results.
+    """
+    
+    def build_url(self, query: str, limit: int = 10) -> str:
+        encoded_query = urllib.parse.quote(query)
+        return f"https://www.google.com/search?q={encoded_query}"
+
+    def parse(self, content: str) -> List[Dict[str, Any]]:
+        results = []
+        seen_urls = set()
+        
+        # Google search results are in blocks with class="MjjYud" or similar containers
+        # Split by result blocks first for more accurate extraction
+        
+        # Method 1: Split by common result block classes
+        block_patterns = [
+            r'<div class="MjjYud"[^>]*>',
+            r'<div class="tF2Cxc"[^>]*>',
+            r'<div class="g Ww4FFb"[^>]*>',
+        ]
+        
+        blocks = [content]
+        for bp in block_patterns:
+            new_blocks = []
+            for block in blocks:
+                parts = re.split(bp, block)
+                new_blocks.extend(parts)
+            blocks = new_blocks
+        
+        for block in blocks:
+            if len(block) < 100:
+                continue
+                
+            # Find URL in this block - prefer links with h3 nearby
+            url_match = re.search(r'<a[^>]+href="(https?://(?!www\.google\.|google\.|webcache\.googleusercontent\.)[^"]+)"[^>]*>', block)
+            if not url_match:
+                continue
+                
+            url = url_match.group(1)
+            if url in seen_urls or self._should_skip_url(url):
+                continue
+            
+            # Find h3 title in this block
+            h3_match = re.search(r'<h3[^>]*>(.*?)</h3>', block, re.IGNORECASE | re.DOTALL)
+            if not h3_match:
+                continue
+                
+            title = re.sub(r'<[^>]+>', '', h3_match.group(1)).strip()
+            if not title or len(title) < 2:
+                continue
+            
+            seen_urls.add(url)
+            
+            # Extract snippet from VwiC3b class (Google's snippet container)
+            snippet = ""
+            snippet_match = re.search(r'<div[^>]*class="[^"]*VwiC3b[^"]*"[^>]*>(.*?)</div>', block, re.IGNORECASE | re.DOTALL)
+            if snippet_match:
+                snippet = re.sub(r'<[^>]+>', ' ', snippet_match.group(1)).strip()
+                snippet = re.sub(r'\s+', ' ', snippet).strip()
+            
+            # Fallback: look for any text after h3
+            if not snippet:
+                # Try other common snippet patterns
+                alt_patterns = [
+                    r'<span[^>]*class="[^"]*aCOpRe[^"]*"[^>]*>(.*?)</span>',
+                    r'<div[^>]*data-snc[^>]*>(.*?)</div>',
+                ]
+                for ap in alt_patterns:
+                    am = re.search(ap, block, re.IGNORECASE | re.DOTALL)
+                    if am:
+                        snippet = re.sub(r'<[^>]+>', ' ', am.group(1)).strip()
+                        snippet = re.sub(r'\s+', ' ', snippet).strip()
+                        break
+            
+            # Extract images from this block
+            images = []
+            # Pattern 1: Regular img src (excluding data: and tracking pixels)
+            # Note: gstatic.com/images/branding is logo, but encrypted-tbn*.gstatic.com are thumbnails
+            img_matches = re.findall(r'<img[^>]+src="(https?://[^"]+)"', block)
+            for img_url in img_matches:
+                # Decode HTML entities
+                img_url = img_url.replace('&amp;', '&')
+                # Skip tracking/icon/small images (but allow encrypted-tbn which are valid thumbnails)
+                if any(x in img_url.lower() for x in ['favicon', 'icon', 'tracking', 'pixel', 'logo', 'gstatic.com/images/branding', '1x1', 'transparent', 'gstatic.com/images/icons']):
+                    continue
+                if img_url not in images:
+                    images.append(img_url)
+            
+            # Pattern 2: data-src (lazy loaded images)
+            data_src_matches = re.findall(r'data-src="(https?://[^"]+)"', block)
+            for img_url in data_src_matches:
+                img_url = img_url.replace('&amp;', '&')
+                if any(x in img_url.lower() for x in ['favicon', 'icon', 'tracking', 'pixel', 'logo']):
+                    continue
+                if img_url not in images:
+                    images.append(img_url)
+            
+            results.append({
+                "title": title,
+                "url": url,
+                "domain": urllib.parse.urlparse(url).hostname or "",
+                "content": snippet[:1000],
+                "images": images[:3]  # Limit to 3 images per result
+            })
+            
+            if len(results) >= 15:
+                break
+        
+        total_images = sum(len(r.get("images", [])) for r in results)
+        logger.info(f"GoogleEngine parsed {len(results)} results with {total_images} images total.")
+        return results
+    
+    def _should_skip_url(self, url: str) -> bool:
+        """Check if URL should be skipped."""
+        skip_patterns = [
+            "google.com",
+            "googleusercontent.com",
+            "gstatic.com",
+            "youtube.com/watch",  # Keep channel/playlist but skip individual videos
+            "maps.google",
+            "translate.google",
+            "accounts.google",
+            "support.google",
+            "policies.google",
+            "schema.org",
+            "javascript:",
+            "data:",
+            "#",
+        ]
+        
+        for pattern in skip_patterns:
+            if pattern in url.lower():
+                return True
+        
+        # Skip very short URLs (likely invalid)
+        if len(url) < 20:
+            return True
+        
+        # Skip URLs that are just root domains without path
+        parsed = urllib.parse.urlparse(url)
+        if not parsed.path or parsed.path == "/":
+            return True
+            
+        return False

entari_plugin_hyw/browser/service.py

@@ -124,42 +124,71 @@ class ScreenshotService:
             ) or ""
 
             # 2. Extract Images via Parallelized JS (Gallery)
+            # Strategy: For search pages, use Canvas to grab already loaded images (Instant)
+            # For other pages, use fetch (more robust for lazy load)
             images_b64 = []
             try:
-                images_b64 = tab.run_js("""
+                js_code = """
                     (async () => {
                         const blocklist = ['logo', 'icon', 'avatar', 'ad', 'pixel', 'tracker', 'button', 'menu', 'nav'];
                         const candidates = Array.from(document.querySelectorAll('img'));
-                        const validCandidates = candidates.filter(img => {
-                            if (!img.src || img.src.startsWith('data:')) return false;
-                            if (img.naturalWidth < 200 || img.naturalHeight < 150) return false;
-                            const alt = (img.alt || '').toLowerCase();
-                            const cls = (typeof img.className === 'string' ? img.className : '').toLowerCase();
-                            const src = img.src.toLowerCase();
-                            if (blocklist.some(b => alt.includes(b) || cls.includes(b) || src.includes(b))) return false;
-                            return true;
-                        }).slice(0, 10);
-
-                        const fetchImage = async (url) => {
+                        const validImages = [];
+                        
+                        // Helper: Get base64 from loaded image via Canvas
+                        const getBase64 = (img) => {
                             try {
-                                const controller = new AbortController();
-                                const id = setTimeout(() => controller.abort(), 4000);
-                                const resp = await fetch(url, { signal: controller.signal });
-                                clearTimeout(id);
-                                const blob = await resp.blob();
-                                return new Promise(resolve => {
-                                    const reader = new FileReader();
-                                    reader.onloadend = () => resolve(reader.result.split(',')[1]);
-                                    reader.onerror = () => resolve(null);
-                                    reader.readAsDataURL(blob);
-                                });
+                                const canvas = document.createElement('canvas');
+                                canvas.width = img.naturalWidth;
+                                canvas.height = img.naturalHeight;
+                                const ctx = canvas.getContext('2d');
+                                ctx.drawImage(img, 0, 0);
+                                return canvas.toDataURL('image/jpeg').split(',')[1];
                             } catch(e) { return null; }
                         };
 
-                        const results = await Promise.all(validCandidates.map(img => fetchImage(img.src)));
-                        return results.filter(b64 => !!b64);
+                        for (const img of candidates) {
+                            if (validImages.length >= 8) break;
+                            
+                            if (img.naturalWidth < 100 || img.naturalHeight < 80) continue;
+                            
+                            const alt = (img.alt || '').toLowerCase();
+                            const cls = (typeof img.className === 'string' ? img.className : '').toLowerCase();
+                            const src = (img.src || '').toLowerCase();
+                            
+                            if (blocklist.some(b => alt.includes(b) || cls.includes(b) || src.includes(b))) continue;
+                            
+                            // 1. Try Canvas (Instant for loaded images)
+                            if (img.complete && img.naturalHeight > 0) {
+                                const b64 = getBase64(img);
+                                if (b64) {
+                                    validImages.push(b64);
+                                    continue;
+                                }
+                            }
+                            
+                            // 2. Fallback to fetch (only for non-search pages to avoid delay)
+                            // We skip fetch for search pages to ensure speed
+                            if (!window.location.href.includes('google') && !window.location.href.includes('search')) {
+                                try {
+                                    const controller = new AbortController();
+                                    const id = setTimeout(() => controller.abort(), 2000);
+                                    const resp = await fetch(img.src, { signal: controller.signal });
+                                    clearTimeout(id);
+                                    const blob = await resp.blob();
+                                    const b64 = await new Promise(resolve => {
+                                        const reader = new FileReader();
+                                        reader.onloadend = () => resolve(reader.result.split(',')[1]);
+                                        reader.onerror = () => resolve(null);
+                                        reader.readAsDataURL(blob);
+                                    });
+                                    if (b64) validImages.push(b64);
+                                } catch(e) {}
+                            }
+                        }
+                        return validImages;
                     })()
-                """, as_expr=True) or []
+                """
+                images_b64 = tab.run_js(js_code, as_expr=True) or []
                 
                 if images_b64:
                     logger.info(f"ScreenshotService: Extracted {len(images_b64)} images for {url}")

entari_plugin_hyw/definitions.py

@@ -11,7 +11,7 @@ from typing import Dict, Any
 # =============================================================================
 
 INSTRUCT_SP = """你是一个智能 INSTRUCT 助手。
-你的目标是为用户的查询制定调研计划并执行。
+你的目标是为用户的查询制定调研计划并执行
 > 尽量完成所有搜索和获取, 需要的时候可以并发执行多个同种或不同种工具
 
 - 用户消息包含典型名词、可能的专有名词组合: 调用 `web_search` 工具(最大3)。
@@ -22,25 +22,28 @@ INSTRUCT_SP = """你是一个智能 INSTRUCT 助手。
     - 明显的鉴证、国家领导人、历史敏感事件隐喻
     - 过于露骨的r18+、r18g内容(但不包括 galgame等acg向, 除非其过于违规)
 
+## 内容审查
+以下情况调用 `refuse_answer`:
+- 内容涉及隐喻政治事件任务
+- r18+、r18g(但不包含正常galgame、科普等)
+
+## 决定流程
+调用 `set_mode` 决定使用 `fast` 还是 `deepsearch`:
+- 只要用户不明确研究就用 `fast`
+- 用户提到: 深度搜索、深度研究、deepsearch、整理关于...的资料, 这几种情况时, 选择 `deepsearch`
 
 ## 重要规则 (CRITICAL RULES)：
 - 禁止输出任何文本回复：你必须且只能通过工具调用来行动。
-- 禁止回答用户的问题：你的任务仅仅是收集信息，回答将由后续阶段完成。
-- 禁止解释你的行为：不要输出思考过程或计划描述，直接调用工具。
 - 如果没有工具调用，流程将自动结束。
 """
 
-INSTRUCT_REVIEW_SP = """你是一个智能 INSTRUCT 审查助手, 你需要对 INSTRUCT 的输出进行二次信息补充或直接通过(不进行操作)
-
+INSTRUCT_DEEPSEARCH_SP = """你是一个智能 INSTRUCT_DEEPSEARCH 审查助手, 你需要对 INSTRUCT 的输出进行多次信息补充直到信息足够、或达到次数上限(3次)
 
-- 你已经使用过 `web_search` 工具, 不推荐再次使用, 即便你微调搜索词也只能获取重复信息
 - 推荐使用 `crawl_page` 工具查看官方网站、wiki网站(但不推荐维基百科)、权威网站
     - crawl_page 永远不使用国内垃圾网站例如 csdn、知乎、等重复搬运二手信息的网站
     
 ## 重要规则 (CRITICAL RULES)：
 - 禁止输出任何文本回复：你必须且只能通过工具调用来行动。
-- 禁止回答用户的问题：你的任务仅仅是收集信息。
-- 禁止解释你的行为：直接调用所需工具。
 - 如果没有必要进一步操作，请不要输出任何内容（空回复），流程将自动进入下一阶段。
 """
 
@@ -101,7 +104,7 @@ def get_web_search_tool() -> Dict[str, Any]:
     return {
         "type": "function",
         "function": {
-            "name": "internal_web_search",
+            "name": "web_search",
             "description": "网络搜索",
             "parameters": {
                 "type": "object",
@@ -128,3 +131,25 @@ def get_crawl_page_tool() -> Dict[str, Any]:
             },
         },
     }
+
+
+def get_set_mode_tool() -> Dict[str, Any]:
+    """Tool for setting the pipeline mode (fast or deepsearch)."""
+    return {
+        "type": "function",
+        "function": {
+            "name": "set_mode",
+            "description": "设置本次查询的处理模式",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "mode": {
+                        "type": "string",
+                        "enum": ["fast", "deepsearch"],
+                        "description": "fast=快速回答 / deepsearch=深度研究"
+                    },
+                },
+                "required": ["mode"],
+            },
+        },
+    }

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,14 +7,14 @@ 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 .search import SearchService
 
@@ -24,19 +24,20 @@ 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_deepsearch_stage = InstructDeepsearchStage(config, self.search_service, self.client)
         self.summary_stage = SummaryStage(config, self.search_service, self.client)
     
     async def execute(
@@ -60,6 +61,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,
@@ -82,21 +93,33 @@ 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)
-            
-            # 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 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")
             
             # === 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":
+            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"):
@@ -134,17 +157,27 @@ class ModularPipeline:
                     # 3. Update structured response with cached (base64) URLs
                     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
+                            # Keep cached images, but preserve original URLs as fallback
                             new_images = []
                             for img in ref["images"]:
+                                # 1. Already Base64 (from Search Injection) -> Keep it
+                                if img.startswith("data:"):
+                                    new_images.append(img)
+                                    continue
+
+                                # 2. Cached successfully -> Keep it
                                 cached_val = cached_map.get(img)
                                 if cached_val and cached_val.startswith("data:"):
                                     new_images.append(cached_val)
+                                # 3. Else -> DROP IT (User request: "Delete Fallback, must download in advance")
                             ref["images"] = new_images
             except Exception as e:
                 logger.warning(f"Pipeline: Image caching 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)
             
             conversation_history.append({"role": "user", "content": user_input})

entari_plugin_hyw/search.py

@@ -8,7 +8,8 @@ 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
 
 class SearchService:
     def __init__(self, config: Any):
@@ -24,8 +25,13 @@ class SearchService:
         self._engine_name = getattr(config, "search_engine", "bing").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 fallback
+            self._engine = BingEngine()
         
         logger.info(f"SearchService initialized with engine: {self._engine_name}")
 
@@ -40,15 +46,14 @@ class SearchService:
     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}"
 
@@ -60,23 +65,24 @@ class SearchService:
             # Fetch - Search parsing doesn't need screenshot, only HTML
             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)
-
-            # 2. Parse Results
+
+            # Parse Results (skip raw page - only return parsed results)
             if content and not content.startswith("Error"):
                 parsed = self._engine.parse(content)
+
+                # 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}")
                 results.extend(parsed)
             else:

entari_plugin_hyw/stage_base.py

@@ -31,10 +31,14 @@ 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
+    
     def next_id(self) -> int:
         """Get next global ID."""
         self.global_id_counter += 1

entari_plugin_hyw/stage_instruct.py

@@ -17,6 +17,7 @@ from .definitions import (
     get_refuse_answer_tool,
     get_web_search_tool,
     get_crawl_page_tool,
+    get_set_mode_tool,
     INSTRUCT_SP
 )
 
@@ -31,6 +32,7 @@ class InstructStage(BaseStage):
         self.refuse_answer_tool = get_refuse_answer_tool()
         self.web_search_tool = get_web_search_tool()
         self.crawl_page_tool = get_crawl_page_tool()
+        self.set_mode_tool = get_set_mode_tool()
     
     async def execute(self, context: StageContext) -> StageResult:
         start_time = time.time()
@@ -48,7 +50,7 @@ class InstructStage(BaseStage):
         # Execute Round 1 LLM
         r1_response, r1_usage, r1_tool_calls, r1_content = await self._call_llm(
             messages=r1_messages,
-            tools=[self.refuse_answer_tool, self.web_search_tool, self.crawl_page_tool],
+            tools=[self.refuse_answer_tool, self.web_search_tool, self.crawl_page_tool, self.set_mode_tool],
             tool_choice="auto"
         )
         
@@ -167,7 +169,7 @@ class InstructStage(BaseStage):
                      "id": tc_id, "name": name, "content": f"Refused: {reason}"
                 })
             
-            elif name == "internal_web_search":
+            elif name == "web_search":
                 query = args.get("query")
                 if query: 
                     logger.info(f"Instruct: Planned search query -> '{query}'")
@@ -178,6 +180,18 @@ class InstructStage(BaseStage):
                 if url: 
                     logger.info(f"Instruct: Planned page crawl -> {url}")
                     pending_crawls.append((url, tc_id))
+            
+            elif name == "set_mode":
+                mode = args.get("mode", "fast")
+                if mode in ("fast", "deepsearch"):
+                    context.selected_mode = mode
+                    logger.info(f"Instruct: Mode set to '{mode}'")
+                    results_for_context.append({
+                        "id": tc_id, "name": name, "content": f"Mode set to: {mode}"
+                    })
+                else:
+                    logger.warning(f"Instruct: Invalid mode '{mode}', defaulting to 'fast'")
+                    context.selected_mode = "fast"
         
         # Execute Batches
         
@@ -189,7 +203,8 @@ class InstructStage(BaseStage):
             # Start fetch
             fetch_task = asyncio.create_task(self.search_service.fetch_pages_batch(urls))
             
-            is_image_mode = getattr(self.config, "page_content_mode", "text") == "image"
+            # Use image capability from context to determine content mode
+            is_image_mode = getattr(context, "image_input_supported", True)
             tab_ids = []
             if is_image_mode:
                 from .render_vue import get_content_renderer
@@ -285,6 +300,8 @@ class InstructStage(BaseStage):
                 visible_results = [r for r in web_results if not r.get("_hidden")]
                 
                 # Update global context
+                total_images = sum(len(item.get("images", []) or []) for item in web_results)
+                logger.debug(f"Instruct: Search '{query}' returned {len(web_results)} items with {total_images} images total")
                 for item in web_results:
                     item["_id"] = context.next_id()
                     if "type" in item:
@@ -301,7 +318,7 @@ class InstructStage(BaseStage):
                 
                 results_for_context.append({
                      "id": tc_id, 
-                     "name": "internal_web_search", 
+                     "name": "web_search", 
                      "content": summary
                 })
                 

entari_plugin_hyw/stage_instruct_deepsearch.py

@@ -0,0 +1,104 @@
+"""
+Instruct Deepsearch Stage
+
+Handles the deepsearch loop: Supplement information until sufficient or max iterations reached.
+Inherits from InstructStage to reuse tool execution logic.
+"""
+
+import time
+from typing import Any, List
+from loguru import logger
+from openai import AsyncOpenAI
+
+from .stage_base import StageContext, StageResult
+from .stage_instruct import InstructStage
+from .definitions import INSTRUCT_DEEPSEARCH_SP
+
+class InstructDeepsearchStage(InstructStage):
+    @property
+    def name(self) -> str:
+        return "Instruct Deepsearch"
+    
+    def __init__(self, config: Any, search_service: Any, client: AsyncOpenAI):
+        super().__init__(config, search_service, client)
+        # Inherits tools from InstructStage (web_search, crawl_page)
+    
+    async def execute(self, context: StageContext) -> StageResult:
+        start_time = time.time()
+        logger.info("Instruct Deepsearch: Starting supplementary research")
+        
+        # Check if we have context to review
+        if not context.review_context:
+            logger.warning("Instruct Deepsearch: No context found. Skipping.")
+            return StageResult(
+                success=True, 
+                data={"reasoning": "Skipped due to missing context.", "should_stop": True}
+            )
+            
+        # Build System Prompt (Clean)
+        system_prompt = INSTRUCT_DEEPSEARCH_SP
+        
+        # Build Messages
+        # Inject context as a separate user message explaining the background
+        context_message = f"## 已收集的信息\n\n```context\n{context.review_context}\n```"
+        
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": context_message},
+            {"role": "user", "content": self._build_user_message(context)}
+        ]
+        
+        # Call LLM
+        # We use only web_search and crawl_page tools (no set_mode, no refuse_answer in this stage)
+        tools = [self.web_search_tool, self.crawl_page_tool]
+        
+        response, usage, tool_calls, content = await self._call_llm(
+            messages=messages,
+            tools=tools,
+            tool_choice="auto"
+        )
+        
+        # Check for empty response = signal to stop
+        should_stop = False
+        if not tool_calls or len(tool_calls) == 0:
+            logger.info("Instruct Deepsearch: No tool calls, signaling to stop loop.")
+            should_stop = True
+        else:
+            # Execute Tools
+            tool_outputs = await self._process_tool_calls(context, tool_calls)
+            
+            # Update context for next iteration
+            iteration_summary = f"\n## Deepsearch Iteration\n"
+            if content:
+                iteration_summary += f"Thought: {content}\n"
+            for output in tool_outputs:
+                iteration_summary += f"- {output['name']}: {output['content'][:200]}...\n"
+            context.review_context += iteration_summary
+            
+            # Update history
+            context.instruct_history.append({
+                "role": "assistant",
+                "content": f"[Deepsearch]: {content}\n[Actions]: {len(tool_outputs)} tools"
+            })
+        
+        return self._build_result(start_time, usage, content, len(tool_calls or []), should_stop)
+
+    def _build_result(self, start_time, usage, content, tool_calls_count, should_stop=False):
+        model_cfg = self.config.get_model_config("instruct")
+        model = model_cfg.get("model_name") or self.config.model_name
+
+        trace = {
+            "stage": "Instruct Deepsearch",
+            "model": model, 
+            "usage": usage,
+            "output": content,
+            "tool_calls": tool_calls_count,
+            "time": time.time() - start_time,
+        }
+        
+        return StageResult(
+            success=True,
+            data={"reasoning": content, "should_stop": should_stop},
+            usage=usage,
+            trace=trace
+        )

{entari_plugin_hyw-4.0.0rc5.dist-info → entari_plugin_hyw-4.0.0rc6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: entari_plugin_hyw
-Version: 4.0.0rc5
+Version: 4.0.0rc6
 Summary: Use large language models to interpret chat messages
 Author-email: kumoSleeping <zjr2992@outlook.com>
 License: MIT

{entari_plugin_hyw-4.0.0rc5.dist-info → entari_plugin_hyw-4.0.0rc6.dist-info}/RECORD

@@ -1,14 +1,14 @@
-entari_plugin_hyw/__init__.py,sha256=502FHKMiXsq7RoOfQs1RiY6B9-1JMnT1caDGCy3mxDU,20073
-entari_plugin_hyw/definitions.py,sha256=QKvhk8q6Wa22QlF72HsoikbdNxfveoZJR71zpkxTiLQ,5912
+entari_plugin_hyw/__init__.py,sha256=t-TAqOaghlzVtoSuMfQoiqdA8wrfB7Riofqp3EpGQPU,21844
+entari_plugin_hyw/definitions.py,sha256=sRgNkmzD-XDSbRM2nVQP14WGpMoFrzr9C-cc6xmShDA,6570
 entari_plugin_hyw/history.py,sha256=6d1e8DPfv4XQyM9hMjrx08_WKrxqVSJEvSIGRX4JOB0,11085
 entari_plugin_hyw/image_cache.py,sha256=t8pr1kgH2ngK9IhrBAhzUqhBWERNztUywMzgCFZEtQk,9899
-entari_plugin_hyw/misc.py,sha256=b0KPCUrf1GuCY0Mx29Sn5sREg1fxR1OyYEl4O4Omsys,4553
-entari_plugin_hyw/modular_pipeline.py,sha256=QjuvmM6d1fYudyzK3a7tlZS24zpUlFRwo21Skn_gVW0,14798
+entari_plugin_hyw/misc.py,sha256=ZGDXeXbSugG4tRrBfUDVd94i2SCaPOmaGtVmPz8mqtY,5413
+entari_plugin_hyw/modular_pipeline.py,sha256=-p2Z4oUij-G4sCdf2SeHNm89NlVTYHuU91vUIz9R-IM,16867
 entari_plugin_hyw/render_vue.py,sha256=4i5xTZCb9amPgSWo6f7Ev279ZOk-D8Kfmxe2HdcA_vI,14737
-entari_plugin_hyw/search.py,sha256=oAC9vmpSBwvOHkf4mBSqgvN5W9USsJT5Znubn41llYk,4826
-entari_plugin_hyw/stage_base.py,sha256=-A8CArfnL7eDaLv-DCv-mjtSkMrdowlHq0w_gg8btQ4,2625
-entari_plugin_hyw/stage_instruct.py,sha256=7b_3vGB1KQ7Ek3l55_OmLgVgARXYDHcVqWYWVBPo4tg,13676
-entari_plugin_hyw/stage_instruct_review.py,sha256=e0yblVnEI-11dwZ-H5ydctx9O5PejYLNpkGWyHc1M1s,3392
+entari_plugin_hyw/search.py,sha256=2Rnc6iYIzPEFH7NtSR0Pi0eXFH-EqIia7Kh3txWmD8U,5262
+entari_plugin_hyw/stage_base.py,sha256=wNotYPl8LElk-1Yf8NB2OvFeGSV2UGW9uEmlY4QmxzA,2752
+entari_plugin_hyw/stage_instruct.py,sha256=2vMLfA7lVRqaPdf9szBfsN7sTAALmkNUsMyUL7tjmGA,14620
+entari_plugin_hyw/stage_instruct_deepsearch.py,sha256=_I_xZ-M1xovM4I7NL5eyc21Wg9xdFKnJDQVQActTjUI,3969
 entari_plugin_hyw/stage_summary.py,sha256=1g1tL7alHbDdp6Mrq2HrXD8k65VMOL-zdyo3bWAS5RQ,5736
 entari_plugin_hyw/assets/card-dist/index.html,sha256=s_RU1rCFowRwFMTuIiUsyGp25WfsIyk-XNWyD9jYqVc,2204580
 entari_plugin_hyw/assets/card-dist/vite.svg,sha256=SnSK_UQ5GLsWWRyDTEAdrjPoeGGrXbrQgRw6O0qSFPs,1497
@@ -51,10 +51,11 @@ entari_plugin_hyw/assets/icon/zai.png,sha256=K-gnabdsjMLInppHA1Op7Nyt33iegrx1x-y
 entari_plugin_hyw/browser/__init__.py,sha256=Cht-i5MowfAdmfW3kiY4sV7oXKDb-DmhZ-_eKwDl6r0,321
 entari_plugin_hyw/browser/landing.html,sha256=wgqldumdylz69T83pvOkrigT1Mdb9GY0_KU0ceLGwdY,4642
 entari_plugin_hyw/browser/manager.py,sha256=9VuTyXBr1QBcTV8Nj2vSrozstMmNxAytXESUQ6vxLrM,5234
-entari_plugin_hyw/browser/service.py,sha256=ekrHDEWesDZw2PLex9bGL6SMYxfElxEOAxIegRu_zEo,12013
+entari_plugin_hyw/browser/service.py,sha256=8PihWOdyJcBV1_2lp3PRmmcgXYFN3uryqs5rE9E5a9M,13647
 entari_plugin_hyw/browser/engines/base.py,sha256=q5y4SM1G6xS7-6TQ-nZz9iTWw3XonjJn01fWzoTxr6c,414
 entari_plugin_hyw/browser/engines/bing.py,sha256=rIWcvjzvm700xji_OBl6COUAtwXg87DcXQ97DlTzleA,3838
-entari_plugin_hyw/browser/engines/searxng.py,sha256=m58Vzj807-70mT4j63SjzGijS85-O06l-Mmd3M-sd7Y,5152
+entari_plugin_hyw/browser/engines/duckduckgo.py,sha256=jlCIXR1mpJ0LjSbuHMYNGMYjHiQ9Lw_x-A8242Zajgo,5154
+entari_plugin_hyw/browser/engines/google.py,sha256=vCtyOxr63F40hDMW70sS1CyoMsqc0HzyESYrK_qcZLg,6091
 entari_plugin_hyw/card-ui/.gitignore,sha256=_nGOe6uxTzy60tl_CIibnOUhXtP-DkOyuM-_s7m4ROg,253
 entari_plugin_hyw/card-ui/README.md,sha256=fN9IawCcxEcJ8LM-RfKiAH835fRqyY_iqrRsgSkxiSk,442
 entari_plugin_hyw/card-ui/index.html,sha256=Hd7vk8v8PtATbfiEWLYoKDpUT0dlyozW_K5gR_cObfo,328
@@ -93,7 +94,7 @@ entari_plugin_hyw/card-ui/src/components/HelloWorld.vue,sha256=yvBIzJua9BfikUOR1
 entari_plugin_hyw/card-ui/src/components/MarkdownContent.vue,sha256=SV95Vuj99tQN2yrU9GqiyhiemWAW8omhYnS8AsH1YIU,13325
 entari_plugin_hyw/card-ui/src/components/SectionCard.vue,sha256=owcDNx2JYVmF2J5SYCroR2gvg_cPApQsNunjK1WJpVI,1433
 entari_plugin_hyw/card-ui/src/components/StageCard.vue,sha256=MgpOaBlPR--LJoRenN37i72BV8qVgzDdurpoKCvzKyk,11133
-entari_plugin_hyw-4.0.0rc5.dist-info/METADATA,sha256=oe3M_DRBIEBJu8n90HXBsK7CuwahB8DanrFdx2MO7bA,3766
-entari_plugin_hyw-4.0.0rc5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-entari_plugin_hyw-4.0.0rc5.dist-info/top_level.txt,sha256=TIDsn6XPs6KA5e3ezsE65JoXsy03ejDdrB41I4SPjmo,18
-entari_plugin_hyw-4.0.0rc5.dist-info/RECORD,,
+entari_plugin_hyw-4.0.0rc6.dist-info/METADATA,sha256=ODqjgpaG9PeWasK1FlsQ5E39DxvyyC7nVy4WMy_HcUk,3766
+entari_plugin_hyw-4.0.0rc6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+entari_plugin_hyw-4.0.0rc6.dist-info/top_level.txt,sha256=TIDsn6XPs6KA5e3ezsE65JoXsy03ejDdrB41I4SPjmo,18
+entari_plugin_hyw-4.0.0rc6.dist-info/RECORD,,

entari_plugin_hyw/stage_instruct_review.py

@@ -1,92 +0,0 @@
-"""
-Instruct Review Stage
-
-Handles the second round of instruction: Review and Refine.
-Inherits from InstructStage to reuse tool execution logic.
-"""
-
-import time
-from typing import Any, List
-from loguru import logger
-from openai import AsyncOpenAI
-
-from .stage_base import StageContext, StageResult
-from .stage_instruct import InstructStage
-from .definitions import INSTRUCT_REVIEW_SP
-
-class InstructReviewStage(InstructStage):
-    @property
-    def name(self) -> str:
-        return "Instruct Review"
-    
-    def __init__(self, config: Any, search_service: Any, client: AsyncOpenAI):
-        super().__init__(config, search_service, client)
-        # Inherits tools from InstructStage
-    
-    async def execute(self, context: StageContext) -> StageResult:
-        start_time = time.time()
-        logger.info("Instruct Review: Starting Round 2 (Review & Refine)")
-        
-        # Check if we have context to review
-        if not context.review_context:
-            logger.warning("Instruct Review: No context found from Round 1. Skipping.")
-            return StageResult(success=True, data={"reasoning": "Skipped due to missing context."})
-            
-        # Build System Prompt (Clean)
-        system_prompt = INSTRUCT_REVIEW_SP
-        
-        # Build Messages
-        # Inject context as a separate user message explaining the background
-        context_message = f"## Previous Round Context\n\n```context\n{context.review_context}\n```"
-        
-        messages = [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": context_message},
-            {"role": "user", "content": self._build_user_message(context)}
-        ]
-        
-        # Call LLM
-        # We reuse _call_llm from parent
-        # We reuse tools from parent (refuse_answer might be redundant but harmless, or we can filter)
-        tools = [self.web_search_tool, self.crawl_page_tool] # Review prompt doesn't mention refuse_answer explicitly, but usually fine.
-        
-        response, usage, tool_calls, content = await self._call_llm(
-            messages=messages,
-            tools=tools,
-            tool_choice="auto"
-        )
-        
-        # Execute Tools
-        tool_outputs = []
-        if tool_calls:
-            tool_outputs = await self._process_tool_calls(context, tool_calls)
-            
-        # Update history logic? 
-        # The prompt says "上下文". It is "independent". 
-        # But for the record, we might want to log it.
-        context.instruct_history.append({
-             "role": "assistant",
-             "content": f"[Round 2 Review]: {content}\n[Round 2 Actions]: {len(tool_outputs)} tools"
-        })
-        
-        return self._build_result(start_time, usage, content, len(tool_calls or []))
-
-    def _build_result(self, start_time, usage, content, tool_calls_count):
-        model_cfg = self.config.get_model_config("instruct")
-        model = model_cfg.get("model_name") or self.config.model_name
-
-        trace = {
-            "stage": "Instruct Review",
-            "model": model, 
-            "usage": usage,
-            "output": content,
-            "tool_calls": tool_calls_count,
-            "time": time.time() - start_time,
-        }
-        
-        return StageResult(
-            success=True,
-            data={"reasoning": content},
-            usage=usage,
-            trace=trace
-        )