entari-plugin-hyw 3.2.105__py3-none-any.whl → 3.5.0rc6__py3-none-any.whl

entari_plugin_hyw/__init__.py

@@ -1,20 +1,29 @@
 from dataclasses import dataclass, field
-from typing import List, Dict, Any, Optional
+from importlib.metadata import version as get_version
+from typing import List, Dict, Any, Optional, Union
 import time
+import asyncio
+
+# 从 pyproject.toml 读取版本号，避免重复维护
+try:
+    __version__ = get_version("entari_plugin_hyw")
+except Exception:
+    __version__ = "0.0.0"
 
 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.letoderea import on
 from arclet.entari import MessageChain, Text, Image, MessageCreatedEvent, Quote, At
 from satori.element import Custom
 from loguru import logger
 import arclet.letoderea as leto
 from arclet.entari.event.command import CommandReceive
 
-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
+from .pipeline import ProcessingPipeline
+from .history import HistoryManager
+from .render_vue import ContentRenderer
+from .misc import process_onebot_json, process_images, resolve_model_name, render_refuse_answer, REFUSE_ANSWER_MARKDOWN
+from arclet.entari.event.lifespan import Cleanup
 
 import os
 import secrets
@@ -22,6 +31,32 @@ import base64
 
 import re
 
+
+def parse_color(color: str) -> str:
+    """
+    Parse color from hex or RGB tuple to hex format.
+    Supports: #ff0000, ff0000, (255, 0, 0), 255,0,0
+    """
+    if not color:
+        return "#ef4444"
+    
+    color = str(color).strip()
+    
+    # Hex format: #fff or #ffffff or ffffff
+    if color.startswith('#') and len(color) in [4, 7]:
+        return color
+    if re.match(r'^[0-9a-fA-F]{6}$', color):
+        return f'#{color}'
+    
+    # RGB tuple: (r, g, b) or r,g,b
+    rgb_match = re.match(r'^\(?(\d+)[,\s]+(\d+)[,\s]+(\d+)\)?$', color)
+    if rgb_match:
+        r, g, b = (max(0, min(255, int(x))) for x in rgb_match.groups())
+        return f'#{r:02x}{g:02x}{b:02x}'
+    
+    logger.warning(f"Invalid color '{color}', using default #ef4444")
+    return "#ef4444"
+
 class _RecentEventDeduper:
     def __init__(self, ttl_seconds: float = 30.0, max_size: int = 2048):
         self.ttl_seconds = ttl_seconds
@@ -58,24 +93,23 @@ class HywConfig(BasicConfModel):
     base_url: str = "https://openrouter.ai/api/v1"
     vision_model_name: Optional[str] = None
     vision_api_key: Optional[str] = None
+    language: str = "Simplified Chinese"
     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
-    playwright_mcp_command: str = "npx"
-    playwright_mcp_args: Optional[List[str]] = None
-    search_base_url: str = "https://duckduckgo.com/?q={query}&format=json&results_per_page={limit}"
-    image_search_base_url: str = "https://duckduckgo.com/?q={query}&iax=images&ia=images&format=json&results_per_page={limit}"
+    instruct_model_name: Optional[str] = None
+    instruct_api_key: Optional[str] = None
+    instruct_base_url: 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
+    render_image_timeout_ms: int = 3000
     extra_body: Optional[Dict[str, Any]] = None
+    vision_extra_body: Optional[Dict[str, Any]] = None
+    instruct_extra_body: Optional[Dict[str, Any]] = None
     enable_browser_fallback: bool = False
-    reaction: bool = True
+    reaction: bool = False
     quote: bool = True
     temperature: float = 0.4
     # Billing configuration (price per million tokens)
@@ -85,84 +119,50 @@ class HywConfig(BasicConfModel):
     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
+    instruct_input_price: Optional[float] = None
+    instruct_output_price: Optional[float] = None
+    # Provider Names
+    search_name: str = "DuckDuckGo"
+    search_provider: str = "crawl4ai"  # crawl4ai | httpx | ddgs
+    fetch_provider: str = "crawl4ai"  # crawl4ai | jinaai
+    jina_api_key: Optional[str] = None  # Optional API key for Jina AI
+    model_provider: Optional[str] = None
+    vision_model_provider: Optional[str] = None
+    instruct_model_provider: Optional[str] = None
+    # UI Theme
+    theme_color: str = "#ef4444"  # Tailwind red-500, supports hex/RGB/color names
+    
+    def __post_init__(self):
+        """Parse and normalize theme color after initialization."""
+        self.theme_color = parse_color(self.theme_color)
+
+
 
 conf = plugin_config(HywConfig)
 history_manager = HistoryManager()
 renderer = ContentRenderer()
-hyw = HYW(config=conf)
 
