entari-plugin-hyw 3.3.0__py3-none-any.whl → 3.3.1__py3-none-any.whl

entari_plugin_hyw/__init__.py

@@ -1,818 +1,364 @@
-from dataclasses import dataclass, field
-from typing import List, Dict, Any, Optional, Union
+from dataclasses import dataclass
+import html
 import time
-
-from arclet.alconna import Alconna, Args, AllParam, CommandMeta, Option, Arparma, MultiVar, store_true
-from arclet.entari import metadata, listen, Session, plugin_config, BasicConfModel, plugin, command
-from arclet.entari import MessageChain, Text, Image, MessageCreatedEvent, Quote, At
-from satori.element import Custom
+from collections import deque
+from typing import Any, Deque, Dict, List, Optional, Set, Text, Tuple, Union, TYPE_CHECKING, cast
+from typing_extensions import override
+from arclet.entari import metadata
+from arclet.entari import MessageChain, Session
+from arclet.entari.event.base import MessageEvent
 from loguru import logger
+from satori.exception import ActionFailed
+from arclet.entari import MessageChain, Image, Quote, Text
 import arclet.letoderea as leto
-from arclet.entari.event.command import CommandReceive
+from arclet.entari import MessageCreatedEvent, Session
+from arclet.entari import BasicConfModel, metadata, plugin_config
+import httpx
+import asyncio
+import json
+import re
+from arclet.alconna import (
+    Args,
+    Alconna,
+    AllParam,
+    MultiVar,
+    CommandMeta,
+    Option,
+)
+from arclet.entari import MessageChain, Session, command
+from arclet.entari import plugin, Ready, Cleanup, Startup
+from satori.element import Custom, E
+from .hyw_core import HYW, HYWConfig
+
+# 全局变量
+hyw_core = None
+
+class HistoryManager:
+    def __init__(self, max_records: int = 20):
+        self.max_records = max_records
+        self._order: Deque[str] = deque()
+        self._store: Dict[str, List[dict]] = {}
+        self._bindings: Dict[str, Set[str]] = {}
+        self._msg_map: Dict[str, str] = {}
+
+    def extract_message_id(self, message_like: Any) -> Optional[str]:
+        if message_like is None:
+            return None
+        if isinstance(message_like, (list, tuple)):
+            for item in message_like:
+                mid = self.extract_message_id(item)
+                if mid:
+                    return mid
+            return None
+        if isinstance(message_like, dict):
+            for key in ("message_id", "id"):
+                value = message_like.get(key)
+                if value:
+                    return str(value)
+        for attr in ("message_id", "id"):
+            value = getattr(message_like, attr, None)
+            if value:
+                return str(value)
+        nested = getattr(message_like, "message", None)
+        if nested is not None and nested is not message_like:
+            return self.extract_message_id(nested)
+        return None
+
+    def remove(self, conversation_id: Optional[str], *, remove_from_order: bool = True) -> None:
+        if not conversation_id:
+            return
+        cid = str(conversation_id)
+        if remove_from_order:
+            try:
+                self._order.remove(cid)
+            except ValueError:
+                pass
+        bindings = self._bindings.pop(cid, set())
+        for msg_id in bindings:
+            self._msg_map.pop(msg_id, None)
+        self._store.pop(cid, None)
+
+    def _enforce_limit(self) -> None:
+        while len(self._order) > self.max_records:
+            obsolete = self._order.popleft()
+            self.remove(obsolete, remove_from_order=False)
+
+    def remember(self, conversation_id: Optional[str], history: Optional[List[dict]], related_ids: List[Optional[str]]) -> None:
+        if not conversation_id or not history:
+            return
+        cid = str(conversation_id)
+        self._store[cid] = list(history)
+        binding_ids = {str(mid) for mid in related_ids if mid}
+        self._bindings[cid] = binding_ids
+        for mid in binding_ids:
+            self._msg_map[mid] = cid
+        self._order.append(cid)
+        self._enforce_limit()
+
+    def get_history(self, msg_id: str) -> Optional[List[dict]]:
+        cid = self._msg_map.get(msg_id)
+        if cid:
+            return list(self._store.get(cid, []))
+        return None
+    
+    def get_conversation_id(self, msg_id: str) -> Optional[str]:
+        return self._msg_map.get(msg_id)
 
-from .core.hyw import HYW
-from .core.history import HistoryManager
-from .core.render import ContentRenderer
-from .utils.misc import process_onebot_json, process_images, resolve_model_name
-from arclet.entari.event.lifespan import Startup, Ready, Cleanup
+history_manager = HistoryManager()
 
-import os
-import secrets
-import base64
+# Request lock for HYW agent
+_hyw_request_lock: Optional[asyncio.Lock] = None
+
+def _get_hyw_request_lock() -> asyncio.Lock:
+    global _hyw_request_lock
+    if _hyw_request_lock is None:
+        _hyw_request_lock = asyncio.Lock()
+    return _hyw_request_lock
 
-import re
 
-class _RecentEventDeduper:
-    def __init__(self, ttl_seconds: float = 30.0, max_size: int = 2048):
-        self.ttl_seconds = ttl_seconds
-        self.max_size = max_size
-        self._seen: Dict[str, float] = {}
-
-    def seen_recently(self, key: str) -> bool:
-        now = time.time()
-        if len(self._seen) > self.max_size:
-            self._prune(now)
-        ts = self._seen.get(key)
-        if ts is None or now - ts > self.ttl_seconds:
-            self._seen[key] = now
-            return False
-        return True
-
-    def _prune(self, now: float):
-        expired = [k for k, ts in self._seen.items() if now - ts > self.ttl_seconds]
-        for k in expired:
-            self._seen.pop(k, None)
-        if len(self._seen) > self.max_size:
-            for k, _ in sorted(self._seen.items(), key=lambda kv: kv[1])[: len(self._seen) - self.max_size]:
-                self._seen.pop(k, None)
-
-_event_deduper = _RecentEventDeduper()
-
-@dataclass
 class HywConfig(BasicConfModel):
