entari-plugin-hyw 4.0.0rc5__tar.gz → 4.0.0rc6__tar.gz

{entari_plugin_hyw-4.0.0rc5/src/entari_plugin_hyw.egg-info → entari_plugin_hyw-4.0.0rc6}/PKG-INFO

@@ -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 → entari_plugin_hyw-4.0.0rc6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "entari_plugin_hyw"
-version = "4.0.0-rc5"
+version = "4.0.0-rc6"
 description = "Use large language models to interpret chat messages"
 authors = [{name = "kumoSleeping", email = "zjr2992@outlook.com"}]
 dependencies = [

{entari_plugin_hyw-4.0.0rc5 → entari_plugin_hyw-4.0.0rc6}/src/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-4.0.0rc5/src/entari_plugin_hyw/browser/engines/searxng.py → entari_plugin_hyw-4.0.0rc6/src/entari_plugin_hyw/browser/engines/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-4.0.0rc6/src/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-4.0.0rc5 → entari_plugin_hyw-4.0.0rc6}/src/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-4.0.0rc5 → entari_plugin_hyw-4.0.0rc6}/src/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-4.0.0rc5 → entari_plugin_hyw-4.0.0rc6}/src/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-4.0.0rc5 → entari_plugin_hyw-4.0.0rc6}/src/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})