entari-plugin-hyw 3.5.0rc1__py3-none-any.whl → 3.5.0rc2__py3-none-any.whl

entari_plugin_hyw/render_vue.py

@@ -0,0 +1,314 @@
+"""
+Vue-based Card Renderer (Minimal Python)
+
+Python only provides raw data. All frontend logic (markdown, syntax highlighting,
+math rendering, citations) is handled by the Vue frontend.
+"""
+
+import json
+import gc
+import os
+import threading
+import asyncio
+from pathlib import Path
+from typing import List, Dict, Any
+from concurrent.futures import Future
+
+from loguru import logger
+from playwright.async_api import async_playwright
+
+
+class ContentRenderer:
+    """Minimal renderer with background browser thread for instant startup."""
+    
+    def __init__(self, template_path: str = None, auto_start: bool = True):
+        if template_path is None:
+            current_dir = Path(__file__).parent
+            template_path = current_dir / "assets" / "card-dist" / "index.html"
+        
+        self.template_path = Path(template_path)
+        if not self.template_path.exists():
+            raise FileNotFoundError(f"Vue template not found: {self.template_path}")
+            
+        self.template_content = self.template_path.read_text(encoding="utf-8")
+        logger.info(f"ContentRenderer: loaded Vue template ({len(self.template_content)} bytes)")
+        
+        # Browser state (managed by background thread)
+        self._playwright = None
+        self._browser = None
+        self._context = None
+        self._page = None
+        self._render_count = 0
+        self._max_renders_before_restart = 50
+        
+        # Background event loop for playwright
+        self._loop: asyncio.AbstractEventLoop = None
+        self._thread: threading.Thread = None
+        self._ready = threading.Event()
+        self._lock = threading.Lock()
+        
+        if auto_start:
+            self._start_background_loop()
+
+    def _start_background_loop(self):
+        """Start dedicated event loop in background thread."""
+        def _run_loop():
+            self._loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(self._loop)
+            # Start browser immediately
+            self._loop.run_until_complete(self._init_browser())
+            self._ready.set()
+            # Keep loop running for future tasks
+            self._loop.run_forever()
+        
+        self._thread = threading.Thread(target=_run_loop, daemon=True, name="ContentRenderer-Browser")
+        self._thread.start()
+        logger.info("ContentRenderer: Background browser thread started")
+
+    async def _init_browser(self, timeout: int = 6000):
+        """Initialize browser and page with warmup render (runs in background loop)."""
+        logger.info("ContentRenderer: Starting browser...")
+        try:
+            self._playwright = await async_playwright().start()
+            self._browser = await self._playwright.chromium.launch(
+                headless=True, 
+                args=['--no-sandbox', '--disable-setuid-sandbox']
+            )
+            self._context = await self._browser.new_context(
+                viewport={"width": 540, "height": 1400},
+                device_scale_factor=2.0,
+            )
+            self._page = await self._context.new_page()
+            await self._page.goto(self.template_path.as_uri(), wait_until="domcontentloaded", timeout=timeout)
+            
+            # Pre-warm the page with initial data so Vue compiles and renders
+            warmup_data = {
+                "markdown": "# Ready",
+                "total_time": 0,
+                "stages": [],
+                "references": [],
+                "page_references": [],
+                "image_references": [],
+                "stats": {},
+                "theme_color": "#ef4444",
+            }
+            await self._page.evaluate("(data) => window.updateRenderData(data)", warmup_data)
+            await asyncio.sleep(0.1)  # Let Vue render
+            logger.success("ContentRenderer: Browser + page ready!")
+        except Exception as e:
+            logger.error(f"ContentRenderer: Failed to start browser: {e}")
+            raise
+
+    def _run_in_background(self, coro) -> Future:
+        """Schedule coroutine in background loop and return Future."""
+        if not self._loop or not self._loop.is_running():
+            raise RuntimeError("Background loop not running")
+        return asyncio.run_coroutine_threadsafe(coro, self._loop)
+
+    async def start(self, timeout: int = 6000):
+        """Wait for browser to be ready (for compatibility)."""
+        ready = await asyncio.to_thread(self._ready.wait, timeout / 1000)
+        if not ready:
+            raise TimeoutError("Browser startup timeout")
+
+    async def close(self):
+        """Clean up browser resources."""
+        if self._loop and self._loop.is_running():
+            future = self._run_in_background(self._close_internal())
+            # Use asyncio.to_thread to wait without blocking the event loop
+            await asyncio.to_thread(future.result, 10)
+        if self._loop:
+            self._loop.call_soon_threadsafe(self._loop.stop)
+        if self._thread:
+            # Use asyncio.to_thread to wait without blocking the event loop
+            await asyncio.to_thread(self._thread.join, 5)
+        logger.info("ContentRenderer: Browser closed.")
+
+    async def _close_internal(self):
+        """Internal close (runs in background loop)."""
+        if self._page:
+            await self._page.close()
+            self._page = None
+        if self._context:
+            await self._context.close()
+            self._context = None
+        if self._browser:
+            await self._browser.close()
+            self._browser = None
+        if self._playwright:
+            await self._playwright.stop()
+            self._playwright = None
+
+    async def _ensure_page(self):
+        """Ensure page is ready, restart if needed (runs in background loop)."""
+        if self._render_count >= self._max_renders_before_restart:
+            logger.info(f"ContentRenderer: Restarting browser after {self._render_count} renders...")
+            await self._close_internal()
+            self._render_count = 0
+        
+        if not self._page:
+            await self._init_browser()
+
+    async def render(
+        self,
+        markdown_content: str,
+        output_path: str,
+        stats: Dict[str, Any] = None,
+        references: List[Dict[str, Any]] = None,
+        page_references: List[Dict[str, Any]] = None,
+        image_references: List[Dict[str, Any]] = None,
+        stages_used: List[Dict[str, Any]] = None,
+        image_timeout: int = 3000,
+        theme_color: str = "#ef4444",
+        **kwargs
+    ) -> bool:
+        """Render content to image."""
+        # Wait for browser ready (non-blocking)
+        ready = await asyncio.to_thread(self._ready.wait, 30)
+        if not ready:
+            logger.error("ContentRenderer: Browser not ready after 30s")
+            return False
+        
+        # Prepare data
+        resolved_output_path = Path(output_path).resolve()
+        resolved_output_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        stats_dict = stats[0] if isinstance(stats, list) and stats else (stats or {})
+        
+        render_data = {
+            "markdown": markdown_content,
+            "total_time": stats_dict.get("total_time", 0) or 0,
+            "stages": [
+                {
+                    "name": s.get("name", "Step"),
+                    "model": s.get("model", ""),
+                    "provider": s.get("provider", ""),
+                    "time": s.get("time", 0),
+                    "cost": s.get("cost", 0),
+                    "references": s.get("references") or s.get("search_results"),
+                    "image_references": s.get("image_references"),
+                    "crawled_pages": s.get("crawled_pages"),
+                }
+                for s in (stages_used or [])
+            ],
+            "references": references or [],
+            "page_references": page_references or [],
+            "image_references": image_references or [],
+            "stats": stats_dict,
+            "theme_color": theme_color,
+        }
+        
+        # Reorder images in stages
+        self._reorder_images_in_stages(render_data["markdown"], render_data["stages"])
+        
+        # Run render in background loop (non-blocking wait for result)
+        try:
+            future = self._run_in_background(
+                self._render_internal(render_data, str(resolved_output_path), image_timeout)
+            )
+            # Use asyncio.to_thread to wait for the future without blocking the event loop
+            return await asyncio.to_thread(future.result, 60)
+        except Exception as e:
+            logger.error(f"ContentRenderer: render failed ({e})")
+            return False
+
+    async def _render_internal(self, render_data: dict, output_path: str, image_timeout: int) -> bool:
+        """Internal render (runs in background loop)."""
+        import time
+        start_time = time.time()
+        
+        try:
+            await self._ensure_page()
+            
+            # Update data via JS
+            await self._page.evaluate("(data) => window.updateRenderData(data)", render_data)
+            
+            # Wait for Vue to update DOM
+            await asyncio.sleep(0.1)
+            
+            # Wait for images to load
+            try:
+                await self._page.wait_for_function(
+                    "() => Array.from(document.images).every(img => img.complete)",
+                    timeout=image_timeout
+                )
+            except Exception:
+                logger.warning(f"ContentRenderer: Timeout waiting for images ({image_timeout}ms)")
+            
+            # Take screenshot
+            element = await self._page.query_selector("#main-container")
+            if element:
+                await element.screenshot(path=output_path, type="jpeg", quality=88)
+            else:
+                await self._page.screenshot(path=output_path, full_page=True, type="jpeg", quality=88)
+            
+            self._render_count += 1
+            duration = time.time() - start_time
+            logger.success(f"ContentRenderer: Rendered in {duration:.3f}s (No.{self._render_count})")
+            return True
+            
+        except Exception as exc:
+            logger.error(f"ContentRenderer: render failed ({exc})")
+            # Reset page to force restart next time
+            self._page = None
+            return False
+        finally:
+            gc.collect()
+
+    async def render_models_list(
+        self,
+        models: List[Dict[str, Any]],
+        output_path: str,
+        default_base_url: str = "https://openrouter.ai/api/v1",
+        **kwargs
+    ) -> bool:
+        """Render models list."""
+        lines = ["# 模型列表"]
+        for idx, model in enumerate(models or [], start=1):
+            name = model.get("name", "unknown")
+            base_url = model.get("base_url") or default_base_url
+            provider = model.get("provider", "")
+            lines.append(f"{idx}. **{name}**  \n   - base_url: {base_url}  \n   - provider: {provider}")
+
+        markdown_content = "\n\n".join(lines) if len(lines) > 1 else "# 模型列表\n暂无模型"
+
+        return await self.render(
+            markdown_content=markdown_content,
+            output_path=output_path,
+            stats={},
+            references=[],
+            stages_used=[],
+        )
+
+    def _reorder_images_in_stages(self, markdown: str, stages: List[Dict[str, Any]]) -> None:
+        """Reorder image references in stages based on appearance in markdown."""
+        import re
+        
+        img_urls = []
+        for match in re.finditer(r'!\[.*?\]\((.*?)\)', markdown):
+            url_part = match.group(1).split()[0].strip()
+            if url_part and url_part not in img_urls:
+                img_urls.append(url_part)
+                
+        if not img_urls:
+            return
+
+        for stage in stages:
+            refs = stage.get("image_references")
+            if not refs:
+                continue
+                
+            ref_map = {r["url"]: r for r in refs}
+            new_refs = []
+            seen_urls = set()
+            
+            for url in img_urls:
+                if url in ref_map:
+                    new_refs.append(ref_map[url])
+                    seen_urls.add(url)
+            
+            for r in refs:
+                if r["url"] not in seen_urls:
+                    new_refs.append(r)
+            
+            stage["image_references"] = new_refs

