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

entari_plugin_hyw/history.py

@@ -0,0 +1,248 @@
+import random
+import string
+from typing import Dict, List, Any, Optional
+
+class HistoryManager:
+    def __init__(self):
+        self._history: Dict[str, List[Dict[str, Any]]] = {}
+        self._metadata: Dict[str, Dict[str, Any]] = {}
+        self._mapping: Dict[str, str] = {}
+        self._context_latest: Dict[str, str] = {}
+        
+        # New: Short code management
+        self._short_codes: Dict[str, str] = {} # code -> key
+        self._key_to_code: Dict[str, str] = {} # key -> code
+        self._context_history: Dict[str, List[str]] = {} # context_id -> list of keys
+
+    def is_bot_message(self, message_id: str) -> bool:
+        """Check if the message ID belongs to a bot message"""
+        return message_id in self._history
+
+    def generate_short_code(self) -> str:
+        """Generate a unique 4-digit hex code"""
+        while True:
+            code = ''.join(random.choices(string.hexdigits.lower(), k=4))
+            if code not in self._short_codes:
+                return code
+
+    def get_conversation_id(self, message_id: str) -> Optional[str]:
+        return self._mapping.get(message_id)
+        
+    def get_key_by_code(self, code: str) -> Optional[str]:
+        return self._short_codes.get(code.lower())
+        
+    def get_code_by_key(self, key: str) -> Optional[str]:
+        return self._key_to_code.get(key)
+
+    def get_history(self, key: str) -> List[Dict[str, Any]]:
+        return self._history.get(key, [])
+
+    def get_metadata(self, key: str) -> Dict[str, Any]:
+        return self._metadata.get(key, {})
+        
+    def get_latest_from_context(self, context_id: str) -> Optional[str]:
+        return self._context_latest.get(context_id)
+        
+    def list_by_context(self, context_id: str, limit: int = 10) -> List[str]:
+        """Return list of keys for a context, most recent first"""
+        keys = self._context_history.get(context_id, [])
+        return keys[-limit:][::-1]
+
+    def remember(self, message_id: Optional[str], history: List[Dict[str, Any]], related_ids: List[str], metadata: Optional[Dict[str, Any]] = None, context_id: Optional[str] = None, code: Optional[str] = None):
+        if not message_id:
+            return
+            
+        key = message_id
+        self._history[key] = history
+        if metadata:
+            self._metadata[key] = metadata
+            
+        self._mapping[key] = key
+        for rid in related_ids:
+            if rid:
+                self._mapping[rid] = key
+                
+        # Generate or use provided short code
+        if key not in self._key_to_code:
+            if not code:
+                code = self.generate_short_code()
+            self._short_codes[code] = key
+            self._key_to_code[key] = code
+            
+        if context_id:
+            self._context_latest[context_id] = key
+            if context_id not in self._context_history:
+                self._context_history[context_id] = []
+            self._context_history[context_id].append(key)
+
+    def save_to_disk(self, key: str, save_root: str = "data/conversations", image_path: Optional[str] = None, web_results: Optional[List[Dict]] = None):
+        """Save conversation history to specific folder structure"""
+        import os
+        import time
+        import re
+        import shutil
+        import json
+        
+        if key not in self._history:
+            return
+
+        try:
+            # Extract user's first message (question) for folder name
+            user_question = ""
+            for msg in self._history[key]:
+                if msg.get("role") == "user":
+                    content = msg.get("content", "")
+                    if isinstance(content, list):
+                        for item in content:
+                            if isinstance(item, dict) and item.get("type") == "text":
+                                user_question = item.get("text", "")
+                                break
+                    else:
+                        user_question = str(content)
+                    break
+            
+            # Clean and truncate question
+            question_part = re.sub(r'[\\/:*?"<>|\n\r\t]', '', user_question)[:20].strip()
+            if not question_part:
+                question_part = "conversation"
+            
+            # Create folder: YYYYMMDD_HHMMSS_question
+            time_str = time.strftime("%Y%m%d_%H%M%S", time.localtime())
+            folder_name = f"{time_str}_{question_part}"
+            folder_path = os.path.join(save_root, folder_name)
+            
+            os.makedirs(folder_path, exist_ok=True)
+            
+            meta = self._metadata.get(key, {})
+
+            # 1. Save Context/Trace
+            trace_md = meta.get("trace_markdown")
+            if trace_md:
+                with open(os.path.join(folder_path, "context_trace.md"), "w", encoding="utf-8") as f:
+                    f.write(trace_md)
+            
+            # 2. Save Web Results (Search & Pages)
+            if web_results:
+                pages_dir = os.path.join(folder_path, "pages")
+                os.makedirs(pages_dir, exist_ok=True)
+                
+                search_buffer = []  # Buffer for unfetched search results
+                
+                for i, item in enumerate(web_results):
+                    item_type = item.get("_type", "unknown")
+                    title = item.get("title", "Untitled")
+                    url = item.get("url", "")
+                    content = item.get("content", "")
+                    item_id = item.get("_id", i + 1)
+                    
+                    if not content:
+                        continue
+                    
+                    if item_type == "search":
+                        # Collect search snippets for consolidated file
+                        search_buffer.append(f"## [{item_id}] {title}\n- **URL**: {url}\n\n{content}\n")
+                    
+                    elif item_type in ["page", "search_raw_page"]:
+                        # Save fetched pages/raw search pages individually
+                        clean_title = re.sub(r'[\\/:*?"<>|\n\r\t]', '', title)[:30].strip() or "page"
+                        filename = f"{item_id:02d}_{item_type}_{clean_title}.md"
+                        
+                        # Save screenshot if available
+                        screenshot_b64 = item.get("screenshot_b64")
+                        image_ref = ""
+                        if screenshot_b64:
+                            try:
+                                import base64
+                                img_filename = f"{item_id:02d}_{item_type}_{clean_title}.jpg"
+                                img_path = os.path.join(pages_dir, img_filename)
+                                with open(img_path, "wb") as f:
+                                    f.write(base64.b64decode(screenshot_b64))
+                                image_ref = f"\n### Screenshot\n![Screenshot]({img_filename})\n"
+                            except Exception as e:
+                                print(f"Failed to save screenshot for {title}: {e}")
+                        
+                        page_md = f"# [{item_id}] {title}\n\n"
+                        page_md += f"- **Type**: {item_type}\n"
+                        page_md += f"- **URL**: {url}\n\n"
+                        if image_ref:
+                            page_md += f"{image_ref}\n"
+                        page_md += f"---\n\n{content}\n"
+                        
+                        with open(os.path.join(pages_dir, filename), "w", encoding="utf-8") as f:
+                            f.write(page_md)
+                
+                # Save consolidated search results
+                if search_buffer:
+                    with open(os.path.join(folder_path, "search_results.md"), "w", encoding="utf-8") as f:
+                        f.write(f"# Search Results\n\nGenerated at {time.strftime('%Y-%m-%d %H:%M:%S')}\n\n" + "\n---\n\n".join(search_buffer))
+                
+            # 3. Save Final Response (MD)
+            final_content = ""
+            # Find last assistant message
+            for msg in reversed(self._history[key]):
+                if msg.get("role") == "assistant":
+                    content = msg.get("content", "")
+                    if isinstance(content, str):
+                        final_content = content
+                    break
+            
+            if final_content:
+                with open(os.path.join(folder_path, "final_response.md"), "w", encoding="utf-8") as f:
+                    f.write(final_content)
+
+            # Save Output Image (Final Card)
+            if image_path and os.path.exists(image_path):
+                try:
+                    dest_img_path = os.path.join(folder_path, "output_card.jpg")
+                    shutil.copy2(image_path, dest_img_path)
+                except Exception as e:
+                    print(f"Failed to copy output image: {e}")
+
+            # 4. Save Full Log (Readme style)
+            timestamp = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+            model_name = meta.get("model", "unknown")
+            code = self._key_to_code.get(key, "N/A")
+            
+            md_content = f"# Conversation Log: {folder_name}\n\n"
+            md_content += f"- **Time**: {timestamp}\n"
+            md_content += f"- **Code**: {code}\n"
+            md_content += f"- **Model**: {model_name}\n\n"
+
+            md_content += "## History\n\n"
+            
+            for msg in self._history[key]:
+                role = msg.get("role", "unknown").upper()
+                content = msg.get("content", "")
+                
+                md_content += f"### {role}\n\n"
+                
+                tool_calls = msg.get("tool_calls")
+                if tool_calls:
+                     try:
+                         tc_str = json.dumps(tool_calls, ensure_ascii=False, indent=2)
+                     except:
+                         tc_str = str(tool_calls)
+                     md_content += f"**Tool Calls**:\n```json\n{tc_str}\n```\n\n"
+                
+                if role == "TOOL":
+                    try:
+                        # Try parsing as JSON first
+                        if isinstance(content, str):
+                            parsed = json.loads(content)
+                            pretty = json.dumps(parsed, ensure_ascii=False, indent=2)
+                            md_content += f"**Output**:\n```json\n{pretty}\n```\n\n"
+                        else:
+                            md_content += f"**Output**:\n```text\n{content}\n```\n\n"
+                    except:
+                         md_content += f"**Output**:\n```text\n{content}\n```\n\n"
+                else:
+                    if content:
+                        md_content += f"{content}\n\n"
+                
+                md_content += "---\n\n"
+            
+            with open(os.path.join(folder_path, "full_log.md"), "w", encoding="utf-8") as f:
+                f.write(md_content)
+                
+        except Exception as e:
+            print(f"Failed to save conversation: {e}")