-    admins: List[str] = field(default_factory=list)
-    models: List[Dict[str, Any]] = field(default_factory=list)
-    question_command: str = "/q"
-    model_name: Optional[str] = None
-    api_key: Optional[str] = None
+    command_name_list: Union[str, List[str]] = "hyw"
+    model_name: str
+    api_key: str
     base_url: str = "https://openrouter.ai/api/v1"
-    vision_model_name: Optional[str] = None
-    vision_api_key: Optional[str] = None
-    vision_base_url: Optional[str] = None
-    vision_system_prompt: Optional[str] = None
-    intruct_model_name: Optional[str] = None
-    intruct_api_key: Optional[str] = None
-    intruct_base_url: Optional[str] = None
-    intruct_system_prompt: Optional[str] = None
-    agent_system_prompt: Optional[str] = None
-    search_base_url: str = "https://lite.duckduckgo.com/lite/?q={query}"
-    image_search_base_url: str = "https://duckduckgo.com/?q={query}&iax=images&ia=images"
     headless: bool = False
     save_conversation: bool = False
-    icon: str = "openai"
-    render_timeout_ms: int = 6000
-    extra_body: Optional[Dict[str, Any]] = None
-    enable_browser_fallback: bool = False
-    reaction: bool = True
-    quote: bool = True
-    temperature: float = 0.4
-    # Billing configuration (price per million tokens)
-    input_price: Optional[float] = None  # $ per 1M input tokens
-    output_price: Optional[float] = None  # $ per 1M output tokens
-    # Vision model pricing overrides (defaults to main model pricing if not set)
-    vision_input_price: Optional[float] = None
-    vision_output_price: Optional[float] = None
-    # Instruct model pricing overrides (defaults to main model pricing if not set)
-    intruct_input_price: Optional[float] = None
-    intruct_output_price: Optional[float] = None
     
-    # Provider Names
-    search_name: str = "DuckDuckGo"
-    search_provider: str = "Crawl4AI"
-    model_provider: Optional[str] = None
-    vision_model_provider: Optional[str] = None
-    intruct_model_provider: Optional[str] = None
+    browser_tool: str = "jina"
+    jina_api_key: Optional[str] = None
     
-    start_test: Optional[Union[str, bool]] = None
-
-conf = plugin_config(HywConfig)
-history_manager = HistoryManager()
-renderer = ContentRenderer()
-hyw = HYW(config=conf)
-
-@listen(Ready, once=True)
-async def _run_ui_test():
-    """Run UI rendering test on startup if configured."""
-    # Debug log to confirm listener is active
-    logger.info(f"UI TEST Listener Active. start_test config: {conf.start_test} (type: {type(conf.start_test)})")
+    vision_model_name: Optional[str] = None
+    vision_base_url: Optional[str] = None
+    vision_api_key: Optional[str] = None
     
-    if not conf.start_test:
-        return
-        
-    test_file = ""
-    if isinstance(conf.start_test, str):
-        test_file = conf.start_test
-    elif conf.start_test is True:
-        # User enabled boolean toggle, assume default path
-        # Try a few locations
-        candidates = ["data/conversations/ui-test.md", "ui-test.md", "README.md"]
-        for c in candidates:
-            if os.path.exists(c):
-                test_file = c
-                break
-        if not test_file:
-            logger.warning("UI TEST: start_test=True but no default test file found (tried: data/conversations/ui-test.md, ui-test.md, README.md)")
-            return
-            
-    logger.info(f"UI TEST: Starting render test with file {test_file}")
+    extra_body: Optional[Dict[str, Any]] = None
     
