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

entari_plugin_hyw/browser/service.py

@@ -6,6 +6,8 @@ Provides page fetching and screenshot capabilities using DrissionPage.
 
 import asyncio
 import base64
+import threading
+import time
 from concurrent.futures import ThreadPoolExecutor
 from typing import Optional, Dict, Any, List
 from loguru import logger
@@ -20,16 +22,182 @@ class ScreenshotService:
         self.headless = headless
         self._manager = None
         self._executor = ThreadPoolExecutor(max_workers=10)
+        self._search_tab_pool = []  # List of Tab objects
+        self._pool_lock = threading.Lock()
         
         if auto_start:
             self._ensure_ready()
+            
+    def prepare_search_tabs_background(self, count: int, url: str = "https://www.google.com") -> None:
+        """
+        Pre-launch tabs for search (BACKGROUND - fire and forget).
+        Tabs are created in background thread, may not be ready immediately.
+        """
+        self._executor.submit(self._prepare_search_tabs_sync, count, url)
+
+    def _prepare_search_tabs_sync(self, count: int, url: str = "https://www.google.com"):
+        """Sync implementation of tab preparation - creates tabs in PARALLEL."""
+        try:
+            self._ensure_ready()
+            page = self._manager.page
+            if not page: return
+            
+            with self._pool_lock:
+                current_count = len(self._search_tab_pool)
+                needed = count - current_count
+            
+            if needed <= 0:
+                return
+                
+            logger.info(f"ScreenshotService: Pre-launching {needed} search tabs for {url} (parallel)...")
+            
+            # Create tabs in parallel using threads
+            created_tabs = [None] * needed
+            
+            def create_single_tab(index):
+                try:
+                    tab = page.new_tab(url)
+                    created_tabs[index] = tab
+                    logger.debug(f"ScreenshotService: Tab {index} ready")
+                except Exception as e:
+                    logger.error(f"ScreenshotService: Failed to create tab {index}: {e}")
+            
+            threads = []
+            for i in range(needed):
+                t = threading.Thread(target=create_single_tab, args=(i,))
+                t.start()
+                threads.append(t)
+            
+            # Wait for all threads to complete
+            for t in threads:
+                t.join()
+            
+            # Add successfully created tabs to pool
+            with self._pool_lock:
+                for tab in created_tabs:
+                    if tab:
+                        self._search_tab_pool.append(tab)
+                logger.info(f"ScreenshotService: Tab pool ready ({len(self._search_tab_pool)} tabs)")
+                
+        except Exception as e:
+            logger.error(f"ScreenshotService: Failed to prepare tabs: {e}")
+
+    async def search_via_page_input_batch(self, queries: List[str], url: str, selector: str = "#input") -> List[Dict[str, Any]]:
+        """
+        Execute concurrent searches using page inputs.
+        """
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            self._executor,
+            self._search_via_page_input_batch_sync,
+            queries, url, selector
+        )
+
+    def _search_via_page_input_batch_sync(self, queries: List[str], url: str, selector: str) -> List[Dict[str, Any]]:
+        """Sync batch execution - create tabs sequentially, search in parallel."""
+        results = [None] * len(queries)
+        tabs = []
+        
+        # Phase 1: Get/create tabs SEQUENTIALLY (DrissionPage isn't thread-safe for new_tab)
+        target_url = url or "https://www.google.com"
+        logger.info(f"ScreenshotService: Acquiring {len(queries)} tabs for parallel search...")
+        
+        for i in range(len(queries)):
+            tab = None
+            # Try to get from pool first
+            with self._pool_lock:
+                if self._search_tab_pool:
+                    tab = self._search_tab_pool.pop(0)
+                    logger.debug(f"ScreenshotService: Got tab {i} from pool")
+            
+            if not tab:
+                # Create new
+                self._ensure_ready()
+                tab = self._manager.page.new_tab(target_url)
+                logger.debug(f"ScreenshotService: Created tab {i} for {target_url}")
+            
+            tabs.append(tab)
+        
+        logger.info(f"ScreenshotService: {len(tabs)} tabs ready, starting parallel searches...")
+        
+        # Phase 2: Execute searches in PARALLEL
+        def run_search(index, tab, query):
+            try:
+                logger.debug(f"Search[{index}]: Starting for '{query}' on {tab.url}")
+                
+                # Wait for page to be ready first
+                try:
+                    tab.wait.doc_loaded(timeout=10)
+                except:
+                    pass
+                
+                # Find input element with wait
+                logger.debug(f"Search[{index}]: Looking for input with selector '{selector}'")
+                ele = tab.ele(selector, timeout=5)
+                if not ele:
+                    logger.debug(f"Search[{index}]: Primary selector failed, trying fallbacks")
+                    for fallback in ["textarea[name='q']", "#APjFqb", "input[name='q']", "input[type='text']"]:
+                        ele = tab.ele(fallback, timeout=2)
+                        if ele:
+                            logger.debug(f"Search[{index}]: Found input with fallback '{fallback}'")
+                            break
+                
+                if not ele:
+                    logger.error(f"Search[{index}]: No input element found on {tab.url}!")
+                    results[index] = {"content": "Error: input not found", "title": "Error", "url": tab.url, "html": tab.html[:5000]}
+                    return
+
+                logger.debug(f"Search[{index}]: Typing query...")
+                ele.input(query)
+                
+                logger.debug(f"Search[{index}]: Pressing Enter...")
+                tab.actions.key_down('enter').key_up('enter')
+                
+                logger.debug(f"Search[{index}]: Waiting for search results...")
+                tab.wait.doc_loaded(timeout=10)
+                time.sleep(0.5)
+                
+                logger.debug(f"Search[{index}]: Extracting content...")
+                html = tab.html
+                content = trafilatura.extract(
+                    html, include_links=True, include_images=True, include_comments=False,
+                    include_tables=True, favor_precision=False, output_format="markdown"
+                ) or ""
+                
+                logger.info(f"ScreenshotService: Search '{query}' completed -> {tab.url}")
+                
+                results[index] = {
+                    "content": content,
+                    "html": html,
+                    "title": tab.title,
+                    "url": tab.url,
+                    "images": []
+                }
+                
+            except Exception as e:
+                logger.error(f"ScreenshotService: Search error for '{query}': {e}")
+                results[index] = {"content": f"Error: {e}", "title": "Error", "url": "", "html": ""}
+            finally:
+                try: tab.close()
+                except: pass
+
+        threads = []
+        for i, (tab, query) in enumerate(zip(tabs, queries)):
+            t = threading.Thread(target=run_search, args=(i, tab, query))
+            t.start()
+            threads.append(t)
+        
+        for t in threads:
+            t.join()
+            
+        return results
     
     def _ensure_ready(self):
         """Ensure shared browser is ready."""
         from .manager import get_shared_browser_manager
         self._manager = get_shared_browser_manager(headless=self.headless)
 