entari_plugin_hyw/image_cache.py

@@ -0,0 +1,274 @@
+"""
+Image Caching Module for Pre-downloading Images
+
+This module provides async image pre-download functionality to reduce render time.
+Images are downloaded in the background when search results are obtained,
+and cached as base64 data URLs for instant use during rendering.
+"""
+
+import asyncio
+import base64
+import hashlib
+from typing import Dict, List, Optional, Any
+from loguru import logger
+import httpx
+
+
+
+class ImageCache:
+    """
+    Async image cache that pre-downloads images as base64.
+    
+    Usage:
+        cache = ImageCache()
+        
+        # Start pre-downloading images (non-blocking)
+        cache.start_prefetch(image_urls)
+        
+        # Later, get cached image (blocking if not ready)
+        cached_url = await cache.get_cached(url)  # Returns data:image/... or original URL
+    """
+    
+    def __init__(
+        self, 
+        max_size_kb: int = 500,  # Max image size to cache (KB)
+        max_concurrent: int = 6,  # Max concurrent downloads
+    ):
+        self.max_size_bytes = max_size_kb * 1024
+        self.max_concurrent = max_concurrent
+        
+        # Cache storage: url -> base64_data_url or None (if failed)
+        self._cache: Dict[str, Optional[str]] = {}
+        # Pending downloads: url -> asyncio.Task
+        self._pending: Dict[str, asyncio.Task] = {}
+        # Semaphore for concurrent downloads
+        self._semaphore = asyncio.Semaphore(max_concurrent)
+        # Lock for cache access
+        self._lock = asyncio.Lock()
+    
+    def start_prefetch(self, urls: List[str]) -> None:
+        """
+        Start pre-downloading images in the background (non-blocking).
+        
+        Args:
+            urls: List of image URLs to prefetch
+        """
+        if not httpx:
+            logger.warning("ImageCache: httpx not installed, prefetch disabled")
+            return
+            
+        for url in urls:
+            if not url or not url.startswith("http"):
+                continue
+            if url in self._cache or url in self._pending:
+                continue
+            
+            # Create background task
+            task = asyncio.create_task(self._download_image(url))
+            self._pending[url] = task
+    
+    async def _download_image(self, url: str) -> Optional[str]:
+        """
+        Download a single image and convert to base64.
+        
+        Returns:
+            Base64 data URL or None if failed/too large
+        """
+        async with self._semaphore:
+            try:
+                # No timeout - images download until agent ends
+                async with httpx.AsyncClient(timeout=None, 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"
+                    })
+                    resp.raise_for_status()
+                    
+                    # Check content length
+                    content_length = resp.headers.get("content-length")
+                    if content_length and int(content_length) > self.max_size_bytes:
+                        logger.debug(f"ImageCache: Skipping {url} (too large: {content_length} bytes)")
+                        async with self._lock:
+                            self._cache[url] = None
+                            self._pending.pop(url, None)
+                        return None
+                    
+                    # Read content
+                    content = resp.content
+                    if len(content) > self.max_size_bytes:
+                        logger.debug(f"ImageCache: Skipping {url} (content too large: {len(content)} bytes)")
+                        async with self._lock:
+                            self._cache[url] = None
+                            self._pending.pop(url, None)
+                        return None
+                    
+                    # Determine MIME type
+                    content_type = resp.headers.get("content-type", "").lower()
+                    if "jpeg" in content_type or "jpg" in content_type:
+                        mime = "image/jpeg"
+                    elif "png" in content_type:
+                        mime = "image/png"
+                    elif "gif" in content_type:
+                        mime = "image/gif"
+                    elif "webp" in content_type:
+                        mime = "image/webp"
+                    elif "svg" in content_type:
+                        mime = "image/svg+xml"
+                    else:
+                        # Try to infer from URL
+                        url_lower = url.lower()
+                        if ".jpg" in url_lower or ".jpeg" in url_lower:
+                            mime = "image/jpeg"
+                        elif ".png" in url_lower:
+                            mime = "image/png"
+                        elif ".gif" in url_lower:
+                            mime = "image/gif"
+                        elif ".webp" in url_lower:
+                            mime = "image/webp"
+                        elif ".svg" in url_lower:
+                            mime = "image/svg+xml"
+                        else:
+                            mime = "image/jpeg"  # Default fallback
+                    
+                    # Encode to base64
+                    b64 = base64.b64encode(content).decode("utf-8")
+                    data_url = f"data:{mime};base64,{b64}"
+                    
+                    async with self._lock:
+                        self._cache[url] = data_url
+                        self._pending.pop(url, None)
+                    
+                    logger.debug(f"ImageCache: Cached {url} ({len(content)} bytes)")
+                    return data_url
+                    
+            except Exception as e:
+                logger.debug(f"ImageCache: Failed to download {url}: {e}")
+            
+            async with self._lock:
+                self._cache[url] = None
+                self._pending.pop(url, None)
+            return None
+    
+    async def get_cached(self, url: str, wait: bool = True) -> str:
+        """
+        Get cached image data URL, or original URL if not cached.
+        
+        Args:
+            url: Original image URL
+            wait: If True, wait for pending download to complete (no timeout - waits until agent ends)
+            
+        Returns:
+            Cached data URL or original URL
+        """
+        if not url:
+            return url
+            
+        # Check if already cached
+        async with self._lock:
+            if url in self._cache:
+                cached = self._cache[url]
+                return cached if cached else url  # Return original if cached as None (failed)
+            
+            pending_task = self._pending.get(url)
+        
+        # Wait for pending download if requested (no timeout - waits until cancelled)
+        if pending_task and wait:
+            try:
+                await pending_task
+                async with self._lock:
+                    cached = self._cache.get(url)
+                    return cached if cached else url
+            except asyncio.CancelledError:
+                logger.debug(f"ImageCache: Download cancelled for {url}")
+                return url
+            except Exception:
+                return url
+        
+        return url
+    
+    async def get_all_cached(self, urls: List[str]) -> Dict[str, str]:
+        """
+        Get cached URLs for multiple images.
+        
+        Args:
+            urls: List of original URLs
+            
+        Returns:
+            Dict mapping original URL to cached data URL (or original if not cached)
+        """
+        result = {}
+        
+        # Wait for all pending downloads first (no timeout - waits until cancelled)
+        pending_tasks = []
+        async with self._lock:
+            for url in urls:
+                if url in self._pending:
+                    pending_tasks.append(self._pending[url])
+        
+        if pending_tasks:
+            try:
+                await asyncio.gather(*pending_tasks, return_exceptions=True)
+            except asyncio.CancelledError:
+                logger.debug(f"ImageCache: Batch download cancelled")
+        
+        # Collect results
+        for url in urls:
+            async with self._lock:
+                cached = self._cache.get(url)
+            result[url] = cached if cached else url
+            
+        return result
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get cache statistics."""
+        cached_count = sum(1 for v in self._cache.values() if v is not None)
+        failed_count = sum(1 for v in self._cache.values() if v is None)
+        return {
+            "cached": cached_count,
+            "failed": failed_count,
+            "pending": len(self._pending),
+            "total": len(self._cache) + len(self._pending),
+        }
+    
+    def clear(self) -> None:
+        """Clear all cached data."""
+        self._cache.clear()
+        for task in self._pending.values():
+            task.cancel()
+        self._pending.clear()
+
+
+# Global cache instance for reuse across requests
+_global_cache: Optional[ImageCache] = None
+
+
+def get_image_cache() -> ImageCache:
+    """Get or create the global image cache instance."""
+    global _global_cache
+    if _global_cache is None:
+        _global_cache = ImageCache()
+    return _global_cache
+
+
+async def prefetch_images(urls: List[str]) -> None:
+    """
+    Convenience function to start prefetching images.
+    
+    Args:
+        urls: List of image URLs to prefetch
+    """
+    cache = get_image_cache()
+    cache.start_prefetch(urls)
+
+
+async def get_cached_images(urls: List[str]) -> Dict[str, str]:
+    """
+    Convenience function to get cached images.
+    
+    Args:
+        urls: List of original URLs
+        
+    Returns:
+        Dict mapping original URL to cached data URL
+    """
+    cache = get_image_cache()
+    return await cache.get_all_cached(urls)

entari_plugin_hyw/misc.py

@@ -0,0 +1,135 @@
+import json
+import base64
+import httpx
+from typing import Dict, Any, List, Optional
+from loguru import logger
+from arclet.entari import MessageChain, Image
+from typing import Tuple
+import asyncio
+from satori.exception import ActionFailed
+
+def process_onebot_json(data: Dict[str, Any]) -> str:
+    """Process OneBot JSON elements"""
+    try:
+        if "data" in data:
+            json_str = data["data"]
+            if isinstance(json_str, str):
+                json_str = json_str.replace(""", '"').replace(",", ",")
+                content = json.loads(json_str)
+                if "meta" in content and "detail_1" in content["meta"]:
+                    detail = content["meta"]["detail_1"]
+                    if "desc" in detail and "qqdocurl" in detail:
+                        return f"[Shared Document] {detail['desc']}: {detail['qqdocurl']}"
+    except Exception as e:
+        logger.warning(f"Failed to process JSON element: {e}")
+    return ""
+
+
+async def download_image(url: str) -> bytes:
+    """下载图片"""
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            resp = await client.get(url)
+            if resp.status_code == 200:
+                return resp.content
+            else:
+                raise ActionFailed(f"下载图片失败，状态码: {resp.status_code}")
+    except Exception as e:
+        raise ActionFailed(f"下载图片失败: {url}, 错误: {str(e)}")
+
+async def process_images(mc: MessageChain, vision_model: Optional[str] = None) -> Tuple[List[str], Optional[str]]:
+    # If vision model is explicitly set to "off", skip image processing
+    if vision_model == "off":
+        return [], None
+        
+    has_images = bool(mc.get(Image))
+    images = []
+    if has_images:
+        urls = mc[Image].map(lambda x: x.src)
+        tasks = [download_image(url) for url in urls]
+        raw_images = await asyncio.gather(*tasks)
+        import base64
+        images = [base64.b64encode(img).decode('utf-8') for img in raw_images]
+    
+    return images, None
+
+
+def resolve_model_name(name: str, models_config: List[Dict[str, Any]]) -> Tuple[Optional[str], Optional[str]]:
+    """
+    Resolve a user input model name to the full API model name from config.
+    Supports partial matching if unique.
+    """
+    if not name:
+        return None, "No model name provided"
+        
+    name = name.lower()
+    
+    # 1. Exact match (name or id or shortname)
+    for m in models_config:
+        if m.get("name") == name or m.get("id") == name:
+            return m.get("name"), None
+            
+    # 2. Key/Shortcut match
+    # Assuming the config might have keys like 'gpt4' mapping to full name
+    # But usually models list is [{'name': '...', 'provider': '...'}, ...]
+    
+    # Check if 'name' matches any model 'name' partially?
+    # Or just return the name itself if it looks like a valid model ID (contains / or -)
+    if "/" in name or "-" in name or "." in name:
+        return name, None
+        
+    # If not found in config specific list, and doesn't look like an ID, maybe return error
+    # But let's look for partial match in config names
+    matches = [m["name"] for m in models_config if name in m.get("name", "").lower()]
+    if len(matches) == 1:
+        return matches[0], None
+    elif len(matches) > 1:
+        return None, f"Model name '{name}' is ambiguous. Matches: {', '.join(matches[:3])}..."
+        
+    # Default: assume it's a valid ID passed directly
+    return name, None
+
+
+# Hardcoded markdown for refuse answer
+REFUSE_ANSWER_MARKDOWN = """
+<summary>
+Instruct 专家分配此任务流程失败，请尝试提出其他问题~
+</summary>
+"""
+
+
+async def render_refuse_answer(
+    renderer,
+    output_path: str,
+    reason: str = "Instruct 专家分配此任务流程失败，请尝试提出其他问题~",
+    theme_color: str = "#ef4444",
+) -> bool:
+    """
+    Render a refuse-to-answer image using the provided reason.
+    
+    Args:
+        renderer: ContentRenderer instance
+        output_path: Path to save the output image
+        reason: The refusal reason to display
+        theme_color: Theme color for the card
+        
+    Returns:
+        True if render succeeded, False otherwise
+    """
+    markdown = f"""
+# 任务中止
+
+> {reason}
+"""
+    return await renderer.render(
+        markdown_content=markdown,
+        output_path=output_path,
+        stats={},
+        references=[],
+        page_references=[],
+        image_references=[],
+        stages_used=[],
+        image_timeout=1000,
+        theme_color=theme_color,
+    )
+