-    if not os.path.exists(test_file):
-        logger.error(f"UI TEST: File not found: {test_file}")
-        return
-        
-    try:
-        with open(test_file, "r", encoding="utf-8") as f:
-            content = f.read()
-            
-        # Mock Data for Full UI Test
-        stats = {
-            "total_time": 12.5,
-            "vision_duration": 3.2,
-            "cost": 0.0015
-        }
-        
-        stages = [
-            {"name": "Vision", "model": "google/gemini-pro-vision", "time": 3.2, "cost": 0.0005, "provider": "Google", "icon_config": "google"},
-            {"name": "Search", "model": "duckduckgo", "time": 1.5, "cost": 0.0, "provider": "DDG", "icon_config": "search",
-             "children": {"references": [
-                 {"title": "Crawl4AI, Open-source LLM-Friendly Web Crawler & Scraper", "url": "https://docs.crawl4ai.com/core/llmtxt", "domain": "docs.crawl4ai.com"}
-             ]}},
-            {"name": "Crawler", "model": "Crawl4AI", "time": 2.5, "cost": 0.0, "provider": "Page Fetcher", "icon_config": "browser",
-             "children": {"crawled_pages": [
-                 {"title": "Quick Start - Crawl4AI Documentation (v0.7.x)", "url": "https://docs.crawl4ai.com/core/quickstart/", "domain": "docs.crawl4ai.com"},
-                 {"title": "Crawl4AI Explained: The AI-Friendly Web Crawling Framework", "url": "https://scrapfly.io/blog/posts/crawl4AI-explained/", "domain": "scrapfly.io"},
-                 {"title": "Llmtxt - Crawl4AI Documentation (v0.7.x)", "url": "https://docs.crawl4ai.com/core/llmtxt/", "domain": "docs.crawl4ai.com"},
-                 {"title": "Multi-URL Crawling - Crawl4AI Documentation (v0.7.x)", "url": "https://docs.crawl4ai.com/advanced/multi-url-crawling/", "domain": "docs.crawl4ai.com"}
-             ]}},
-            {"name": "Agent", "model": "anthropic/claude-3-5-sonnet", "time": 7.8, "cost": 0.0010, "provider": "Anthropic", "icon_config": "anthropic"}
-        ]
-        
-        # References come from search results
-        references = [
-            {"title": "Crawl4AI, Open-source LLM-Friendly Web Crawler & Scraper", "url": "https://docs.crawl4ai.com/core/llmtxt", "domain": "docs.crawl4ai.com"}
-        ]
-        
-        # Page references come from crawled pages
-        page_references = [
-            {"title": "Quick Start - Crawl4AI Documentation (v0.7.x)", "url": "https://docs.crawl4ai.com/core/quickstart/", "domain": "docs.crawl4ai.com"},
-            {"title": "Crawl4AI Explained: The AI-Friendly Web Crawling Framework", "url": "https://scrapfly.io/blog/posts/crawl4AI-explained/", "domain": "scrapfly.io"},
-            {"title": "Llmtxt - Crawl4AI Documentation (v0.7.x)", "url": "https://docs.crawl4ai.com/core/llmtxt/", "domain": "docs.crawl4ai.com"},
-            {"title": "Multi-URL Crawling - Crawl4AI Documentation (v0.7.x)", "url": "https://docs.crawl4ai.com/advanced/multi-url-crawling/", "domain": "docs.crawl4ai.com"}
-        ]
-        
-        output_dir = "data/cache"
-        os.makedirs(output_dir, exist_ok=True)
-        output_path = f"{output_dir}/ui_test_result.jpg"
-        
-        logger.info(f"UI TEST: Rendering to {output_path}...")
-        
-        start = time.time()
-        success = await renderer.render(
-            markdown_content=content,
-            output_path=output_path,
-            stats=stats,
-            stages_used=stages,
-            references=references,
-            page_references=page_references,
-            flow_steps=[],
-            model_name="CLAUDE-3-5-SONNET",
-            provider_name="Anthropic",
-            behavior_summary="Automated Test",
-            icon_config="anthropic",
-            render_timeout_ms=10000
-        )
-        
-        if success:
-            logger.success(f"UI TEST: Render completed in {time.time() - start:.2f}s. Saved to {output_path}")
-        else:
-            logger.error("UI TEST: Render FAILED.")
-            
-    except Exception as e:
-        logger.error(f"UI TEST: Exception during test: {e}")
-
-
-@listen(Cleanup, once=True)
-async def _hyw_cleanup():
-    try:
-        await hyw.close()
-    except Exception as e:
-        logger.warning(f"HYW cleanup error: {e}")
-
-class GlobalCache:
-    models_image_path: Optional[str] = None
+    enable_browser_fallback: bool = False
+    # verbose: bool = False
+
+metadata(
+    "hyw",
+    author=[{"name": "kumoSleeping", "email": "zjr2992@outlook.com"}],
+    version="3.3.1",
+    description="",
+    config=HywConfig,
+)
 
-global_cache = GlobalCache()
+conf = plugin_config(HywConfig)
+alc = Alconna(
+    conf.command_name_list,
+    Option("-t|--text", dest="text_only", default=False, help_text="仅文本模式(禁用图片识别)"),
+    Args["all_param", AllParam],
+    # Option("-v|--verbose", dest="verbose", default=False, help_text="启用详细日志输出"),
+    meta=CommandMeta(compact=False)
+)
 
-from satori.exception import ActionFailed
-from satori.adapters.onebot11.reverse import _Connection
+# Create HYW configuration
+hyw_config = HYWConfig(
+    api_key=conf.api_key,
+    model_name=conf.model_name,
+    base_url=conf.base_url,
+    save_conversation=conf.save_conversation,
+    headless=conf.headless,
+    browser_tool=conf.browser_tool,
+    jina_api_key=conf.jina_api_key,
+    vision_model_name=conf.vision_model_name,
+    vision_base_url=conf.vision_base_url,
+    vision_api_key=conf.vision_api_key,
+    extra_body=conf.extra_body,
+    enable_browser_fallback=conf.enable_browser_fallback
+)
 
-# Monkeypatch to suppress ActionFailed for get_msg
-original_call_api = _Connection.call_api
+hyw = HYW(config=hyw_config)
 
-async def patched_call_api(self, action: str, params: dict = None):
-    try:
-        return await original_call_api(self, action, params)
-    except ActionFailed as e:
-        if action == "get_msg":
-            logger.warning(f"Suppressed ActionFailed for get_msg: {e}")
-            return None
-        raise e
 
-_Connection.call_api = patched_call_api
 
+# Emoji到代码的映射字典
 EMOJI_TO_CODE = {
+    "🐳": "128051",
+    "❌": "10060",
+    "🍧": "127847",
     "✨": "10024",
-    "✅": "10004",
-    "❌": "10060"
+    "📫": "128235"
 }
 
-async def react(session: Session, emoji: str):
-    if not conf.reaction: return
+async def download_image(url: str) -> bytes:
+    """下载图片"""
     try:
-        if session.event.login.platform == "onebot":
-            code = EMOJI_TO_CODE.get(emoji, "10024")
-            # OneBot specific reaction
-            await session.account.protocol.call_api(
-                "internal/set_group_reaction", 
-                {
-                    "group_id": str(session.guild.id), 
-                    "message_id": str(session.event.message.id), 
-                    "code": code, 
-                    "is_add": True
-                }
-            )
-        else:
-            # Standard Satori reaction
-            await session.reaction_create(emoji=emoji)
-    except ActionFailed:
-        pass
-    except Exception as e:
-        logger.warning(f"Reaction failed: {e}")
-
-async def process_request(session: Session[MessageCreatedEvent], all_param: Optional[MessageChain] = None, 
-                         selected_model: Optional[str] = None, selected_vision_model: Optional[str] = None, 
-                         conversation_key_override: Optional[str] = None, local_mode: bool = False,
-                         next_prompt: Optional[str] = None, next_text_model: Optional[str] = None, next_vision_model: Optional[str] = None):
-    logger.info(f"Processing request: {all_param}")
-    mc = MessageChain(all_param)
-    logger.info(f"reply: {session.reply}")
-    if session.reply:
-        try:
-            # Check if reply is from self (the bot)
-            # 1. Check by Message ID (reliable for bot's own messages if recorded)
-            reply_msg_id = str(session.reply.origin.id) if hasattr(session.reply.origin, 'id') else None
-            is_bot = False
-            
-            if reply_msg_id and history_manager.is_bot_message(reply_msg_id):
-                is_bot = True
-                logger.info(f"Reply target {reply_msg_id} identified as bot message via history")
-
-            if is_bot:
-                logger.info("Reply is from me - ignoring content")
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            resp = await client.get(url)
+            if resp.status_code == 200:
+                return resp.content
             else:
-                logger.info(f"Reply is from user (or unknown) - including content")
-                mc.extend(MessageChain(" ") + session.reply.origin.message)
-        except Exception as e:
-            logger.warning(f"Failed to process reply origin: {e}")
-            mc.extend(MessageChain(" ") + session.reply.origin.message)
-    
-    # Filter and reconstruct MessageChain
-    filtered_elements = mc.get(Text) + mc.get(Image) + mc.get(Custom)
-    mc = MessageChain(filtered_elements)
-    logger.info(f"mc: {mc}")
-
-    text_content = str(mc.get(Text)).strip()
-    # Remove HTML image tags from text content to prevent "unreasonable code behavior"
-    text_content = re.sub(r'<img[^>]+>', '', text_content, flags=re.IGNORECASE)
-
-    if not text_content and not mc.get(Image) and not mc.get(Custom):
-        return
-
-    # History & Context
-    hist_key = conversation_key_override
-    if not hist_key and session.reply and hasattr(session.reply.origin, 'id'):
-        hist_key = history_manager.get_conversation_id(str(session.reply.origin.id))
-    
-    hist_payload = history_manager.get_history(hist_key) if hist_key else []
-    meta = history_manager.get_metadata(hist_key) if hist_key else {}
-    context_id = f"guild_{session.guild.id}" if session.guild else f"user_{session.user.id}"
+                raise ActionFailed(f"下载图片失败，状态码: {resp.status_code}")
+    except Exception as e:
+        raise ActionFailed(f"下载图片失败: {url}, 错误: {str(e)}")
 
-    if conf.reaction: await react(session, "✨")
 
+def process_onebot_json(json_data_str: str) -> str:
     try:
-        msg_text = str(mc.get(Text)).strip() if mc.get(Text) else ""
-        msg_text = re.sub(r'<img[^>]+>', '', msg_text, flags=re.IGNORECASE)
-        
-        # If message is empty but has images, use a placeholder
-        if not msg_text and (mc.get(Image) or mc.get(Custom)):
-             msg_text = "[图片]"
-        
-        for custom in [e for e in mc if isinstance(e, Custom)]:
-            if custom.tag == 'onebot:json':
-                if decoded := process_onebot_json(custom.attributes()): msg_text += f"\n{decoded}"
-                break
-        
-        # Model Selection (Step 1)
-        # Resolve model names from config if they are short names/keywords
-        model = selected_model or meta.get("model")
-        if model and model != "off":
-            resolved, err = resolve_model_name(model, conf.models)
-            if resolved:
-                model = resolved
-            elif err:
-                logger.warning(f"Model resolution warning for {model}: {err}")
-
-        vision_model = selected_vision_model or meta.get("vision_model")
-        if vision_model and vision_model != "off":
-            resolved_v, err_v = resolve_model_name(vision_model, conf.models)
-            if resolved_v:
-                vision_model = resolved_v
-            elif err_v:
-                logger.warning(f"Vision model resolution warning for {vision_model}: {err_v}")
-
-        images, err = await process_images(mc, vision_model)
-
-        # Call Agent (Step 1)
-        # Sanitize user_input: use extracted text only
-        safe_input = msg_text
-            
-        resp = await hyw.agent(safe_input, conversation_history=hist_payload, images=images, 
-                              selected_model=model, selected_vision_model=vision_model, local_mode=local_mode)
-        
-        # Step 1 Results
-        step1_vision_model = resp.get("vision_model_used")
-        step1_model = resp.get("model_used")
-        step1_history = resp.get("conversation_history", [])
-        step1_stats = resp.get("stats", {})
-        
-        final_resp = resp
-        
-        # Step 2 (Optional)
-        if next_prompt:
-            logger.info(f"Executing Step 2 with prompt: {next_prompt}")
-            
-            # Use Step 1 history as base for Step 2
-            # hyw.agent already returns the updated history including the new turn
-            # So we just pass step1_history
-            
-            # Determine Step 2 models
-            # If not specified, inherit from Step 1 or config? 
-            # Usually inherit from config or meta if not specified in -n
-            step2_model = next_text_model or model
-            if step2_model and step2_model != "off":
-                resolved_s2, err_s2 = resolve_model_name(step2_model, conf.models)
-                if resolved_s2:
-                    step2_model = resolved_s2
-            
-            step2_vision_model = next_vision_model or vision_model # Probably not used if no new images, but consistent
-            if step2_vision_model and step2_vision_model != "off":
-                resolved_s2v, err_s2v = resolve_model_name(step2_vision_model, conf.models)
-                if resolved_s2v:
-                    step2_vision_model = resolved_s2v
-            
-            # No new images for Step 2 usually, unless we want to carry over images?
-            # The user said "First round image model, second round text model".
-            # Usually Step 2 is text-only follow-up.
-            # But hyw.agent stateless? No, we pass history.
-            # We don't pass 'images' again to Step 2 unless we want them re-analyzed.
-            # If Step 1 analyzed images, the analysis is in history (as assistant message or system message?).
-            # In hyw.agent, image analysis result is added to history.
-            # So we don't need to pass images again.
-            
-            resp2 = await hyw.agent(str(next_prompt), conversation_history=step1_history, images=None,
-                                   selected_model=step2_model, selected_vision_model=step2_vision_model, local_mode=local_mode)
-            
-            final_resp = resp2
-            
-            # Merge Stats
-            # Instead of merging into a single dict, we prepare a list of stats for the renderer
-            # But we also need a combined stats for history recording?
-            # History manager likely expects a single dict or doesn't care much (it stores what we give)
-            
-            # Let's keep step1_stats and resp2["stats"] separate for rendering
-            # But for history, maybe we still want a merged one?
-            # The code below uses final_resp["stats"] for rendering AND history.
-            
-            # Let's create a list for rendering
-            stats_for_render = [step1_stats, resp2.get("stats", {})]
-            
-            # And a merged one for history/final_resp
-            merged_stats = step1_stats.copy()
-            if "stats" in resp2:
-                for k, v in resp2["stats"].items():
-                    if isinstance(v, (int, float)) and k in merged_stats:
-                        merged_stats[k] += v
-                    elif k == "visited_domains":
-                        merged_stats[k] = list(set(merged_stats.get(k, []) + v))
-                    else:
-                        merged_stats[k] = v
-            
-            final_resp["stats"] = merged_stats
-            final_resp["stats_list"] = stats_for_render # Pass this to renderer if available
-            
-            # Merge Model Info for Display
-            # We want to show Step 1 Vision Model AND Step 2 Text Model
-            if step1_vision_model:
-                final_resp["vision_model_used"] = step1_vision_model
-            # final_resp["model_used"] is already from Step 2
-            
-        
-        # Extract Response Data
-        content = final_resp.get("llm_response", "")
-        structured = final_resp.get("structured_response", {})
-        
-        # Render
-        import tempfile
-        with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tf:
-            output_path = tf.name
-        model_used = final_resp.get("model_used")
-        vision_model_used = final_resp.get("vision_model_used")
-        
-        # Helper to infer icon from model name
-        def infer_icon_from_model(model_name: str) -> str:
-            """Infer icon name from model name (e.g. 'google/gemini-3-flash' -> 'google' or 'gemini')"""
-            if not model_name:
-                return conf.icon
-            name_lower = model_name.lower()
-            # Check for known providers/models in the name
-            known_icons = ["google", "gemini", "openai", "anthropic", "deepseek", "mistral", 
-                          "qwen", "grok", "xai", "perplexity", "microsoft", "minimax", "nvidia"]
-            for icon_name in known_icons:
-                if icon_name in name_lower:
-                    return icon_name
-            return conf.icon
-        
-        icon = conf.icon
-        m_conf = None
-        if model_used:
-            m_conf = next((m for m in conf.models if m.get("name") == model_used), None)
-            if m_conf:
-                icon = m_conf.get("icon", infer_icon_from_model(model_used))
-            else:
-                # Model not in config list, infer from name
-                icon = infer_icon_from_model(model_used)
-
-        # Determine session short code
-        if hist_key:
-            display_session_id = history_manager.get_code_by_key(hist_key)
-            if not display_session_id:
-                # Should not happen if key exists, but fallback
-                display_session_id = history_manager.generate_short_code()
-        else:
-            # New conversation, pre-generate code
-            display_session_id = history_manager.generate_short_code()
-
-        # Determine vision base url and icon
-        vision_base_url = None
-        vision_icon = None
-        
-        if vision_model_used:
-            v_conf = next((m for m in conf.models if m.get("name") == vision_model_used), None)
-            if v_conf:
-                vision_base_url = v_conf.get("base_url")
-                vision_icon = v_conf.get("icon", infer_icon_from_model(vision_model_used))
-            else:
-                vision_icon = infer_icon_from_model(vision_model_used)
-        
-        # Handle Vision Only Mode (suppress text model display)
-        render_model_name = model_used or conf.model_name or "unknown"
-        render_icon = icon
-        render_base_url = m_conf.get("base_url", conf.base_url) if m_conf else conf.base_url
-        
-        if not model_used and vision_model_used:
-            render_model_name = ""
-            render_icon = ""
-
-        # Use stats_list if available, otherwise standard stats
-        stats_to_render = final_resp.get("stats_list", final_resp.get("stats", {}))
-
-        # Determine Behavior Summary & Provider Name
-        
-        # 1. Behavior Summary
-        behavior_summary = "Text Generation"
-        if vision_model_used:
-             behavior_summary = "Visual Analysis"
-        elif any(s.get("name") == "Search" for s in final_resp.get("stages_used", []) or []):
-            behavior_summary = "Search-Augmented"
-        
-        # 2. Provider Name
-        # Try to get from m_conf (resolved above)
-        provider_name = "Unknown Provider"
-        if model_used and m_conf:
-            provider_name = m_conf.get("provider", "Unknown Provider")
-        elif not model_used and vision_model_used:
-             # If only vision model used (unlikely but possible in code logic)
-             if 'v_conf' in locals() and v_conf:
-                 provider_name = v_conf.get("provider", "Unknown Provider")
-        
-        # If still unknown and we have base_url, maybe use domain as last resort fallback?
-        # User said: "provider does not automatically get from url if not filled"
-        # So if it's "Unknown Provider", we leave it or maybe empty string?
-        # Let's stick to "Unknown Provider" or just empty if we want to be clean.
-        # But for UI validation it's better to show something if missing config.
-             
-        render_ok = await renderer.render(
-            markdown_content=content,
-            output_path=output_path,
-            suggestions=[],
-            stats=stats_to_render,
-            references=structured.get("references", []),
-            page_references=structured.get("page_references", []),
-            flow_steps=structured.get("flow_steps", []),
-            stages_used=final_resp.get("stages_used", []),
-            model_name=render_model_name,
-            provider_name=provider_name,
-            behavior_summary=behavior_summary,
-            icon_config=render_icon,
-            vision_model_name=vision_model_used,
-            vision_base_url=vision_base_url,
-            vision_icon_config=vision_icon,
-            base_url=render_base_url,
-            billing_info=final_resp.get("billing_info"),
-            render_timeout_ms=conf.render_timeout_ms
-        )
-        
-        # Send & Save
-        if not render_ok:
-            logger.error("Render failed; skipping reply. Check Crawl4AI rendering status.")
-            if os.path.exists(output_path):
-                try:
-                    os.remove(output_path)
-                except Exception as exc:
-                    logger.warning(f"Failed to delete render output {output_path}: {exc}")
-            sent = None
-        else:
-            # Convert to base64
-            with open(output_path, "rb") as f:
-                img_data = base64.b64encode(f.read()).decode()
-                
-            # Build single reply chain (image only now)
-            elements = []
-            elements.append(Image(src=f'data:image/png;base64,{img_data}'))
-
-            msg_chain = MessageChain(*elements)
-            
-            if conf.quote:
-                msg_chain = MessageChain(Quote(session.event.message.id)) + msg_chain
-                
-            # Use reply_to instead of manual Quote insertion to avoid ActionFailed errors
-            sent = await session.send(msg_chain)
-        
-        sent_id = next((str(e.id) for e in sent if hasattr(e, 'id')), None) if sent else None
-        msg_id = str(session.event.message.id) if hasattr(session.event, 'message') else str(session.event.id)
-        related = [msg_id] + ([str(session.reply.origin.id)] if session.reply and hasattr(session.reply.origin, 'id') else [])
-        
-        history_manager.remember(
-            sent_id,
-            final_resp.get("conversation_history", []),
-            related,
-            {
-                "model": model_used,
-                "trace_markdown": final_resp.get("trace_markdown"),
-            },
-            context_id,
-            code=display_session_id,
-        )
-        
-        if conf.save_conversation and sent_id:
-            history_manager.save_to_disk(sent_id)
-
-
+        # 解码HTML实体
+        json_str = html.unescape(json_data_str)
+        return json_str
     except Exception as e:
-        logger.exception(f"Error: {e}")
-        err_msg = f"Error: {e}"
-        if conf.quote:
-             await session.send([Quote(session.event.message.id), err_msg])
-        else:
-             await session.send(err_msg)
-        
-        # Save conversation on error if response was generated
-        if 'resp' in locals() and resp and conf.save_conversation:
-            try:
-                # Use a temporary ID for error cases
-                error_id = f"error_{int(time.time())}_{secrets.token_hex(4)}"
-                history_manager.remember(error_id, resp.get("conversation_history", []), [], {"model": model_used if 'model_used' in locals() else "unknown", "error": str(e)}, context_id, code=display_session_id if 'display_session_id' in locals() else None)
-                history_manager.save_to_disk(error_id)
-                logger.info(f"Saved error conversation to {error_id}")
-            except Exception as save_err:
-                logger.error(f"Failed to save error conversation: {save_err}")
-
-# Secondary Parser for -n content
-next_alc = Alconna(
-    "next",
-    Option("-v|--vision", Args["vision_model", str], help_text="设置视觉模型(设为off禁用)"),
-    Option("-t|--text", Args["text_model", str], help_text="设置文本模型"),
-    Args["prompt", AllParam],
-)
+        return json_data_str
 
-# Main Command (Question)
-alc = Alconna(
-    conf.question_command,
-    Option("-v|--vision", Args["vision_model", str]),
-    Option("-t|--text", Args["text_model", str]),
-    Option("-c|--code", Args["code", str]),
-    Option("-n|--next", Args["next_input", AllParam]),
-    Args["list_models;?", "-m|--models"],
-    Args["all_chat;?", "-a"],
-    Args["local_mode;?", "-l"],
-    Args["all_param?", MultiVar(str | Image | Custom)],
-    meta=CommandMeta(
-        compact=False, 
-        description=f"""使用方法:
-        {conf.question_command} -a : 列出所有会话
-        {conf.question_command} -m : 列出所有模型
-        {conf.question_command} -v <模型名> : 设置主要视觉模型, 设为 off 禁用
-        {conf.question_command} -t <模型名> : 设置主要文本模型
-        {conf.question_command} -l : 开启本地模式 (关闭Web索引)
-        {conf.question_command} -c <4位消息码> : 继续指定会话
-        {conf.question_command} -n <后续提示词> : 在第一步完成后执行后续操作 (支持 -t/-v)
-        {conf.question_command} <问题> : 发起问题
-特性:
-"""
-        )
-)
 
-@command.on(alc)
-async def handle_question_command(session: Session[MessageCreatedEvent], result: Arparma):
-    """Handle main Question command"""
+async def react(session: Session, emoji: str):
     try:
-        mid = str(session.event.message.id) if getattr(session.event, "message", None) else str(session.event.id)
-        dedupe_key = f"{getattr(session.account, 'id', 'account')}:{mid}"
-        if _event_deduper.seen_recently(dedupe_key):
-            logger.warning(f"Duplicate command event ignored: {dedupe_key}")
-            return
-    except Exception:
+        if session.event.login.platform == "onebot":
+            code = EMOJI_TO_CODE.get(emoji, "10024")
+            await session.account.protocol.call_api("internal/set_group_reaction", {"group_id": int(session.guild.id), "message_id": int(session.event.message.id), "code": code, "is_add": True})
+        else:
+            await session.reaction_create(emoji=emoji)
+    except ActionFailed:
         pass
 