entari_plugin_hyw/{utils/search.py → search.py}

@@ -22,6 +22,9 @@ except ImportError:
     except ImportError:
         DDGS = None
 
+# Import image cache for prefetching
+from .image_cache import prefetch_images
+
 # Shared crawler instance to avoid repeated init
 _shared_crawler: Optional[AsyncWebCrawler] = None
 
@@ -46,7 +49,8 @@ async def close_shared_crawler():
 class SearchService:
     """
     Multi-strategy search & fetch service.
-    Supported providers: 'crawl4ai' (default), 'httpx', 'ddgs'.
+    Search providers: 'crawl4ai' (default), 'httpx', 'ddgs'.
+    Fetch providers: 'crawl4ai' (default), 'jinaai'.
     """
     def __init__(self, config: Any):
         self.config = config
@@ -56,8 +60,11 @@ class SearchService:
         # Configuration for retries/timeouts
         self._search_timeout = getattr(config, "search_timeout", 10.0)
         self._search_retries = getattr(config, "search_retries", 2)
-        self._provider = getattr(config, "search_provider", "crawl4ai")
-        logger.info(f"SearchService initialized: provider='{self._provider}', limit={self._default_limit}, timeout={self._search_timeout}s")
+        # Separate providers for search and page fetching
+        self._search_provider = getattr(config, "search_provider", "crawl4ai")
+        self._fetch_provider = getattr(config, "fetch_provider", "crawl4ai")
+        self._jina_api_key = getattr(config, "jina_api_key", None)
+        logger.info(f"SearchService initialized: search_provider='{self._search_provider}', fetch_provider='{self._fetch_provider}', limit={self._default_limit}, timeout={self._search_timeout}s")
 
     def _build_search_url(self, query: str) -> str:
         encoded_query = urllib.parse.quote(query)
