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

entari_plugin_hyw/browser/engines/default.py

@@ -0,0 +1,166 @@
+
+import urllib.parse
+import re
+from typing import List, Dict, Any
+from loguru import logger
+from .base import SearchEngine
+
+
+class DefaultEngine(SearchEngine):
+    """
+    Default browser address bar search engine.
+    Uses the browser's address bar to search (Ctrl+L -> type -> Enter).
+    This uses whatever default search engine the browser is configured with.
+    """
+    
+    # Special marker to indicate this engine uses address bar input
+    USE_ADDRESS_BAR = True
+    
+    def build_url(self, query: str, limit: int = 10) -> str:
+        """
+        For address bar search, we don't build a URL.
+        Return the raw query - SearchService will handle the address bar input.
+        """
+        # Return a special marker so SearchService knows to use address bar
+        return f"__ADDRESS_BAR_SEARCH__:{query}"
+
+    def parse(self, content: str) -> List[Dict[str, Any]]:
+        """
+        Parse search results from whatever search engine the browser uses.
+        We detect the engine from the HTML and use appropriate parsing.
+        """
+        results = []
+        seen_urls = set()
+        
+        # Detect which search engine based on content
+        is_google = 'google' in content.lower() and ('class="g"' in content or 'data-hveid' in content)
+        is_bing = 'bing' in content.lower() and 'b_algo' in content
+        is_duckduckgo = 'duckduckgo' in content.lower()
+        
+        if is_google:
+            results = self._parse_google(content, seen_urls)
+        elif is_bing:
+            results = self._parse_bing(content, seen_urls)
+        elif is_duckduckgo:
+            results = self._parse_duckduckgo(content, seen_urls)
+        else:
+            # Generic fallback
+            results = self._parse_generic(content, seen_urls)
+        
+        logger.info(f"DefaultEngine parsed {len(results)} results (detected: {'google' if is_google else 'bing' if is_bing else 'ddg' if is_duckduckgo else 'generic'})")
+        return results
+    
+    def _parse_google(self, content: str, seen_urls: set) -> List[Dict[str, Any]]:
+        """Parse Google search results."""
+        results = []
+        # Look for result links
+        link_regex = re.compile(
+            r'<a[^>]+href="(https?://(?!google\.com|accounts\.google)[^"]+)"[^>]*>([^<]+)</a>',
+            re.IGNORECASE
+        )
+        
+        for match in link_regex.finditer(content):
+            if len(results) >= 15:
+                break
+            href = match.group(1)
+            title = match.group(2).strip()
+            
+            if href in seen_urls or not title or len(title) < 3:
+                continue
+            if any(x in href for x in ['google.com', 'gstatic.com', 'youtube.com/redirect']):
+                continue
+                
+            seen_urls.add(href)
+            results.append({
+                "title": re.sub(r'<[^>]+>', '', title),
+                "url": href,
+                "domain": urllib.parse.urlparse(href).hostname or "",
+                "content": "",
+            })
+        return results
+    
+    def _parse_bing(self, content: str, seen_urls: set) -> List[Dict[str, Any]]:
+        """Parse Bing search results."""
+        results = []
+        link_regex = re.compile(
+            r'<a[^>]+href="(https?://(?!bing\.com|microsoft\.com)[^"]+)"[^>]*>(.*?)</a>',
+            re.IGNORECASE | re.DOTALL
+        )
+        
+        for match in link_regex.finditer(content):
+            if len(results) >= 15:
+                break
+            href = match.group(1)
+            title_html = match.group(2)
+            title = re.sub(r'<[^>]+>', '', title_html).strip()
+            
+            if href in seen_urls or not title or len(title) < 3:
+                continue
+            if any(x in href for x in ['bing.com', 'microsoft.com', 'msn.com']):
+                continue
+                
+            seen_urls.add(href)
+            results.append({
+                "title": title,
+                "url": href,
+                "domain": urllib.parse.urlparse(href).hostname or "",
+                "content": "",
+            })
+        return results
+    
+    def _parse_duckduckgo(self, content: str, seen_urls: set) -> List[Dict[str, Any]]:
+        """Parse DuckDuckGo results."""
+        results = []
+        link_regex = re.compile(
+            r'<a[^>]+href="(https?://(?!duckduckgo\.com)[^"]+)"[^>]*>(.*?)</a>',
+            re.IGNORECASE | re.DOTALL
+        )
+        
+        for match in link_regex.finditer(content):
+            if len(results) >= 15:
+                break
+            href = match.group(1)
+            title_html = match.group(2)
+            title = re.sub(r'<[^>]+>', '', title_html).strip()
+            
+            if href in seen_urls or not title or len(title) < 3:
+                continue
+                
+            seen_urls.add(href)
+            results.append({
+                "title": title,
+                "url": href,
+                "domain": urllib.parse.urlparse(href).hostname or "",
+                "content": "",
+            })
+        return results
+    
+    def _parse_generic(self, content: str, seen_urls: set) -> List[Dict[str, Any]]:
+        """Generic link parser for unknown search engines."""
+        results = []
+        link_regex = re.compile(
+            r'<a[^>]+href="(https?://[^"]+)"[^>]*>([^<]+)</a>',
+            re.IGNORECASE
+        )
+        
+        for match in link_regex.finditer(content):
+            if len(results) >= 15:
+                break
+            href = match.group(1)
+            title = match.group(2).strip()
+            
+            if href in seen_urls or not title or len(title) < 5:
+                continue
+            # Skip common non-result URLs
+            if any(x in href for x in ['javascript:', 'mailto:', '#', 'login', 'signin', 'account']):
+                continue
+                
+            seen_urls.add(href)
+            results.append({
+                "title": title,
+                "url": href,
+                "domain": urllib.parse.urlparse(href).hostname or "",
+                "content": "",
+            })
+        return results
+