-    logger.info(f"Question Command Triggered. Message: {session.event.message}")
+def handle_shortcut(message_chain: MessageChain) -> Tuple[bool, str]:
+    current_msg_text = str(message_chain.get(Text)) if message_chain.get(Text) else ""
+    is_shortcut = False
+    shortcut_replacement = ""
+    if current_msg_text.strip().startswith("/"):
+        is_shortcut = True
+        shortcut_replacement = current_msg_text.strip()[1:]
+    return is_shortcut, shortcut_replacement
+
+async def process_images(mc: MessageChain, parse_result: Any) -> Tuple[List[str], Optional[str]]:
+    is_text_only = False
+    if parse_result.matched:
+        def get_bool_value(val):
+            if hasattr(val, 'value'):
+                return bool(val.value)
+            return bool(val)
+        is_text_only = get_bool_value(getattr(parse_result, 'text_only', False))
     
-    args = result.all_matched_args
-    logger.info(f"Matched Args: {args}")
+    text_str = str(mc.get(Text) or "")
+    if not is_text_only and re.search(r'(?:^|\s)(-t|--text)(?:$|\s)', text_str):
+        is_text_only = True
     
-    text_model_val = args.get("text_model")
-    vision_model_val = args.get("vision_model")
-    code_val = args.get("code")
-    all_flag_val = args.get("all_chat")
-    list_models_val = args.get("list_models")
-    local_mode_val = True if args.get("local_mode") else False
-    logger.info(f"Local mode: {local_mode_val} (type: {type(local_mode_val)})")
+    if is_text_only:
+        logger.info("检测到仅文本模式参数，跳过图片分析")
+        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]
     
-    # Handle -m (List Models)
-    if list_models_val:
-        # global_cache is already imported/defined in __init__.py
-        
-        if global_cache.models_image_path and os.path.exists(global_cache.models_image_path):
-            logger.info(f"Using cached models list: {global_cache.models_image_path}")
-            with open(global_cache.models_image_path, "rb") as f:
-                img_data = base64.b64encode(f.read()).decode()
-            msg = MessageChain(Image(src=f'data:image/png;base64,{img_data}'))
-            if conf.quote: msg = MessageChain(Quote(session.event.message.id)) + msg
-            await session.send(msg)
-            return
-
-        output_dir = "data/cache"
-        os.makedirs(output_dir, exist_ok=True)
-        output_path = f"{output_dir}/models_list_cache.png"
-        
-        await renderer.render_models_list(
-            conf.models,
-            output_path,
-            default_base_url=conf.base_url,
-            render_timeout_ms=conf.render_timeout_ms,
-        )
-        global_cache.models_image_path = os.path.abspath(output_path)
-        
-        with open(output_path, "rb") as f:
-            img_data = base64.b64encode(f.read()).decode()
-        msg = MessageChain(Image(src=f'data:image/png;base64,{img_data}'))
-        if conf.quote: msg = MessageChain(Quote(session.event.message.id)) + msg
-        await session.send(msg)
+    return images, None
+
+@leto.on(MessageCreatedEvent)
+async def on_message_created(message_chain: MessageChain, session: Session[MessageEvent]):
+    # Skip if no substantial content in original message
+    original_text = str(message_chain.get(Text)).strip()
+    has_images = bool(message_chain.get(Image))
+    has_custom = bool(message_chain.get(Custom))
+    if not original_text and not has_images and not has_custom:
         return
     
-    # Handle -a (List History)
-    if all_flag_val:
-        context_id = f"guild_{session.guild.id}" if session.guild else f"user_{session.user.id}"
-        keys = history_manager.list_by_context(context_id, limit=10)
-        if not keys:
-            msg = "暂无历史会话"
-            if conf.quote: await session.send([Quote(session.event.message.id), msg])
-            else: await session.send(msg)
-            return
+    if session.reply:
+        try:
+            message_chain.extend(MessageChain(" ") + session.reply.origin.message)
+        except Exception:
+            pass
             
-        msg = "历史会话 [最近10条]\n"
-        for i, key in enumerate(keys):
-            short_code = history_manager.get_code_by_key(key) or "????"
-            hist = history_manager.get_history(key)
-            preview = "..."
-            if hist and len(hist) > 0:
-                last_content = hist[-1].get("content", "")
-                preview = (last_content[:20] + "...") if len(last_content) > 20 else last_content
+    message_chain = message_chain.get(Text) + message_chain.get(Image) + message_chain.get(Custom)
+    
+    quoted_message_id: Optional[str] = None
+    conversation_history_key: Optional[str] = None
+    conversation_history_payload: List[dict] = []
+    
+    if session.reply:
+        try:
+            quoted_message_id = str(session.reply.origin.id) if hasattr(session.reply.origin, 'id') else None
+        except Exception as e:
+            logger.warning(f"提取引用消息ID失败: {e}")
+            quoted_message_id = None
             
-            msg += f"{short_code} {preview}\n"
-        if conf.quote: await session.send([Quote(session.event.message.id), msg])
-        else: await session.send(msg)
-        return
+        if quoted_message_id:
+            conversation_history_key = history_manager.get_conversation_id(quoted_message_id)
+            if conversation_history_key:
+                conversation_history_payload = history_manager.get_history(quoted_message_id) or []
+                logger.info(f"继续对话模式触发, 引用消息ID: {quoted_message_id}, 历史长度: {len(conversation_history_payload)}")
+
+    parse_result = alc.parse(message_chain)
+    is_shortcut, shortcut_replacement = handle_shortcut(message_chain)
     
-    selected_vision_model = None
-    selected_text_model = None
+    should_process = parse_result.matched or (bool(conversation_history_key) and is_shortcut)
     
-    if vision_model_val:
-        if vision_model_val.lower() == "off":
-            selected_vision_model = "off"
-        else:
-            selected_vision_model, err = resolve_model_name(vision_model_val, conf.models)
-            if err:
-                if conf.quote: await session.send([Quote(session.event.message.id), err])
-                else: await session.send(err)
-                return
-        logger.info(f"Selected vision model: {selected_vision_model}")
-        
-    if text_model_val:
-        selected_text_model, err = resolve_model_name(text_model_val, conf.models)
-        if err:
-            if conf.quote: await session.send([Quote(session.event.message.id), err])
-            else: await session.send(err)
-            return
-        logger.info(f"Selected text model: {selected_text_model}")
+    if not should_process:
+        return
+
+    raw_param_chain: MessageChain = parse_result.all_param if parse_result.matched else message_chain  # type: ignore
+    if not parse_result.matched and is_shortcut:
+        logger.debug(f"触发快捷指令，替换内容: {shortcut_replacement}")
         