@@ -82,7 +89,7 @@ class SearchService:
         if not query:
             return []
 
-        provider = self._provider.lower()
+        provider = self._search_provider.lower()
         logger.info(f"SearchService: searching for '{query}' using provider='{provider}'")
 
         if provider == "httpx":
@@ -355,11 +362,122 @@ class SearchService:
 
     async def fetch_page(self, url: str) -> Dict[str, str]:
         """
-        Fetch a single page via Crawl4AI and return cleaned markdown/text plus metadata.
+        Fetch a single page and return cleaned markdown/text plus metadata.
+        Dispatches to jinaai or Crawl4AI based on fetch_provider config.
         """
         if not url:
             return {"content": "Error: missing url", "title": "Error", "url": ""}
 
+        provider = self._fetch_provider.lower()
+        logger.info(f"SearchService: fetching page '{url}' using fetch_provider='{provider}'")
+
+        if provider == "jinaai":
+            return await self._fetch_page_jinaai(url)
+        else:
+            return await self._fetch_page_crawl4ai(url)
+
+    async def _fetch_page_jinaai(self, url: str) -> Dict[str, str]:
+        """
+        Fetch page via Jina AI Reader - returns clean markdown content.
+        https://r.jina.ai/{url}
+        """
+        if not httpx:
+            logger.warning("SearchService: httpx not installed, fallback to crawl4ai")
+            return await self._fetch_page_crawl4ai(url)
+
+        jina_url = f"https://r.jina.ai/{url}"
+        headers = {
+            "X-Return-Format": "markdown",
+        }
+        # Add authorization header if API key is configured
+        if self._jina_api_key:
+            headers["Authorization"] = f"Bearer {self._jina_api_key}"
+
+        try:
+            async with httpx.AsyncClient(timeout=30.0, follow_redirects=True) as client:
+                resp = await client.get(jina_url, headers=headers)
+                resp.raise_for_status()
+                content = resp.text
+
+            # Jina AI returns markdown content directly
+            # Try to extract title from first heading or first line
+            title = "No Title"
+            lines = content.strip().split('\n')
+            for line in lines:
+                line = line.strip()
+                if line.startswith('# '):
+                    title = line[2:].strip()
+                    break
+                elif line and not line.startswith('!') and not line.startswith('['):
+                    # Use first non-empty, non-image, non-link line as title
+                    title = line[:100]
+                    break
+
+            logger.info(f"SearchService(jinaai): fetched page, title='{title}', content_len={len(content)}")
+            return {
+                "content": content[:8000],
+                "title": title,
+                "url": url
+            }
+
+        except Exception as e:
+            logger.error(f"SearchService(jinaai) fetch_page failed: {e}")
+            return {"content": f"Error: fetch failed ({e})", "title": "Error", "url": url}
+
+    async def _fetch_page_httpx(self, url: str) -> Dict[str, str]:
+        """
+        Fetch page via httpx - fast, no browser overhead.
+        """
+        if not httpx:
+            logger.warning("SearchService: httpx not installed, fallback to crawl4ai")
+            return await self._fetch_page_crawl4ai(url)
+
+        try:
+            async with httpx.AsyncClient(timeout=self._search_timeout, follow_redirects=True) as client:
+                resp = await client.get(url, headers={
+                    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+                })
+                resp.raise_for_status()
+                html_content = resp.text
+
+            # Extract title from HTML
+            title = "No Title"
+            title_match = re.search(r'<title[^>]*>([^<]+)</title>', html_content, re.IGNORECASE)
+            if title_match:
+                title = html.unescape(title_match.group(1).strip())
+            
+            # Try og:title as fallback
+            if title == "No Title":
+                og_match = re.search(r'<meta[^>]+property=["\']og:title["\'][^>]+content=["\']([^"\']+)["\']', html_content, re.IGNORECASE)
+                if og_match:
+                    title = html.unescape(og_match.group(1).strip())
+
+            # Simple HTML to text conversion
+            # Remove script/style tags
+            content = re.sub(r'<script[^>]*>[\s\S]*?</script>', '', html_content, flags=re.IGNORECASE)
+            content = re.sub(r'<style[^>]*>[\s\S]*?</style>', '', html_content, flags=re.IGNORECASE)
+            # Remove HTML tags
+            content = re.sub(r'<[^>]+>', ' ', content)
+            # Decode entities
+            content = html.unescape(content)
+            # Normalize whitespace
+            content = re.sub(r'\s+', ' ', content).strip()
+
+            logger.info(f"SearchService(httpx): fetched page, title='{title}', content_len={len(content)}")
+            return {
+                "content": content[:8000],
+                "title": title,
+                "url": url
+            }
+
+        except Exception as e:
+            logger.error(f"SearchService(httpx) fetch_page failed: {e}")
+            return {"content": f"Error: fetch failed ({e})", "title": "Error", "url": url}
+
+    async def _fetch_page_crawl4ai(self, url: str) -> Dict[str, str]:
+        """
+        Fetch page via Crawl4AI - full browser rendering.
+        """
         try:
             crawler = await self._get_crawler()
             result = await crawler.arun(
@@ -416,17 +534,116 @@ class SearchService:
                 pass
             self._crawler = None
 
-    async def image_search(self, query: str) -> List[Dict[str, str]]:
+    async def image_search(self, query: str, prefetch: bool = True) -> List[Dict[str, str]]:
         """
-        Image search via Crawl4AI media extraction or DDGS.
+        Image search - dispatches to httpx, ddgs, or Crawl4AI based on search_provider.
+        
+        Args:
+            query: Search query
+            prefetch: If True, automatically start prefetching images for caching
         """
         if not query:
             return []
 
-        # If ddgs is selected, use it
-        if self._provider == "ddgs":
-             return await self._search_ddgs_images(query)
+        provider = self._search_provider.lower()
+        logger.info(f"SearchService: image searching for '{query}' using provider='{provider}'")
+
+        if provider == "ddgs":
+            results = await self._search_ddgs_images(query)
+        elif provider == "httpx":
+            results = await self._image_search_httpx(query)
+        else:
+            results = await self._image_search_crawl4ai(query)
+        
+        # Start prefetching images in background for faster rendering
+        if prefetch and results:
+            urls_to_prefetch = []
+            for img in results:
+                # Prefer thumbnail for prefetch (smaller, used in UI)
+                thumb = img.get("thumbnail")
+                url = img.get("url")
+                if thumb:
+                    urls_to_prefetch.append(thumb)
+                if url and url != thumb:
+                    urls_to_prefetch.append(url)
+            
+            if urls_to_prefetch:
+                logger.info(f"SearchService: Starting prefetch for {len(urls_to_prefetch)} images")
+                await prefetch_images(urls_to_prefetch)
+        
+        return results
+
+    async def _image_search_httpx(self, query: str) -> List[Dict[str, str]]:
+        """
+        Image search via httpx - parse img tags from HTML response.
+        """
+        if not httpx:
+            logger.warning("SearchService: httpx not installed, fallback to crawl4ai")
+            return await self._image_search_crawl4ai(query)
+
+        url = self._build_image_url(query)
+        logger.info(f"SearchService(httpx Image): fetching {url}")
+
+        try:
+            async with httpx.AsyncClient(timeout=self._search_timeout, follow_redirects=True) as client:
+                resp = await client.get(url, headers={
+                    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+                })
+                resp.raise_for_status()
+                html_content = resp.text
+
+            # Parse img tags from HTML
+            # Match: <img ... src="..." ... > or <img ... data-src="..." ...>
+            img_regex = re.compile(r'<img[^>]+(?:src|data-src)=["\']([^"\']+)["\'][^>]*(?:alt=["\']([^"\']*)["\'])?[^>]*>', re.IGNORECASE)
+            
+            images = []
+            seen = set()
+            
+            for match in img_regex.finditer(html_content):
+                src = match.group(1) or ""
+                alt = match.group(2) or ""
+                
+                if not src:
+                    continue
+                if src.startswith("//"):
+                    src = "https:" + src
+                if not src.startswith("http"):
+                    continue
+                # Skip tiny icons/placeholders
+                if "favicon" in src.lower() or "logo" in src.lower() or "icon" in src.lower():
+                    continue
+                if src in seen:
+                    continue
+                seen.add(src)
+                
+                alt = html.unescape(alt.strip()) if alt else "Image"
+                domain = urllib.parse.urlparse(src).hostname or ""
+                
+                images.append({
+                    "title": alt,
+                    "url": src,
+                    "thumbnail": src,  # Use same URL as thumbnail
+                    "domain": domain,
+                    "content": alt,
+                })
+                
+                if len(images) >= self._default_limit:
+                    break
+
+            if not images:
+                logger.warning(f"SearchService(httpx): no images parsed from HTML")
+            else:
+                logger.info(f"SearchService(httpx): parsed {len(images)} images")
+            return images
+
+        except Exception as e:
+            logger.error(f"SearchService(httpx) image_search failed: {e}")
+            return []
 
+    async def _image_search_crawl4ai(self, query: str) -> List[Dict[str, str]]:
+        """
+        Image search via Crawl4AI media extraction.
+        """
         url = self._build_image_url(query)
         logger.info(f"SearchService(Crawl4AI Image): fetching {url}")
 

{entari_plugin_hyw-3.5.0rc1.dist-info → entari_plugin_hyw-3.5.0rc2.dist-info}/METADATA

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

{entari_plugin_hyw-3.5.0rc1.dist-info → entari_plugin_hyw-3.5.0rc2.dist-info}/RECORD

@@ -1,5 +1,12 @@
-entari_plugin_hyw/__init__.py,sha256=_IfEZZhGgTTAgJIV4-eyPruxDyCMwf61QrAA24HAD9s,16105
-entari_plugin_hyw/assets/card-dist/index.html,sha256=l0T2bQLb51XKXMGR_lL1IIV_GemCd171-I0AxEjgnRQ,274777
+entari_plugin_hyw/__init__.py,sha256=LHhCnOL5X6Il5OOrL4Q9HH1PHZtGfof9rTsRDQpVYpQ,15790
+entari_plugin_hyw/history.py,sha256=zYtON0FgkA_AcXerLV335OzpIP30eAxDEp7NHCFFXis,7016
+entari_plugin_hyw/image_cache.py,sha256=-GWNgzmIZv8OF2qEECqcQcuzGnhz5vmZ2-GWdPkEX4I,10373
+entari_plugin_hyw/misc.py,sha256=pW-eSRKGJjJhVfz8Z-N0bTIHL57Jq3ynPzVFuy7YWnI,3479
+entari_plugin_hyw/pipeline.py,sha256=Q4896twMwL_UbaabA7v-TFlLl1fduTrtPkFyiH3Qvyc,56173
+entari_plugin_hyw/prompts.py,sha256=ZE0UN4GuUuG6HCzH4RbfQFHVCC9zT4_xByiG2L-U70I,3961
+entari_plugin_hyw/render_vue.py,sha256=BkjfIB4JJ-CTvbreSHbczMu5NyDZtKjK-0HVQpYGacQ,12393
+entari_plugin_hyw/search.py,sha256=yauAkNs3bM79dWoMSbn5ngRsxGLAHRbiAYSaGOxzVUQ,28316
+entari_plugin_hyw/assets/card-dist/index.html,sha256=2DEOmrRDN6QwoqsywMfe8zdHvzHxrn5Rnhgg2bJA8UE,2016347
 entari_plugin_hyw/assets/card-dist/vite.svg,sha256=SnSK_UQ5GLsWWRyDTEAdrjPoeGGrXbrQgRw6O0qSFPs,1497
 entari_plugin_hyw/assets/card-dist/logos/anthropic.svg,sha256=ASsy1ypo3osNc3n-B0R81tk_dIFsVgg7qQORrd5T2kA,558
 entari_plugin_hyw/assets/card-dist/logos/cerebras.svg,sha256=bpmiiYTODwc06knTmPj3GQ7NNtosMog5lkggvB_Z-7M,44166
@@ -65,35 +72,17 @@ entari_plugin_hyw/card-ui/public/logos/qwen.png,sha256=eqLbnIPbjh2_PsODU_mmqjeD8
 entari_plugin_hyw/card-ui/public/logos/xai.png,sha256=uSulvvDVqoA4RUOW0ZAkdvBVM2rpyGJRZIbn5dEFspw,362
 entari_plugin_hyw/card-ui/public/logos/xiaomi.png,sha256=WHxlDFGU5FCjb-ure3ngdGG18-efYZUUfqA3_lqCUN0,4084
 entari_plugin_hyw/card-ui/public/logos/zai.png,sha256=K-gnabdsjMLInppHA1Op7Nyt33iegrx1x-yNlvCZ0Tc,2351
-entari_plugin_hyw/card-ui/src/App.vue,sha256=ijVHzRH9nnwt723YRrgYRebISyM1f2c6M_hozcUlzVo,8094
+entari_plugin_hyw/card-ui/src/App.vue,sha256=DA5CLpWtl_bm3n3WBpEhdmun9IkLaRE1E_jWMeOmwwY,17656
 entari_plugin_hyw/card-ui/src/main.ts,sha256=rm653lPnK5fuTIj-iNLpgr8GAmayuCoKop7IWfo0IBk,111
 entari_plugin_hyw/card-ui/src/style.css,sha256=LnQEZyUqsj-IuESW1YBRqAz7T6LMayMDuiNKP5TAB1o,188
-entari_plugin_hyw/card-ui/src/types.ts,sha256=hEofV_xlQCpYIMU3chjjn6wDII8NBww3YqtGiZvIfpI,1182
+entari_plugin_hyw/card-ui/src/test_regex.js,sha256=cWmclm6LRKYfjeN1RT5HECdltmo1HvS2BwGCYY_4l14,3040
+entari_plugin_hyw/card-ui/src/types.ts,sha256=jzI8MXDKxz7WRZmGVb-bToO8BEFW2AOp8iek1n4VuQY,1246
 entari_plugin_hyw/card-ui/src/assets/vue.svg,sha256=VTLbNPHFKEGIG6uK7KbD6NCSvSGmiaZfTY-M-AQe750,496
 entari_plugin_hyw/card-ui/src/components/HelloWorld.vue,sha256=yvBIzJua9BfikUOR1I7GYytlnBbgB6xyposxslAoRLU,856
-entari_plugin_hyw/card-ui/src/components/MarkdownContent.vue,sha256=4-xt_r79Llni6VP5A4hCs7I9xBQzqL4f14yYc-0p3uw,11992
+entari_plugin_hyw/card-ui/src/components/MarkdownContent.vue,sha256=w6XbsYa0UQVnb_E7Z6CR2HwKMXWEEzAgQxJ5DQbL9yg,13068
 entari_plugin_hyw/card-ui/src/components/SectionCard.vue,sha256=owcDNx2JYVmF2J5SYCroR2gvg_cPApQsNunjK1WJpVI,1433
-entari_plugin_hyw/card-ui/src/components/StageCard.vue,sha256=HPh_O8ltcdOCe4KXMN4OqMZTHsN4NJEZnhICRDjyrBM,7572
-entari_plugin_hyw/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-entari_plugin_hyw/core/config.py,sha256=09lpgYTuNnZlR3KXaHmR4WfuUVEHwrHH0Thjbq93jX4,1440
-entari_plugin_hyw/core/history.py,sha256=vqp7itwR5-KaqC4Ftmq6GOz7OM9GsiFJnSN9JJ2P6L4,5894
-entari_plugin_hyw/core/hyw.py,sha256=RCRjV9uYmvXysiliztphLP3VyUabrf0LY2Bk66W5JGA,1927
-entari_plugin_hyw/core/pipeline.py,sha256=15SyghuDkNX81kr3ESeLmCyy2eL2RZgt44-PQY1gdx8,51793
-entari_plugin_hyw/core/render_vue.py,sha256=54XtNiacH_9eyBhcD0dZtL0_wOy05YaK2td13jyVXcs,9694
-entari_plugin_hyw/test_output/render_0.jpg,sha256=uoODJLt-PPY7iCpmlo9ehPIlMMiN6dmmlkT9tpIHEn8,109963
-entari_plugin_hyw/test_output/render_1.jpg,sha256=uoODJLt-PPY7iCpmlo9ehPIlMMiN6dmmlkT9tpIHEn8,109963
-entari_plugin_hyw/test_output/render_2.jpg,sha256=uoODJLt-PPY7iCpmlo9ehPIlMMiN6dmmlkT9tpIHEn8,109963
-entari_plugin_hyw/test_output/render_3.jpg,sha256=uoODJLt-PPY7iCpmlo9ehPIlMMiN6dmmlkT9tpIHEn8,109963
-entari_plugin_hyw/test_output/render_4.jpg,sha256=uoODJLt-PPY7iCpmlo9ehPIlMMiN6dmmlkT9tpIHEn8,109963
-entari_plugin_hyw/tests/ui_test_output.jpg,sha256=UwkpO8saGV0HubXq9Oo0WpdVON9t5_7FSmQrak_YfpE,1586227
-entari_plugin_hyw/tests/verify_ui.py,sha256=Zln2mNCaJopvDBOFujux0K1UF5PfjpmscBq6q3-dKPI,6728
-entari_plugin_hyw/utils/__init__.py,sha256=TnkxDqYr0zgRE7TC92tVbUaY8m1UyyoLg2zvzQ8nMVI,84
-entari_plugin_hyw/utils/browser.py,sha256=LJlFh-oSqt9mQBpMALxbYGUG__t1YLUo7RxUAslsWUc,1416
-entari_plugin_hyw/utils/misc.py,sha256=pW-eSRKGJjJhVfz8Z-N0bTIHL57Jq3ynPzVFuy7YWnI,3479
-entari_plugin_hyw/utils/playwright_tool.py,sha256=ZZNkzFtUt_Gxny3Od4boBAgNF9J0N84uySatzn1Bwe4,1272
-entari_plugin_hyw/utils/prompts.py,sha256=Zqgs9ywMri-LLyPjPYA1qcA9GVBfqjZ3qVHb7K7Fnx8,4284
-entari_plugin_hyw/utils/search.py,sha256=Bvz2KFw3Gr2nuvmlo_8ExLHvO353NKX-YN35A2FCsBw,19047
-entari_plugin_hyw-3.5.0rc1.dist-info/METADATA,sha256=RDxS81rieII4yZMeKuhLS-1sd365gGH6N5zjHa4kiu0,3740
-entari_plugin_hyw-3.5.0rc1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-entari_plugin_hyw-3.5.0rc1.dist-info/top_level.txt,sha256=TIDsn6XPs6KA5e3ezsE65JoXsy03ejDdrB41I4SPjmo,18
-entari_plugin_hyw-3.5.0rc1.dist-info/RECORD,,
+entari_plugin_hyw/card-ui/src/components/StageCard.vue,sha256=4nIZXKDtvsAKwc3-lkeONrpdT2Fbw_fgn16SdJOOku4,9066
+entari_plugin_hyw-3.5.0rc2.dist-info/METADATA,sha256=r67ZlZIVbMlpS99bqIHs14JS3xiL8v_jz0ziQR69LrQ,3740
+entari_plugin_hyw-3.5.0rc2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+entari_plugin_hyw-3.5.0rc2.dist-info/top_level.txt,sha256=TIDsn6XPs6KA5e3ezsE65JoXsy03ejDdrB41I4SPjmo,18
+entari_plugin_hyw-3.5.0rc2.dist-info/RECORD,,