-    async def fetch_page(self, url: str, timeout: float = 20.0, include_screenshot: bool = True) -> Dict[str, Any]:
+    async def fetch_page(self, url: str, timeout: float = 10.0, include_screenshot: bool = True) -> Dict[str, Any]:
         """
         Fetch page content (and optionally screenshot).
         Runs in a thread executor to avoid blocking the async loop.
@@ -43,6 +211,87 @@ class ScreenshotService:
             include_screenshot
         )
 
+    async def search_via_address_bar(self, query: str, timeout: float = 20.0) -> Dict[str, Any]:
+        """
+        Search using browser's address bar (uses browser's default search engine).
+        Simulates: Ctrl+L (focus address bar) -> type query -> Enter
+        """
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            self._executor,
+            self._search_via_address_bar_sync,
+            query,
+            timeout
+        )
+    
+    def _search_via_address_bar_sync(self, query: str, timeout: float) -> Dict[str, Any]:
+        """Synchronous address bar search logic."""
+        if not query:
+            return {"content": "Error: missing query", "title": "Error", "url": "", "html": ""}
+        
+        tab = None
+        try:
+            self._ensure_ready()
+            page = self._manager.page
+            if not page:
+                return {"content": "Error: Browser not available", "title": "Error", "url": "", "html": ""}
+            
+            # Open new blank tab
+            tab = page.new_tab()
+            
+            # Focus address bar with Ctrl+L (or Cmd+L on Mac)
+            import platform
+            if platform.system() == "Darwin":
+                tab.actions.key_down('cmd').key_down('l').key_up('l').key_up('cmd')
+            else:
+                tab.actions.key_down('ctrl').key_down('l').key_up('l').key_up('ctrl')
+            
+            # Small delay for address bar to focus
+            import time as _time
+            _time.sleep(0.1)
+            
+            # Type the query
+            tab.actions.type(query)
+            
+            # Press Enter to search
+            tab.actions.key_down('enter').key_up('enter')
+            
+            # Wait for page to load
+            try:
+                tab.wait.doc_loaded(timeout=timeout)
+                # Additional wait for search results
+                _time.sleep(1)
+            except:
+                pass
+            
+            html = tab.html
+            title = tab.title
+            final_url = tab.url
+            
+            # Extract content
+            content = trafilatura.extract(
+                html, include_links=True, include_images=True, include_comments=False,
+                include_tables=True, favor_precision=False, output_format="markdown"
+            ) or ""
+            
+            logger.info(f"ScreenshotService: Address bar search completed -> {final_url}")
+            
+            return {
+                "content": content,
+                "html": html,
+                "title": title,
+                "url": final_url,
+                "images": []
+            }
+            
+        except Exception as e:
+            logger.error(f"ScreenshotService: Address bar search failed: {e}")
+            return {"content": f"Error: search failed ({e})", "title": "Error", "url": "", "html": ""}
+        finally:
+            if tab:
+                try: tab.close()
+                except: pass
+
     def _fetch_page_sync(self, url: str, timeout: float, include_screenshot: bool) -> Dict[str, Any]:
         """Synchronous fetch logic."""
         if not url:
@@ -55,39 +304,31 @@ class ScreenshotService:
             if not page:
                 return {"content": "Error: Browser not available", "title": "Error", "url": url}
             
-            # New Tab
+            # New Tab with URL directly
             tab = page.new_tab(url)
             
-            # Wait logic
+            # Wait logic - optimized for search pages
             is_search_page = any(s in url.lower() for s in ['search', 'bing.com', 'duckduckgo', 'google.com/search', 'searx'])
             if is_search_page:
-                # Quick check for results
-                result_selectors = ['#results', '#b_results', '#search', '#links', '.result']
-                for selector in result_selectors:
-                    if tab.ele(selector, timeout=1):
-                        break
+                # Optimized waiting for search engine results
+                try:
+                    # Google uses #search or #rso
+                    # DuckDuckGo uses #react-layout
+                    # Bing uses #b_results
+                    if 'google' in url.lower():
+                        # Wait for results container (fastest possible return)
+                        tab.ele('#search', timeout=timeout)
+                    elif 'bing' in url.lower():
+                        tab.ele('#b_results', timeout=timeout)
+                    else:
+                        # Generic search fallback
+                        tab.wait.doc_loaded(timeout=timeout)
+                except:
+                    pass
             else:
                 # 1. Wait for document to settle (Fast Dynamic Wait)
                 try:
-                    tab.wait.doc_loaded(timeout=5)
-                    # Brief check for loading overlays (fast skip if none)
-                    tab.run_js("""
-                        (async () => {
-                            const isVisible = (el) => !!(el.offsetWidth || el.offsetHeight || el.getClientRects().length);
-                            for (let i = 0; i < 15; i++) {
-                                const indicators = Array.from(document.querySelectorAll('*')).filter(el => {
-                                    try {
-                                        const text = (el.textContent || '').toLowerCase();
-                                        const id = (el.id || '').toLowerCase();
-                                        const cls = (el.getAttribute('class') || '').toLowerCase();
-                                        return (text.includes('loading') || id.includes('loading') || cls.includes('loading')) && isVisible(el);
-                                    } catch(e) { return false; }
-                                });
-                                if (indicators.length === 0) break;
-                                await new Promise(r => setTimeout(r, 100));
-                            }
-                        })()
-                    """, as_expr=True)
+                    tab.wait.doc_loaded(timeout=timeout)
                 except: pass
 
             html = tab.html
@@ -124,42 +365,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/card-ui/src/App.vue

@@ -237,6 +237,8 @@ const instructStage = computed(() => {
   }
 })
 
+const visionStage = computed(() => data.value?.stages?.find(s => s.name === 'Vision'))
+
 const summaryStage = computed(() => data.value?.stages?.find(s => s.name?.toLowerCase() === 'summary' || s.name?.toLowerCase() === 'agent'))
 // searchStage removed - no longer needed for display
 
@@ -654,7 +656,7 @@ The system automatically handles citations like [1] and [2], reordering them dyn
         </div>
 
         <!-- Flow: Unified Stage Info Area -->
-        <div v-if="instructStage || summaryStage" class="relative group/flow">
+        <div v-if="instructStage || summaryStage || visionStage" class="relative group/flow">
             <!-- Corner Badge -->
             <div 
               class="absolute -top-2 -left-2 h-7 px-2.5 z-10 flex items-center justify-center gap-1.5"
@@ -668,6 +670,35 @@ The system automatically handles citations like [1] and [2], reordering them dyn
             <div class="shadow-sm shadow-black/5 bg-white pt-8 px-6 pb-8">
               <div class="space-y-8 relative">
 
+                <!-- Vision Stage -->
+                <div v-if="visionStage" class="relative flex items-start gap-4 z-10 w-full">
+                  <!-- Node: Brand Logo -->
+                  <div class="shrink-0 w-6 h-6 flex items-center justify-center bg-white">
+                     <img :src="getIconPath(visionStage)" class="w-5 h-5 object-contain" alt="" />
+                  </div>
+                  <!-- Content -->
+                  <div class="flex-1 min-w-0 pt-1">
+                    <div class="text-[17px] font-bold uppercase tracking-tight mb-1.5 leading-none" style="color: var(--text-primary)">Vision</div>
+                    <div class="flex items-center justify-between gap-x-4 text-[13px] font-mono leading-tight w-full" style="color: var(--text-muted)">
+                      <!-- Model Name (Truncated) -->
+                      <span class="truncate max-w-[180px]" :title="visionStage.model">{{ visionStage.model }}</span>
+                      
+                      <!-- Metrics -->
+                      <div class="flex items-center gap-4 shrink-0">
+                        <div class="flex items-center gap-1.5 opacity-80">
+                          <Icon icon="mdi:clock-outline" class="text-[13px]" />
+                          <span>{{ (visionStage.time || 0).toFixed(2) }}s</span>
+                        </div>
+                        <template v-if="visionStage.cost">
+                          <div class="flex items-center gap-0.5 opacity-80">
+                            <span>${{ visionStage.cost.toFixed(5) }}</span>
+                          </div>
+                        </template>
+                      </div>
+                    </div>
+                  </div>
+                </div>
+
                 <!-- Instruct Stage -->
                 <div v-if="instructStage" class="relative flex items-start gap-4 z-10 w-full">
                   <!-- Node: Brand Logo -->

entari_plugin_hyw/definitions.py

@@ -11,10 +11,10 @@ from typing import Dict, Any
 # =============================================================================
 
 INSTRUCT_SP = """你是一个智能 INSTRUCT 助手。