-@listen(Ready, once=True)
-async def _hyw_warmup_mcp():
-    try:
-        await hyw.pipeline.warmup_mcp()
-    except Exception as e:
-        logger.warning(f"MCP Playwright warmup error: {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
 
 global_cache = GlobalCache()
 
-from satori.exception import ActionFailed
-from satori.adapters.onebot11.reverse import _Connection
-
-# Monkeypatch to suppress ActionFailed for get_msg
-original_call_api = _Connection.call_api
-
-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_TO_CODE = {
-    "✨": "10024",
-    "✅": "10004",
-    "❌": "10060"
-}
-
 async def react(session: Session, emoji: str):
     if not conf.reaction: return
     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
+        await session.reaction_create(emoji=emoji)
     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):
+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,
+) -> None:
     logger.info(f"Processing request: {all_param}")
     mc = MessageChain(all_param)
     logger.info(f"reply: {session.reply}")
@@ -242,12 +242,19 @@ async def process_request(session: Session[MessageCreatedEvent], all_param: Opti
 
         images, err = await process_images(mc, vision_model)
 
-        # Call Agent (Step 1)
-        # Sanitize user_input: use extracted text only
+        # Call Pipeline directly
         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)
+        pipeline = ProcessingPipeline(conf)
+        try:
+            resp = await pipeline.execute(
+                safe_input,
+                hist_payload,
+                model_name=model,
+                images=images,
+                selected_vision_model=vision_model,
+            )
+        finally:
+            await pipeline.close()
         
         # Step 1 Results
         step1_vision_model = resp.get("vision_model_used")
@@ -258,73 +265,7 @@ async def process_request(session: Session[MessageCreatedEvent], all_param: Opti
         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
@@ -333,117 +274,45 @@ async def process_request(session: Session[MessageCreatedEvent], all_param: Opti
         
         # Render
         import tempfile
-        with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tf:
+        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 structured.get("mcp_steps"):
-            behavior_summary = "Agentic Loop"
-        elif vision_model_used:
-             behavior_summary = "Visual Analysis"
-        
-        # 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", []),
-            mcp_steps=structured.get("mcp_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
-        )
+        # Check if refuse_answer was triggered
+        if final_resp.get("refuse_answer"):
+            logger.info(f"Refuse answer triggered. Rendering refuse image. Reason: {final_resp.get('refuse_reason', '')}")
+            render_ok = await render_refuse_answer(
+                renderer=renderer,
+                output_path=output_path,
+                theme_color=conf.theme_color,
+            )
+        else:
+            render_ok = await renderer.render(
+                markdown_content=content,
+                output_path=output_path,
+                stats=stats_to_render,
+                references=structured.get("references", []),
+                page_references=structured.get("page_references", []),
+                image_references=structured.get("image_references", []),
+                stages_used=final_resp.get("stages_used", []),
+                image_timeout=conf.render_image_timeout_ms,
+                theme_color=conf.theme_color,
+            )
         
         # Send & Save
         if not render_ok:
-            logger.error("Render failed; skipping reply. Check browser/playwright status.")
+            logger.error("Render failed; skipping reply. Check Crawl4AI rendering status.")
             if os.path.exists(output_path):
                 try:
                     os.remove(output_path)
@@ -506,45 +375,17 @@ async def process_request(session: Session[MessageCreatedEvent], all_param: Opti
             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],
-)
 
-# 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} <问题> : 发起问题
-特性:
-"""
-        )
+    Args["all_param;?", AllParam],
 )
 
-@command.on(alc)
+@command.on(alc)    
 async def handle_question_command(session: Session[MessageCreatedEvent], result: Arparma):
     """Handle main Question command"""
     try:
+        logger.info(f"Question Command Triggered. Message: {result}")
         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):
@@ -558,160 +399,11 @@ async def handle_question_command(session: Session[MessageCreatedEvent], result:
     args = result.all_matched_args
     logger.info(f"Matched Args: {args}")
     
-    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)})")
-    
-    # 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
-    
-    # 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
-            
-        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
-            
-            msg += f"{short_code} {preview}\n"
-        if conf.quote: await session.send([Quote(session.event.message.id), msg])
-        else: await session.send(msg)
-        return
-    
-    selected_vision_model = None
-    selected_text_model = None
-    
-    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}")
-        
-    # 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
-    
-    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}")
-        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)
-            else:
-                cmd_str = str(next_input_val)
-            
-            # Prepend 'next' header for Alconna
-            parse_target = f"next {cmd_str}"
-            
-            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}")
-            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}")
+    await process_request(session, args.get("all_param"), selected_model=None, selected_vision_model=None, conversation_key_override=None, local_mode=False)
 
-    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)
+metadata("hyw", author=[{"name": "kumoSleeping", "email": "zjr2992@outlook.com"}], version=__version__, config=HywConfig)
 
-metadata("hyw", author=[{"name": "kumoSleeping", "email": "zjr2992@outlook.com"}], version="3.2.105", config=HywConfig)
 
-@leto.on(CommandReceive)
+@listen(CommandReceive)
 async def remove_at(content: MessageChain):
-    content = content.lstrip(At)
-    return content
+    return content.lstrip(At)