entari_plugin_hyw/browser/manager.py

@@ -65,7 +65,7 @@ class SharedBrowserManager:
             # Hide scrollbars globally
             co.set_argument('--hide-scrollbars')
             # 十万的原因是滚动条屏蔽(大概吧)
-            co.set_argument('--window-size=1280,20000')
+            co.set_argument('--window-size=1280,9000')
             self._page = ChromiumPage(addr_or_opts=co)
             
             # Show Landing Page

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

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) 获取网页全文
@@ -35,6 +35,9 @@ INSTRUCT_SP = """你是一个智能 INSTRUCT 助手。
 ## 重要规则 (CRITICAL RULES)：
 - 禁止输出任何文本回复：你必须且只能通过工具调用来行动。
 - 如果没有工具调用，流程将自动结束。
+
+## now
+请快速给出回复.
 """
 
 INSTRUCT_DEEPSEARCH_SP = """你是一个智能 INSTRUCT_DEEPSEARCH 审查助手, 你需要对 INSTRUCT 的输出进行多次信息补充直到信息足够、或达到次数上限(3次)
@@ -77,6 +80,22 @@ SUMMARY_REPORT_SP = """# 你是一个信息整合专家 (Summary Agent).
 """
 
 
+# =============================================================================
+# VISION DESCRIPTION PROMPT
+# =============================================================================
+
+VISION_DESCRIPTION_SP = """你是一个图像描述专家。
+根据用户发送的图片和文字，快速描述图片中的内容。
+
+要求：
+- 客观描述图片中的主要元素、场景、人物、文字等
+- 如果图片包含文字，请完整转录
+- 如果用户有具体问题，围绕问题描述相关细节
+- 描述应该简洁但信息丰富，控制在 300 字以内
+- 使用用户的语言回复
+"""
+
+
 # =============================================================================
 # TOOL DEFINITIONS
 # =============================================================================
@@ -105,7 +124,7 @@ def get_web_search_tool() -> Dict[str, Any]:
         "type": "function",
         "function": {
             "name": "web_search",
-            "description": "网络搜索",
+            "description": "网络搜索, 只容许输入正常的字符串查询, 禁止高级搜索",
             "parameters": {
                 "type": "object",
                 "properties": {"query": {"type": "string"}},