-你的目标是为用户的查询制定调研计划并执行。
+你的目标是立即, 为用户的查询制定调研计划并执行
 > 尽量完成所有搜索和获取, 需要的时候可以并发执行多个同种或不同种工具
 
-- 用户消息包含典型名词、可能的专有名词组合: 调用 `web_search` 工具(最大3)。
+- 用户消息包含典型名词、可能的专有名词组合: 调用 `web_search` 工具(最大3, 推荐1)。
     - 提炼消息中出独立的关键词搜索关键词本身, 不添加任何其他辅助搜索词, 搜索效果最好
     - 不混合搜索词, 每次只针对搜索一个关键词, 获取其目的方向的最新数据
 - 用户消息中出现链接时, 调用 `crawl_page`(最大3) 获取网页全文
@@ -22,25 +22,31 @@ 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 的输出进行二次信息补充或直接通过(不进行操作)
+## now
+请快速给出回复.
+"""
 
+INSTRUCT_DEEPSEARCH_SP = """你是一个智能 INSTRUCT_DEEPSEARCH 审查助手, 你需要对 INSTRUCT 的输出进行多次信息补充直到信息足够、或达到次数上限(3次)
 
-- 你已经使用过 `web_search` 工具, 不推荐再次使用, 即便你微调搜索词也只能获取重复信息
 - 推荐使用 `crawl_page` 工具查看官方网站、wiki网站(但不推荐维基百科)、权威网站
     - crawl_page 永远不使用国内垃圾网站例如 csdn、知乎、等重复搬运二手信息的网站
     
 ## 重要规则 (CRITICAL RULES)：
 - 禁止输出任何文本回复：你必须且只能通过工具调用来行动。
