myagent-ai 1.18.2 → 1.18.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myagent-ai",
-  "version": "1.18.2",
+  "version": "1.18.4",
   "description": "本地桌面端执行型AI助手 - Open Interpreter 风格 | Local Desktop Execution-Oriented AI Assistant",
   "main": "main.py",
   "bin": {

package/skills/chromedev_mcp.py

@@ -383,6 +383,11 @@ class MCPClient:
                     pass
         except Exception:
             pass
+        finally:
+            # [v1.18.3] stdout EOF = MCP Server 或 Chrome 已断开
+            # 标记为未初始化，下次 call_tool 会自动重建
+            self._initialized = False
+            logger.warning("MCP stdout 读取结束（Server 或 Chrome 已断开）")
 
     async def _handshake(self) -> bool:
         """执行 MCP 初始化握手"""
@@ -552,7 +557,12 @@ class MCPClient:
         self._cleanup()
 
     def _cleanup(self):
-        """清理子进程"""
+        """清理子进程（包括 Chrome/Chromium 浏览器）
+
+        [v1.18.3] 修复 'Target closed' 问题：
+        终止 MCP Server 后，额外杀死残留的 Chrome 进程，
+        避免下次启动时因锁文件冲突导致 'Target closed'。
+        """
         self._initialized = False
         if self._process:
             try:
@@ -569,6 +579,48 @@ class MCPClient:
                     pass
             self._process = None
 
+        # [v1.18.3] 清理残留的 Chrome/Chromium 进程
+        # chrome-devtools-mcp 启动的 Chrome 可能不会随 MCP 进程一起退出
+        self._kill_stale_chrome()
+
+    def _kill_stale_chrome(self):
+        """清理残留的 Chrome/Chromium 进程
+
+        查找并杀死由 chrome-devtools-mcp 启动的 Chrome 进程。
+        这些进程可能导致下次启动时 'Target closed' 错误。
+        """
+        import signal as _sig
+        try:
+            # 查找 chrome-devtools-mcp 启动的 Chrome 进程
+            # 特征: 父进程是 node/npx (chrome-devtools-mcp)
+            result = subprocess.run(
+                ["pgrep", "-f", "chromium-browser.*--remote-debugging-port"],
+                capture_output=True, text=True, timeout=5,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                pids = result.stdout.strip().split("\n")
+                for pid_str in pids:
+                    try:
+                        pid = int(pid_str)
+                        os.kill(pid, _sig.SIGTERM)
+                        logger.debug(f"清理残留 Chrome 进程: PID={pid}")
+                    except (ProcessLookupError, PermissionError, ValueError):
+                        pass
+
+                # 等一小会让 Chrome 优雅退出
+                import time
+                time.sleep(0.5)
+
+                # 还没退就强杀
+                for pid_str in pids:
+                    try:
+                        pid = int(pid_str)
+                        os.kill(pid, _sig.SIGKILL)
+                    except (ProcessLookupError, PermissionError, ValueError):
+                        pass
+        except Exception as e:
+            logger.debug(f"清理 Chrome 进程异常: {e}")
+
     def is_running(self) -> bool:
         """检查 MCP Server 是否正在运行"""
         return self._process is not None and self._process.poll() is None
@@ -849,17 +901,13 @@ class BrowserOpenSkill(Skill):
                                   f"请执行: apt install -y chromium-browser 或 apt install -y chromium，"
                                   f"安装后重试即可。"
                         )
-                    # [v1.16.18] 检测 Chrome 崩溃，尝试重建 MCP 客户端并重试
+                    # [v1.16.18→18.3] 检测 Chrome 崩溃，彻底清理后重建 MCP 客户端并重试
                     _crash_keywords = ["Target closed", "Target destroyed", "Protocol error",
                                       "Browser closed", "Connection closed", "Session closed"]
                     if any(kw in err_text for kw in _crash_keywords) and attempt < max_attempts - 1:
                         logger.warning(f"Chrome 连接丢失 ({err_text[:100]})，正在重建 MCP 客户端并重试...")
-                        try:
-                            if client:
-                                client._cleanup()
-                        except Exception:
-                            pass
-                        _mcp_client = None
+                        # [v1.18.3] 彻底清理所有 MCP 客户端（包括残留 Chrome 进程）
+                        await rebuild_mcp_client()
                         continue  # 重试
                     return SkillResult(success=False, error=f"导航失败: {err_text}")
 
@@ -921,18 +969,13 @@ class BrowserOpenSkill(Skill):
                     message=f"已打开: {page_title} (文本 {len(text)} 字符, {len(links)} 个链接)",
                 )
             except Exception as e:
-                # [v1.16.18] 异常时也检测 Chrome 崩溃并重试
+                # [v1.16.18→18.3] 异常时也检测 Chrome 崩溃并彻底重建
                 _err_str = str(e)
                 _crash_keywords = ["Target closed", "Target destroyed", "Protocol error",
                                   "Browser closed", "Connection closed", "Session closed"]
                 if any(kw in _err_str for kw in _crash_keywords) and attempt < max_attempts - 1:
                     logger.warning(f"Chrome 异常 ({_err_str[:100]})，正在重建 MCP 客户端并重试...")
-                    try:
-                        if _mcp_client:
-                            _mcp_client._cleanup()
-                    except Exception:
-                        pass
-                    _mcp_client = None
+                    await rebuild_mcp_client()
                     continue  # 重试
                 logger.error(f"浏览器打开失败: {e}")
                 return SkillResult(success=False, error=f"浏览器打开失败: {e}")

package/web/api_server.py

@@ -4061,13 +4061,14 @@ window.toggleFullscreen = function() {{
         return chain
 
     def _reorder_model_chain_for_images(self, model_chain: list[dict], has_images: bool) -> list[dict]:
-        """[v1.16.14→18] 当消息包含图片时，将支持 vision 的模型优先排列
+        """[v1.16.14→18.2] 当消息包含图片时，将支持 vision 的模型优先排列
 
         优先从 model_chain 自带的 input_modes 读取（v1.16.18 改进），
         其次从 models_library 二次查找（兼容旧逻辑）。
 
         检查每个模型的 input_modes 字段，如果包含 "image"，则优先使用。
-        如果都没有 vision 能力，则保持原序（会触发 main_agent 的纯文本降级）。
+        如果 chain 中没有 vision 模型，自动从全局 models_library 查找 vision
+        兜底模型追加到 chain 末尾（v1.18.2 改进）。
         """
         if not has_images or not model_chain:
             return model_chain
@@ -4075,9 +4076,11 @@ window.toggleFullscreen = function() {{
         # 从 model_chain 自带的 input_modes 或 models_library 获取
         vision_models = []
         text_only_models = []
+        chain_ids = set()
         for mc in model_chain:
             mc_id = mc.get("id", "")
             model_name = mc.get("name", mc.get("model", "?"))
+            chain_ids.add(mc_id)
 
             # [v1.16.18] 优先使用 chain 自带的 input_modes
             input_modes = mc.get("input_modes", None)
@@ -4091,8 +4094,6 @@ window.toggleFullscreen = function() {{
                             input_modes = me.input_modes or ["text"]
                             break
 
-            logger.debug(f"模型 {model_name} (id={mc_id}) input_modes={input_modes}")
-            # [v1.17.1] 改为 info 级别，方便排查
             logger.info(f"[reorder] 模型 {model_name} (id={mc_id}) input_modes={input_modes}")
             if "image" in input_modes:
                 vision_models.append(mc)
@@ -4102,13 +4103,43 @@ window.toggleFullscreen = function() {{
         if vision_models:
             logger.info(f"消息含图片，优先使用 vision 模型: {[m.get('name', m.get('model')) for m in vision_models]}")
             return vision_models + text_only_models
-        else:
-            # [v1.16.18] 详细日志帮助排查问题
-            chain_info = []
-            for mc in model_chain:
-                chain_info.append(f"{mc.get('name', mc.get('model', '?'))}(id={mc.get('id','')}, input_modes={mc.get('input_modes','?')})")
-            logger.warning(f"消息含图片，但模型链中无 vision 模型，链详情: {chain_info}，将尝试当前主模型（失败后自动降级纯文本）")
-            return model_chain
+
+        # [v1.18.2] chain 中没有 vision 模型 → 从全局 models_library 自动找 vision 兜底
+        llm_defaults = self.core.config.llm
+        auto_vision = None
+        for me in self.core.config.models_library:
+            if me.id in chain_ids:
+                continue  # 跳过已在 chain 中的
+            modes = me.input_modes or ["text"]
+            if "image" in modes and me.enabled:
+                auto_vision = me
+                break
+
+        if auto_vision:
+            vision_mc = {
+                "id": auto_vision.id,
+                "name": auto_vision.name,
+                "provider": auto_vision.provider or llm_defaults.provider,
+                "api_type": getattr(auto_vision, 'api_type', '') or llm_defaults.api_type,
+                "model": auto_vision.model or auto_vision.id,
+                "base_url": auto_vision.base_url or llm_defaults.base_url,
+                "api_key": auto_vision.api_key or llm_defaults.api_key,
+                "temperature": auto_vision.temperature if auto_vision.temperature is not None else llm_defaults.temperature,
+                "max_tokens": auto_vision.max_tokens if auto_vision.max_tokens else llm_defaults.max_tokens,
+                "context_window": getattr(auto_vision, 'context_window', None) or llm_defaults.context_window,
+                "input_modes": list(auto_vision.input_modes or ["text"]),
+                "is_backup": True,
+                "_auto_vision": True,  # 标记：自动追加的 vision 兜底
+            }
+            logger.warning(f"消息含图片，agent 模型链无 vision 模型，自动追加全局 vision 兜底: {auto_vision.name} (id={auto_vision.id})")
+            return [vision_mc] + text_only_models
+
+        # 既没有 chain 内 vision，也没有全局兜底 → 保持原序，让 main_agent 降级纯文本
+        chain_info = []
+        for mc in model_chain:
+            chain_info.append(f"{mc.get('name', mc.get('model', '?'))}(id={mc.get('id','')}, modes={mc.get('input_modes','?')})")
+        logger.warning(f"消息含图片，但无可用 vision 模型，链详情: {chain_info}，将降级纯文本")
+        return model_chain
 
     async def _try_model_chain(self, model_chain: list[dict], message: str, session_id: str,
                                  agent_path: str = None, agent_system_prompt: str = None,
@@ -4135,6 +4166,7 @@ window.toggleFullscreen = function() {{
 
         for i, mc in enumerate(model_chain):
             is_backup = mc.get("is_backup", False)
+            is_auto_vision = mc.get("_auto_vision", False)
             model_label = f"{'备用' if is_backup else '主'}模型 {mc.get('name', mc.get('model', '?'))}"
             logger.info(f"尝试 {model_label} ({i+1}/{len(model_chain)}): provider={mc.get('provider')}, model={mc.get('model')}")
 
@@ -4208,6 +4240,10 @@ window.toggleFullscreen = function() {{
                     used_model_name = model_label
                     if is_backup:
                         logger.warning(f"🔄 主模型失败，成功切换到 {model_label}")
+                    # [v1.18.2] 自动 vision 兜底成功的提醒
+                    if is_auto_vision:
+                        _hint = f"💡 当前绑定的模型不支持图片，已自动切换到 {mc.get('name', mc.get('model', '?'))} 处理。\n\n"
+                        return _hint + response
                     return response
 
                 last_error = response
@@ -4265,6 +4301,8 @@ window.toggleFullscreen = function() {{
         """_try_model_chain_stream 的实际执行体（已在 _model_chain_lock 保护下）"""
         llm = self.core.llm
         full_text = ""
+        _auto_vision_switched = False  # [v1.18.2] 标记是否发生了 vision 自动切换
+        _auto_vision_model_name = ""
 
         for i, mc in enumerate(model_chain):
             orig = {
@@ -4288,6 +4326,11 @@ window.toggleFullscreen = function() {{
                             agent.context_builder.context_window = mc["context_window"]
                 llm._client = None
 
+                # [v1.18.2] 检测是否是自动追加的 vision 兜底模型
+                is_auto_vision = mc.get("_auto_vision", False)
+                if is_auto_vision:
+                    _auto_vision_model_name = mc.get("name", mc.get("model", "?"))
+
                 # Pass agent context through AgentContext instead of instance attrs
                 result = await self._stream_process_message(
                     message, session_id, stream_response,
@@ -4296,6 +4339,11 @@ window.toggleFullscreen = function() {{
                     user_images=user_images, user_files=user_files,
                 )
                 if result and not result.startswith("⚠️") and not result.startswith("❌"):
+                    # [v1.18.2] 如果是通过自动 vision 兜底成功的，在响应前追加提醒
+                    if is_auto_vision and user_images:
+                        _hint = f"💡 当前绑定的模型不支持图片，已自动切换到 {_auto_vision_model_name} 处理。\n\n"
+                        logger.info(f"自动 vision 兜底成功: {_auto_vision_model_name}")
+                        return _hint + result
                     return result
                 # 如果返回了错误消息，保存它以便最后返回
                 if result:
@@ -4314,6 +4362,23 @@ window.toggleFullscreen = function() {{
                         if hasattr(agent, 'context_builder') and agent.context_builder:
                             agent.context_builder.context_window = orig["context_window"]
 
+        # [v1.18.2] 所有模型都失败，且包含图片，给出明确的配置提示
+        if user_images and full_text and "不支持图片" in full_text:
+            # 查找可用的 vision 模型名称
+            vision_names = []
+            for me in self.core.config.models_library:
+                modes = me.input_modes or ["text"]
+                if "image" in modes and me.enabled:
+                    vision_names.append(me.name or me.id)
+            if vision_names:
+                return (f"⚠️ 当前绑定的模型不支持图片识别，自动切换也未找到可用的图片模型。\n\n"
+                        f"📋 模型库中支持图片的模型: {', '.join(vision_names[:5])}\n\n"
+                        f"请在 agent 设置中将其中一个绑定为模型或备用模型，以便识别图片。")
+            else:
+                return (f"⚠️ 当前绑定的模型不支持图片识别，且模型库中没有任何支持图片的模型。\n\n"
+                        f"请在 models_library 中添加一个支持 vision 的模型（input_modes 包含 \"image\"），"
+                        f"然后绑定到当前 agent。")
+
         return full_text
 
     async def _stream_text_chunked(self, text: str, write_sse, chunk_size: int = 4, delay: float = 0.015):