-    # Determine History to Continue
-    target_key = None
-    context_id = f"guild_{session.guild.id}" if session.guild else f"user_{session.user.id}"
-    
-    # 1. Explicit Code
-    if code_val:
-        target_code = code_val
-        target_key = history_manager.get_key_by_code(target_code)
-        if not target_key:
-            msg = f"未找到代码为 {target_code} 的会话"
-            if conf.quote: await session.send([Quote(session.event.message.id), msg])
-            else: await session.send(msg)
-            return
-        logger.info(f"Question: Continuing session {target_code} -> {target_key}")
-                
-    next_input_val = args.get("next_input")
-    next_text_model = None
-    next_vision_model = None
-    next_prompt = None
+    mc = MessageChain(raw_param_chain)
     
-    if next_input_val:
-        # Parse secondary command
-        # next_input_val is likely a MessageChain or string depending on AllParam behavior with Alconna
-        # We need to ensure it's a string or compatible input for parse
-        logger.info(f"Parsing next input: {next_input_val}")
+    async def process_request() -> None:
+        await react(session, "✨")
         try:
-            # Convert next_input_val to string
-            if isinstance(next_input_val, list):
-                # It's a list of segments (e.g. [Text(...)])
-                # We need to join them into a string
-                # Assuming they are Satori elements or similar
-                cmd_str = "".join(str(x) for x in next_input_val)
+            if is_shortcut and not parse_result.matched:
+                msg = shortcut_replacement
             else:
-                cmd_str = str(next_input_val)
+                msg = mc.get(Text).strip() if mc.get(Text) else ""
             
-            # Prepend 'next' header for Alconna
-            parse_target = f"next {cmd_str}"
+            if mc.get(Custom): # type: ignore
+                custom_elements = [e for e in mc if isinstance(e, Custom)]
+                for custom in custom_elements:
+                    if custom.tag == 'onebot:json':
+                        decoded_json = process_onebot_json(custom.attributes())
+                        msg += decoded_json
+                        break
             
-            next_res = next_alc.parse(parse_target)
-            if next_res.matched:
-                next_args = next_res.all_matched_args
-                next_text_model = next_args.get("text_model")
-                next_vision_model = next_args.get("vision_model")
-                next_prompt = next_args.get("prompt")
-                
-                # If prompt is AllParam, it might be captured as a list or string depending on Alconna version
-                # If it's a list, join it back to string
-                if isinstance(next_prompt, list):
-                     next_prompt = "".join(str(x) for x in next_prompt)
-                
-                logger.info(f"Next Command Parsed: text={next_text_model}, vision={next_vision_model}, prompt={next_prompt}")
+            time_start = time.perf_counter()
+            images, error_msg = await process_images(mc, parse_result)
+            
+            if error_msg:
+                await session.send(error_msg)
+                return
+
+            lock = _get_hyw_request_lock()
+            async with lock:
+                response = await hyw.agent(str(msg), conversation_history=conversation_history_payload, images=images)
+            
+            response_content = response.get("llm_response", "") if isinstance(response, dict) else ""
+            new_history = response.get("conversation_history", []) if isinstance(response, dict) else []
+            
+            try:
+                send_result = await session.send([Quote(session.event.message.id), response_content])
+            except ActionFailed as e:
+                if "9057" in str(e):
+                    logger.warning(f"发送消息失败(9057)，尝试截断发送: {e}")
+                    truncated_content = response_content[:1000] + "\n\n[...内容过长，已大幅截断...]"
+                    send_result = await session.send([Quote(session.event.message.id), truncated_content])
+                else:
+                    raise e
+            
+            sent_message_id = history_manager.extract_message_id(send_result)
+            current_user_message_id = str(session.event.message.id)
+            related_ids: List[Optional[str]] = [current_user_message_id, sent_message_id]
+            
+            if conversation_history_key:
+                history_manager.remove(conversation_history_key)
+                related_ids.append(quoted_message_id)
+            
+            # Check turn limit
+            user_turns = len([m for m in new_history if m.get("role") == "user"])
+            if user_turns < 5:
+                history_manager.remember(sent_message_id, new_history, related_ids)
             else:
-                logger.warning(f"Next command parsing failed or no match for: {parse_target}")
-                # Fallback: treat the whole string as prompt if parsing failed (e.g. if it didn't match options but Alconna should have matched prompt)
-                # But next_alc has Args["prompt", AllParam], so it should match everything else.
-                # If it failed, maybe something else is wrong.
-                # Let's assume if it failed, we just use the raw string as prompt?
-                # But wait, if we prepend "next ", and next_alc starts with "next", it should match.
-                pass
-        except Exception as e:
-            logger.error(f"Failed to parse next command: {e}")
+                logger.info(f"对话轮数达到上限 ({user_turns})，停止记录历史")
+            
+        except Exception as exc:
+            await react(session, "❌")
+            logger.exception("处理HYW消息失败: {}", exc)
 
-    await process_request(session, args.get("all_param"), selected_model=selected_text_model, selected_vision_model=selected_vision_model, conversation_key_override=target_key, local_mode=local_mode_val, 
-                         next_prompt=next_prompt, next_text_model=next_text_model, next_vision_model=next_vision_model)
+    asyncio.create_task(process_request())
+    return
 
-metadata("hyw", author=[{"name": "kumoSleeping", "email": "zjr2992@outlook.com"}], version="3.2.105", config=HywConfig)
 
-@leto.on(CommandReceive)
-async def remove_at(content: MessageChain):
-    content = content.lstrip(At)
-    return content