entari-plugin-hyw 3.4.2__py3-none-any.whl → 3.5.0rc1__py3-none-any.whl

entari_plugin_hyw/core/config.py

@@ -24,9 +24,6 @@ class HYWConfig:
     instruct_extra_body: Optional[Dict[str, Any]] = None
     temperature: float = 0.4
     max_turns: int = 10
-    icon: str = "openai"  # logo for primary model
-    vision_icon: Optional[str] = None  # logo for vision model (falls back to icon when absent)
-    instruct_icon: Optional[str] = None # logo for instruct model
     enable_browser_fallback: bool = False
     language: str = "Simplified Chinese"
     input_price: Optional[float] = None  # $ per 1M input tokens

entari_plugin_hyw/core/pipeline.py

@@ -122,6 +122,7 @@ class ProcessingPipeline:
         
         # Reset search cache and ID counters for this execution
         self.all_web_results = []
+        self.global_id_counter = 0
         self.search_id_counter = 0
         self.page_id_counter = 0
         self.image_id_counter = 0
@@ -428,7 +429,7 @@ class ProcessingPipeline:
                 stages_used.append({
                     "name": "Vision",
                     "model": v_model,
-                    "icon_config": getattr(self.config, "vision_icon", None) or infer_icon(v_model, v_base_url),
+                    "icon_config": infer_icon(v_model, v_base_url),
                     "provider": infer_provider(v_base_url),
                     "time": v.get("time", 0),
                     "cost": v.get("cost", 0.0)
@@ -441,20 +442,33 @@ class ProcessingPipeline:
                 stages_used.append({
                     "name": "Instruct",
                     "model": i_model,
-                    "icon_config": getattr(self.config, "instruct_icon", None) or infer_icon(i_model, i_base_url),
+                    "icon_config": infer_icon(i_model, i_base_url),
                     "provider": infer_provider(i_base_url),
                     "time": i.get("time", 0),
                     "cost": i.get("cost", 0.0)
                 })
 
-            if has_search_results and search_payloads:
+            # Show Search stage if we have ANY search results (text OR image)
+            if (has_search_results or has_image_results) and search_payloads:
+                # Collect initial search results for the Search stage card
+                initial_refs = [
+                    {"title": r.get("title", ""), "url": r.get("url", ""), "domain": r.get("domain", "")}
+                    for r in self.all_web_results if r.get("_type") == "search"
+                ]
+                initial_images = [
+                    {"title": r.get("title", ""), "url": r.get("url", ""), "thumbnail": r.get("thumbnail", "")}
+                    for r in self.all_web_results if r.get("_type") == "image"
+                ]
+                
                 stages_used.append({
                     "name": "Search",
                     "model": getattr(self.config, "search_name", "DuckDuckGo"),
                     "icon_config": "search",
                     "provider": getattr(self.config, 'search_provider', 'Crawl4AI'),
                     "time": search_time,
-                    "cost": 0.0
+                    "cost": 0.0,
+                    "references": initial_refs,
+                    "image_references": initial_images
                 })
             
             # Add Crawler stage if Instruct used crawl_page
@@ -496,7 +510,7 @@ class ProcessingPipeline:
                 a_model = a.get("model", "") or active_model
                 a_base_url = a.get("base_url", "") or self.config.base_url
                 steps = a.get("steps", [])
-                agent_icon = getattr(self.config, "icon", None) or infer_icon(a_model, a_base_url)
+                agent_icon = infer_icon(a_model, a_base_url)
                 agent_provider = infer_provider(a_base_url)
 
                 for s in steps:
@@ -587,12 +601,25 @@ class ProcessingPipeline:
                             "time": 0, "cost": 0
                         })
 
-                # Assign total time/cost to last Agent stage
+            # Assign total time/cost to last Agent stage
                 last_agent = next((s for s in reversed(stages_used) if s["name"] == "Agent"), None)
                 if last_agent:
                     last_agent["time"] = a.get("time", 0)
                     last_agent["cost"] = a.get("cost", 0.0)
 
