entari-plugin-hyw 4.0.0rc16__tar.gz → 4.0.0rc17__tar.gz

{entari_plugin_hyw-4.0.0rc16/src/entari_plugin_hyw.egg-info → entari_plugin_hyw-4.0.0rc17}/PKG-INFO

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

{entari_plugin_hyw-4.0.0rc16 → entari_plugin_hyw-4.0.0rc17}/pyproject.toml

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

{entari_plugin_hyw-4.0.0rc16 → entari_plugin_hyw-4.0.0rc17}/src/entari_plugin_hyw/__init__.py

@@ -43,7 +43,7 @@ from .misc import (
     RecentEventDeduper,
 )
 from .filters import parse_filter_syntax
-from .search_cache import SearchResultCache, parse_single_index, parse_multi_indices
+from .search_cache import SearchResultCache, parse_single_index, parse_multi_indices, crop_to_square_thumbnail
 
 
 try:
@@ -305,6 +305,22 @@ async def process_request(
             await session.send(f"Error: {response.error}")
             return
         else:
+            # Process screenshots: cache full images and create thumbnails
+            for ref in response.references:
+                if ref.get("raw_screenshot_b64"):
+                    full_b64 = ref["raw_screenshot_b64"]
+                    url = ref.get("url", "")
+
+                    # Cache full screenshot
+                    cache_id = search_cache.store_screenshot(full_b64, url)
+                    ref["screenshot_cache_id"] = cache_id
+
+                    # Create thumbnail (1:1 crop from top)
+                    thumbnail = crop_to_square_thumbnail(full_b64, max_size=400)
+                    if thumbnail:
+                        ref["raw_screenshot_b64"] = thumbnail
+                        ref["is_thumbnail"] = True
+
             # 3. Explicit External Render using the Parallel Tab
             render_ok = await core.render(
                 markdown_content=response.content,
@@ -476,37 +492,148 @@ async def handle_web_command(session: Session[MessageCreatedEvent], result: Arpa
     if session.reply and hasattr(session.reply.origin, 'id'):
         reply_msg_id = str(session.reply.origin.id)
     
-    # Quote + Index mode: Screenshot specific cached result
+    # Quote + Index mode: Screenshot specific cached result(s)
     if reply_msg_id:
         cached = search_cache.get(reply_msg_id)
         if cached:
-            # Parse index from query
+            # Case 1: No query - show all results as Sources card
+            if not query:
+                local_renderer = await get_content_renderer()
+                tab_task = asyncio.create_task(local_renderer.prepare_tab())
+
+                # Build references from cached results
+                references = []
+                for i, res in enumerate(cached.results[:10]):
+                    references.append({
+                        "title": res.get("title", f"Result {i+1}"),
+                        "url": res.get("url", ""),
+                        "snippet": res.get("content", "") or res.get("snippet", ""),
+                        "original_idx": i + 1,
+                    })
+
+                try:
+                    tab_id = await tab_task
+                except Exception:
+                    tab_id = None
+
+                with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tf:
+                    output_path = tf.name
+
+                core = get_hyw_core()
+                render_ok = await core.render(
+                    markdown_content=f"# 搜索结果: {cached.query}",
+                    output_path=output_path,
+                    stats={"total_time": 0},
+                    references=references,
+                    page_references=[],
+                    stages_used=[{"name": "cache", "description": f"缓存结果 ({len(references)} 条)", "time": 0}],
+                    tab_id=tab_id
+                )
+
+                if render_ok and os.path.exists(output_path):
+                    with open(output_path, "rb") as f:
+                        img_data = base64.b64encode(f.read()).decode()
+
+                    msg_chain = MessageChain(Image(src=f'data:image/png;base64,{img_data}'))
+                    if conf.quote:
+                        msg_chain = MessageChain(Quote(session.event.message.id)) + msg_chain
+
+                    sent = await session.send(msg_chain)
+
+                    # Re-cache with new message ID for chaining
+                    sent_id = next((str(e.id) for e in sent if hasattr(e, 'id')), None) if sent else None
+                    if sent_id:
+                        search_cache.store(sent_id, cached.results[:10], cached.query)
+
+                    os.remove(output_path)
+                else:
+                    await session.send("渲染搜索结果失败")
+
+                search_cache.cleanup()
+                return
+
+            # Case 2: Multi-index mode - try parsing multiple indices first
+            indices = parse_multi_indices(query)
+            if indices is not None:
+                # Validate all indices
+                invalid_indices = [i + 1 for i in indices if i >= len(cached.results)]
+                if invalid_indices:
+                    await session.send(f"序号超出范围: {invalid_indices} (最大: {len(cached.results)})")
+                    search_cache.cleanup()
+                    return
+
+                # Collect URLs to screenshot
+                urls_to_screenshot = []
+                for idx in indices:
+                    target_url = cached.results[idx].get("url", "")
+                    if target_url and target_url not in urls_to_screenshot:
+                        urls_to_screenshot.append(target_url)
+
+                if not urls_to_screenshot:
+                    await session.send("所选结果无有效URL")
+                    search_cache.cleanup()
+                    return
+
+                if conf.reaction:
+                    asyncio.create_task(react(session, "📸"))
+
+                core = get_hyw_core()
+                screenshot_results = await core.screenshot_batch(urls_to_screenshot)
+
+                images = [Image(src=f'data:image/jpeg;base64,{b64}') for b64 in screenshot_results if b64]
+
+                if images:
+                    msg_chain = MessageChain(images)
+                    if conf.quote:
+                        msg_chain = MessageChain(Quote(session.event.message.id)) + msg_chain
+                    await session.send(msg_chain)
+                else:
+                    await session.send("截图失败")
+
+                search_cache.cleanup()
+                return
+
+            # Case 3: Single index fallback
             idx = parse_single_index(query)
             if idx is None:
                 # No valid index - show prompt
-                await session.send("请指定序号 (1-10)")
+                await session.send("请指定序号，如: /w 1 或 /w 2、3")
                 search_cache.cleanup()  # Lazy cleanup
                 return
-            
+
             if idx >= len(cached.results):
                 await session.send(f"序号超出范围 (1-{len(cached.results)})")
                 search_cache.cleanup()
                 return
-            
-            # Screenshot the cached URL
+
+            # Screenshot the cached URL - check if already cached first
             target_result = cached.results[idx]
             target_url = target_result.get("url", "")
+            screenshot_cache_id = target_result.get("screenshot_cache_id")
+
             if not target_url:
                 await session.send("该结果无有效URL")
                 search_cache.cleanup()
                 return
-            
-            if conf.reaction:
-                asyncio.create_task(react(session, "📸"))
-            
-            core = get_hyw_core()
-            b64_img = await core.screenshot(target_url)
-            
+
+            # Try to get from cache first
+            b64_img = None
+            if screenshot_cache_id:
+                b64_img = search_cache.get_screenshot(screenshot_cache_id)
+                if b64_img:
+                    logger.info(f"/w using cached screenshot: {screenshot_cache_id}")
+
+            # Fetch if not in cache
+            if not b64_img:
+                if conf.reaction:
+                    asyncio.create_task(react(session, "📸"))
+
+                core = get_hyw_core()
+                b64_img = await core.screenshot(target_url)
+            else:
+                if conf.reaction:
+                    asyncio.create_task(react(session, "✨"))
+
             if b64_img:
                 msg_chain = MessageChain(Image(src=f'data:image/jpeg;base64,{b64_img}'))
                 if conf.quote:
@@ -514,7 +641,7 @@ async def handle_web_command(session: Session[MessageCreatedEvent], result: Arpa
                 await session.send(msg_chain)
             else:
                 await session.send(f"截图失败: {target_url}")
-            
+
             search_cache.cleanup()
             return
         else:

{entari_plugin_hyw-4.0.0rc16 → entari_plugin_hyw-4.0.0rc17}/src/entari_plugin_hyw/search_cache.py

@@ -6,9 +6,13 @@ deep query operations on search results.
 """
 
 import time
+import base64
+import io
 from dataclasses import dataclass, field
 from typing import Dict, List, Any, Optional
 
+from loguru import logger
+
 
 @dataclass
 class CacheEntry:
@@ -18,21 +22,31 @@ class CacheEntry:
     timestamp: float = field(default_factory=time.time)
 
 
+@dataclass
+class ScreenshotCacheEntry:
+    """A cached full screenshot."""
+    screenshot_b64: str
+    url: str
+    timestamp: float = field(default_factory=time.time)
+
+
 class SearchResultCache:
     """
     In-memory cache for search results with TTL-based expiration.
-    
+
     Cleanup is lazy - performed at the end of each request.
     """
-    
+
     def __init__(self, ttl_seconds: float = 600.0):  # 10 minutes default
         self._cache: Dict[str, CacheEntry] = {}
+        self._screenshot_cache: Dict[str, ScreenshotCacheEntry] = {}  # screenshot_id -> full screenshot
+        self._screenshot_counter: int = 0
         self.ttl_seconds = ttl_seconds
-    
+
     def store(self, message_id: str, results: List[Dict[str, Any]], query: str):
         """
         Store search results associated with a message ID.
-        
+
         Args:
             message_id: The sent message ID that contains the search results image
             results: List of search result dicts with url, title, content, etc.
@@ -43,28 +57,65 @@ class SearchResultCache:
             query=query,
             timestamp=time.time()
         )
-    
+
     def get(self, message_id: str) -> Optional[CacheEntry]:
         """
         Get cached search results for a message ID.
-        
+
         Returns None if not found or expired.
         """
         entry = self._cache.get(message_id)
         if entry is None:
             return None
-        
+
         # Check expiration
         if time.time() - entry.timestamp > self.ttl_seconds:
             del self._cache[message_id]
             return None
-        
+
         return entry
-    
+
+    def store_screenshot(self, screenshot_b64: str, url: str) -> str:
+        """
+        Store a full screenshot and return its cache ID.
+
+        Args:
+            screenshot_b64: Base64 encoded full screenshot
+            url: The URL that was screenshotted
+
+        Returns:
+            A short cache ID for referencing this screenshot
+        """
+        self._screenshot_counter += 1
+        cache_id = f"ss{self._screenshot_counter:04x}"
+        self._screenshot_cache[cache_id] = ScreenshotCacheEntry(
+            screenshot_b64=screenshot_b64,
+            url=url,
+            timestamp=time.time()
+        )
+        return cache_id
+
+    def get_screenshot(self, cache_id: str) -> Optional[str]:
+        """
+        Get a cached full screenshot by ID.
+
+        Returns:
+            Base64 encoded screenshot or None if not found/expired
+        """
+        entry = self._screenshot_cache.get(cache_id)
+        if entry is None:
+            return None
+
+        if time.time() - entry.timestamp > self.ttl_seconds:
+            del self._screenshot_cache[cache_id]
+            return None
+
+        return entry.screenshot_b64
+
     def cleanup(self):
         """
         Remove all expired entries.
-        
+
         Called lazily at the end of each request.
         """
         now = time.time()
@@ -74,11 +125,59 @@ class SearchResultCache:
         ]
         for k in expired_keys:
             del self._cache[k]
-    
+
+        # Also cleanup screenshot cache
+        expired_ss = [
+            k for k, v in self._screenshot_cache.items()
+            if now - v.timestamp > self.ttl_seconds
+        ]
+        for k in expired_ss:
+            del self._screenshot_cache[k]
+
     def __len__(self) -> int:
         return len(self._cache)
 
 
+def crop_to_square_thumbnail(screenshot_b64: str, max_size: int = 400) -> Optional[str]:
+    """
+    Crop a screenshot to a 1:1 square from the top and resize.
+
+    Args:
+        screenshot_b64: Base64 encoded image
+        max_size: Maximum dimension of the output square
+
+    Returns:
+        Base64 encoded cropped/resized image, or None on error
+    """
+    try:
+        from PIL import Image
+
+        # Decode base64
+        img_data = base64.b64decode(screenshot_b64)
+        img = Image.open(io.BytesIO(img_data))
+
+        width, height = img.size
+
+        # Crop to square from top
+        square_size = min(width, height)
+        # Crop from top-left, taking full width if width < height
+        crop_box = (0, 0, square_size, square_size)
+        cropped = img.crop(crop_box)
+
+        # Resize if larger than max_size
+        if square_size > max_size:
+            cropped = cropped.resize((max_size, max_size), Image.Resampling.LANCZOS)
+
+        # Encode back to base64
+        buffer = io.BytesIO()
+        cropped.save(buffer, format='JPEG', quality=85)
+        return base64.b64encode(buffer.getvalue()).decode('utf-8')
+
+    except Exception as e:
+        logger.warning(f"Failed to crop screenshot: {e}")
+        return None
+
+
 def parse_single_index(text: str) -> Optional[int]:
     """
     Parse a single index from text like "1" or "3".

{entari_plugin_hyw-4.0.0rc16 → entari_plugin_hyw-4.0.0rc17/src/entari_plugin_hyw.egg-info}/PKG-INFO

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

{entari_plugin_hyw-4.0.0rc16 → entari_plugin_hyw-4.0.0rc17}/src/hyw_core/agent.py

@@ -2,7 +2,7 @@
 Agent Pipeline
 
 Tool-calling agent that can autonomously use web_tool to search/screenshot.
-Maximum 2 rounds of tool calls, up to 3 parallel calls per round.
+Maximum 3 rounds of tool calls, up to 3 parallel calls per round.
 """
 
 import asyncio
@@ -53,8 +53,8 @@ class AgentSession:
     
     @property
     def should_force_summary(self) -> bool:
-        """Force summary after 2 rounds of tool calls."""
-        return self.round_count >= 2
+        """Force summary after 3 rounds of tool calls."""
+        return self.round_count >= 3
 
 
 def parse_filter_syntax(query: str, max_count: int = 3):
@@ -135,11 +135,11 @@ class AgentPipeline:
     Flow:
     1. 用户输入 → LLM (with tools)
     2. If tool_call: execute all tools in parallel → notify user with batched message → loop
-    3. If call_count >= 2 rounds: force summary on next call
+    3. If call_count >= 3 rounds: force summary on next call
     4. Return final content
     """
     
-    MAX_TOOL_ROUNDS = 2  # Maximum rounds of tool calls
+    MAX_TOOL_ROUNDS = 3  # Maximum rounds of tool calls
     MAX_PARALLEL_TOOLS = 3  # Maximum parallel tool calls per round
     MAX_LLM_RETRIES = 3  # Maximum retries for empty API responses
     LLM_RETRY_DELAY = 1.0  # Delay between retries in seconds
@@ -243,7 +243,7 @@ class AgentPipeline:
         # Send initial status notification
         if self.send_func:
             try:
-                await self.send_func("💭 正在理解用户意图...")
+                await self.send_func("💭 何意味...")
             except Exception as e:
                 logger.warning(f"AgentPipeline: Failed to send initial notification: {e}")