-- 禁止回答用户的问题：你的任务仅仅是收集信息。
-- 禁止解释你的行为：直接调用所需工具。
 - 如果没有必要进一步操作，请不要输出任何内容（空回复），流程将自动进入下一阶段。
 """
 
@@ -74,6 +80,22 @@ SUMMARY_REPORT_SP = """# 你是一个信息整合专家 (Summary Agent).
 """
 
 
+# =============================================================================
+# VISION DESCRIPTION PROMPT
+# =============================================================================
+
+VISION_DESCRIPTION_SP = """你是一个图像描述专家。
+根据用户发送的图片和文字，快速描述图片中的内容。
+
+要求：
+- 客观描述图片中的主要元素、场景、人物、文字等
+- 如果图片包含文字，请完整转录
+- 如果用户有具体问题，围绕问题描述相关细节
+- 描述应该简洁但信息丰富，控制在 300 字以内
+- 使用用户的语言回复
+"""
+
+
 # =============================================================================
 # TOOL DEFINITIONS
 # =============================================================================
@@ -101,8 +123,8 @@ def get_web_search_tool() -> Dict[str, Any]:
     return {
         "type": "function",
         "function": {
-            "name": "internal_web_search",
-            "description": "网络搜索",
+            "name": "web_search",
+            "description": "网络搜索, 只容许输入正常的字符串查询, 禁止高级搜索",
             "parameters": {
                 "type": "object",
                 "properties": {"query": {"type": "string"}},
@@ -128,3 +150,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"],
+            },
+        },
+    }