+            # --- Final Filter: Only show cited items in workflow cards ---
+            cited_urls = {ref['url'] for ref in (structured.get("references", []) + 
+                                               structured.get("page_references", []) + 
+                                               structured.get("image_references", []))}
+            
+            for s in stages_used:
+                if "references" in s and s["references"]:
+                    s["references"] = [r for r in s["references"] if r.get("url") in cited_urls]
+                # if "image_references" in s and s["image_references"]:
+                #     s["image_references"] = [r for r in s["image_references"] if r.get("url") in cited_urls]
+                if "crawled_pages" in s and s["crawled_pages"]:
+                    s["crawled_pages"] = [r for r in s["crawled_pages"] if r.get("url") in cited_urls]
+
             # Clean up conversation history: Remove tool calls and results to save tokens and avoid ID conflicts
             # Keep only 'user' messages and 'assistant' messages without tool_calls (final answers)
             cleaned_history = []
@@ -627,11 +654,7 @@ class ProcessingPipeline:
             }
 
     def _parse_tagged_response(self, text: str) -> Dict[str, Any]:
-        """Parse response and auto-infer references from [N] citations in body text.
-        
-        New simplified format:
-        - Body text uses [1][2] format for citations
-        - No ref code block needed - we auto-infer from citations
+        """Parse response and auto-infer references from citations and markdown images.
         """
         parsed = {"response": "", "references": [], "page_references": [], "image_references": [], "flow_steps": []}
         if not text:
@@ -639,9 +662,14 @@ class ProcessingPipeline:
 
         import re
         
-        remaining_text = text
+        # 1. Strip trailing reference/source list
+        body_text = text
+        ref_list_pattern = re.compile(r'(?:\n\s*|^)\s*(?:#{1,3}|\*\*)\s*(?:References|Citations|Sources|参考资料|引用)[\s\S]*$', re.IGNORECASE | re.MULTILINE)
+        body_text = ref_list_pattern.sub('', body_text)
+        
+        remaining_text = body_text.strip()
         
-        # 1. Try to unwrap JSON if the model acted like a ReAct agent
+        # 2. Unwrap JSON if necessary
         try:
             if remaining_text.strip().startswith("{") and "action" in remaining_text:
                 data = json.loads(remaining_text)
@@ -650,67 +678,114 @@ class ProcessingPipeline:
         except Exception:
             pass
 
-        # 2. Extract all [N] citations from body text (scan left to right for order)
+        # 3. Identify all citations [N] and direct markdown images ![]()
+        cited_ids = []
         body_pattern = re.compile(r'\[(\d+)\]')
-        id_order = []  # Preserve citation order
-        
         for match in body_pattern.finditer(remaining_text):
             try:
-                id_val = int(match.group(1))
-                if id_val not in id_order:
-                    id_order.append(id_val)
-            except ValueError:
-                pass
-
-        # 3. Build references by looking up cited IDs in all_web_results
-        # Order by appearance in text
-        old_to_new_map = {}  # old_id -> new_id (for search & page only)
+                cited_ids.append(int(match.group(1)))
+            except ValueError: pass
+
+        # Also find direct URLs in ![]() 
+        direct_image_urls = []
+        img_pattern = re.compile(r'!\[.*?\]\((.*?)\)')
+        for match in img_pattern.finditer(remaining_text):
+            url = match.group(1).strip()
+            if url and not url.startswith('['): # Not a [N] citation
+                direct_image_urls.append(url)
+
+        # 4. Build Citation Maps and Reference Lists
+        unified_id_map = {}
+        # Keep track of what we've already added to avoid duplicates
+        seen_urls = set()
         
+        # id_order needs to be unique and preserve appearance order
+        id_order = []
+        for id_val in cited_ids:
+            if id_val not in id_order:
+                id_order.append(id_val)
+
+        # Process [N] citations first to determine numbering
         for old_id in id_order:
-            # Find in all_web_results by _id
             result_item = next((r for r in self.all_web_results if r.get("_id") == old_id), None)
+            if not result_item: continue
+            
+            url = result_item.get("url", "")
+            item_type = result_item.get("_type", "")
+            
+            entry = {
+                "title": result_item.get("title", ""),
+                "url": url,
+                "domain": result_item.get("domain", "")
+            }
             
+            if item_type == "search":
+                parsed["references"].append(entry)
+                unified_id_map[old_id] = len(parsed["references"]) + len(parsed["page_references"])
+                seen_urls.add(url)
+            elif item_type == "page":
+                parsed["page_references"].append(entry)
+                unified_id_map[old_id] = len(parsed["references"]) + len(parsed["page_references"])
+                seen_urls.add(url)
+            elif item_type == "image":
+                 entry["thumbnail"] = result_item.get("thumbnail", "")
+                 if url not in seen_urls:
+                    parsed["image_references"].append(entry)
+                    seen_urls.add(url)
+                 # Note: Images cited as [N] might be used in text like ![...]([N])
+                 # We'll handle this in replacement
+
+        # Now handle direct image URLs from ![]() that weren't cited as [N]
+        for url in direct_image_urls:
+            if url in seen_urls: continue
+            # Find in all_web_results
+            result_item = next((r for r in self.all_web_results if (r.get("url") == url or r.get("image") == url) and r.get("_type") == "image"), None)
             if result_item:
                 entry = {
                     "title": result_item.get("title", ""),
-                    "url": result_item.get("url", ""),
-                    "domain": result_item.get("domain", "")
+                    "url": url,
+                    "domain": result_item.get("domain", ""),
+                    "thumbnail": result_item.get("thumbnail", "")
                 }
-                
-                item_type = result_item.get("_type", "")
-                
-                # Auto-classify by type
-                if item_type == "search":
-                    parsed["references"].append(entry)
-                    old_to_new_map[old_id] = len(parsed["references"])
-                elif item_type == "page":
-                    parsed["page_references"].append(entry)
-                    old_to_new_map[old_id] = len(parsed["page_references"])
-                elif item_type == "image":
-                    # Collect image but don't add to map (will be stripped from text)
-                    entry["thumbnail"] = result_item.get("thumbnail", "")
-                    parsed["image_references"].append(entry)
-                    # Note: no old_to_new_map entry - image citations will be removed
-
-        # 4. Replace [old_id] with [new_id] in text, or remove if image
-        def replace_id(match):
-            try:
-                old_id = int(match.group(1))
-                new_id = old_to_new_map.get(old_id)
-                if new_id is not None:
-                    return f"[{new_id}]"
-                else:
-                    # Check if it's an image reference (not in map)
-                    item = next((r for r in self.all_web_results if r.get("_id") == old_id), None)
-                    if item and item.get("_type") == "image":
-                        return ""  # Remove image citations from text
-            except ValueError:
-                pass
-            return match.group(0)
+                parsed["image_references"].append(entry)
+                seen_urls.add(url)
 
-        remaining_text = body_pattern.sub(replace_id, remaining_text)
+        # 5. Replacement Logic
+        # Define image replacement map separately to handle ![...]([N])
+        image_url_map = {} # old_id -> raw_url
+        for old_id in id_order:
+            item = next((r for r in self.all_web_results if r.get("_id") == old_id), None)
+            if item and item.get("_type") == "image":
+                image_url_map[old_id] = item.get("url", "")
+
+        def refined_replace(text):
+            # First, handle ![...]([N]) specifically
+            # We want to replace the [N] with the actual URL so the markdown renders
+            def sub_img_ref(match):
+                alt = match.group(1)
+                ref = match.group(2)
+                inner_match = body_pattern.match(ref)
+                if inner_match:
+                    oid = int(inner_match.group(1))
+                    if oid in image_url_map:
+                        return f"![{alt}]({image_url_map[oid]})"
+                return match.group(0)
+            
+            text = re.sub(r'!\[(.*?)\]\((.*?)\)', sub_img_ref, text)
+            
+            # Then handle normal [N] replacements
+            def sub_norm_ref(match):
+                oid = int(match.group(1))
+                if oid in unified_id_map:
+                    return f"[{unified_id_map[oid]}]"
+                if oid in image_url_map:
+                    return "" # Remove standalone image citations like [5] if they aren't in ![]()
+                return match.group(0)
+            
+            return body_pattern.sub(sub_norm_ref, text)
 
-        parsed["response"] = remaining_text.strip()
+        final_text = refined_replace(remaining_text)
+        parsed["response"] = final_text.strip()
         return parsed
 
     async def _safe_route_tool(self, tool_call):

entari_plugin_hyw/core/render_vue.py

@@ -0,0 +1,255 @@
+"""
+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 uuid
+import os
+from pathlib import Path
+from typing import List, Dict, Any
+
+import asyncio
+from loguru import logger
+from playwright.async_api import async_playwright
+
+
+class ContentRenderer:
+    """Minimal renderer - only passes raw data to Vue template."""
+    
+    
+    def __init__(self, template_path: str = None):
+        if template_path is None:
+            current_dir = Path(__file__).parent
+            plugin_root = current_dir.parent
+            template_path = plugin_root / "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)")
+        
+        # Persistent state
+        self.playwright = None
+        self.browser = None
+        self.context = None
+        self.page = None
+        self._lock = asyncio.Lock()
+        self._render_count = 0
+        self._max_renders_before_restart = 50  # Prevent memory leaks
+
+    async def start(self):
+        """Initialize the browser and page."""
+        if self.page:
+            return
+
+        logger.info("ContentRenderer: Starting persistent 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": 520, "height": 1400},
+                device_scale_factor=2.4,
+            )
+            self.page = await self.context.new_page()
+            
+            # Load the template once
+            await self.page.goto(self.template_path.as_uri(), wait_until="networkidle")
+            logger.info("ContentRenderer: Browser started and template loaded.")
+            
+        except Exception as e:
+            logger.error(f"ContentRenderer: Failed to start browser: {e}")
+            await self.close()
+            raise
+
+    async def close(self):
+        """Clean up browser resources."""
+        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
+        logger.info("ContentRenderer: Browser closed.")
+
+    async def _get_page(self):
+        """Get or recreate the persistent page."""
+        if self._render_count >= self._max_renders_before_restart:
+            logger.info(f"ContentRenderer: Restarting browser after {self._render_count} renders...")
+            await self.close()
+            self._render_count = 0
+
+        if not self.page:
+            await self.start()
+        
+        return self.page
+
+    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,
+        **kwargs
+    ) -> bool:
+        """Render content to image using persistent browser."""
+        
+        resolved_output_path = Path(output_path).resolve()
+        resolved_output_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Prepare data
+        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,
+        }
+        import time
+        start_time = time.time()
+        
+        # Reorder images
+        self._reorder_images_in_stages(render_data["markdown"], render_data["stages"])
+
+        async with self._lock:
+            try:
+                page = await self._get_page()
+                
+                # Update data via JS
+                # Using evaluate to call window.updateRenderData
+                await page.evaluate("(data) => window.updateRenderData(data)", render_data)
+                
+                
+                # Wait for Vue to update DOM
+                # Give Vue a moment to patch the DOM (insert img tags)
+                await asyncio.sleep(0.1) 
+                
+                # Wait for all images to load
+                try:
+                    await 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 to load ({image_timeout}ms), taking screenshot anyway.")
+                
+                # Resize height if needed? 
+                # The page height might change. We capture full page or specific element.
+                # If capturing element:
+                element = await page.query_selector("#main-container")
+                if element:
+                    # Clean previous screenshots? No, overwrite.
+                    await element.screenshot(path=str(resolved_output_path), type="jpeg", quality=98)
+                else:
+                    await page.screenshot(path=str(resolved_output_path), full_page=True, type="jpeg", quality=98)
+                
+                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})")
+                # If render failed, maybe browser is dead. Close it to force restart next time.
+                await self.close()
+                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
+        
+        # 1. Extract clean URLs from markdown
+        # Matches: ![...](https://...)
+        img_urls = []
+        for match in re.finditer(r'!\[.*?\]\((.*?)\)', markdown):
+            # Url might be followed by title: "url" "title"
+            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
+
+        # 2. Reorder each stage's image_references
+        for stage in stages:
+            refs = stage.get("image_references")
+            if not refs:
+                continue
+                
+            # Map url -> ref object
+            ref_map = {r["url"]: r for r in refs}
+            
+            new_refs = []
+            seen_urls = set()
+            
+            # First, add images found in markdown in order
+            for url in img_urls:
+                if url in ref_map:
+                    new_refs.append(ref_map[url])
+                    seen_urls.add(url)
+            
+            # Then add remaining images not found in markdown
+            for r in refs:
+                if r["url"] not in seen_urls:
+                    new_refs.append(r)
+            
+            stage["image_references"] = new_refs