jarvis-ai-assistant 0.7.16__py3-none-any.whl → 1.0.2__py3-none-any.whl

jarvis/jarvis_tools/registry.py

@@ -1,23 +1,36 @@
-# -*- coding: utf-8 -*-
-from jarvis.jarvis_utils.jsonnet_compat import loads as json_loads
 import json
 import os
 import re
 import sys
 import tempfile
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Protocol, Tuple
+from typing import Any
+from typing import Callable
+from typing import Dict
+from typing import List
+from typing import Optional
+from typing import Protocol
+from typing import Tuple
+from typing import cast
 
-import yaml  # type: ignore[import-untyped]
+import yaml
 
 from jarvis.jarvis_mcp import McpClient
 from jarvis.jarvis_mcp.sse_mcp_client import SSEMcpClient
 from jarvis.jarvis_mcp.stdio_mcp_client import StdioMcpClient
 from jarvis.jarvis_mcp.streamable_mcp_client import StreamableMcpClient
 from jarvis.jarvis_tools.base import Tool
-from jarvis.jarvis_utils.config import get_data_dir, get_tool_load_dirs
-from jarvis.jarvis_utils.tag import ct, ot
-from jarvis.jarvis_utils.utils import is_context_overflow, daily_check_git_updates
+from jarvis.jarvis_utils.config import get_data_dir
+from jarvis.jarvis_utils.config import get_tool_load_dirs
+from jarvis.jarvis_utils.globals import get_global_model_group
+
+# -*- coding: utf-8 -*-
+from jarvis.jarvis_utils.jsonnet_compat import loads as json_loads
+from jarvis.jarvis_utils.output import PrettyOutput
+from jarvis.jarvis_utils.tag import ct
+from jarvis.jarvis_utils.tag import ot
+from jarvis.jarvis_utils.utils import daily_check_git_updates
+from jarvis.jarvis_utils.utils import is_context_overflow
 
 _multiline_example = """  {
     "multiline_str": |||
@@ -39,8 +52,9 @@ _multiline_example = """  {
   }"""
 
 tool_call_help = f"""
-<tool_system_guide>
-工具调用格式（Jsonnet）：
+## 工具调用指南（Markdown）
+
+**工具调用格式（Jsonnet）**
 {ot("TOOL_CALL")}
 {{
   "want": "想要从执行结果中获取到的信息",
@@ -52,7 +66,7 @@ tool_call_help = f"""
 }}
 {ct("TOOL_CALL")}
 
-Jsonnet格式特性：
+**Jsonnet格式特性**
 - 字符串引号：可使用双引号或单引号
 - 多行字符串：推荐使用 ||| 或 ``` 分隔符包裹多行字符串，直接换行无需转义，支持保留缩进
   示例：
@@ -60,15 +74,18 @@ Jsonnet格式特性：
 - 尾随逗号：对象/数组最后一个元素后可添加逗号
 - 注释：支持 // 单行或 /* */ 多行注释
 
-关键规则：
+**关键规则**
 1. 每次只使用一个工具，等待结果后再进行下一步
 2. {ot("TOOL_CALL")} 和 {ct("TOOL_CALL")} 必须出现在行首
 3. 多行字符串参数推荐使用 ||| 或 ``` 分隔符包裹，直接换行无需转义，支持保留缩进
 4. 等待执行结果，不要假设或创建虚假响应
 5. 信息不足时询问用户，不要在没有完整信息的情况下继续
 
-常见错误：同时调用多个工具、假设工具结果、Jsonnet格式错误、标签未出现在行首
-</tool_system_guide>
+**常见错误**
+- 同时调用多个工具
+- 假设工具结果
+- Jsonnet格式错误
+- 缺少行首的开始/结束标签
 """
 
 
@@ -88,25 +105,22 @@ class ToolRegistry(OutputHandlerProtocol):
 
     def can_handle(self, response: str) -> bool:
         # 仅当 {ot("TOOL_CALL")} 出现在行首时才认为可以处理（忽略大小写）
-        has_tool_call = re.search(rf'(?mi){re.escape(ot("TOOL_CALL"))}', response) is not None
-        if has_tool_call:
-            print("🛠️ 检测到工具调用")  # 增加工具emoji
+        has_tool_call = (
+            re.search(rf"(?mi){re.escape(ot('TOOL_CALL'))}", response) is not None
+        )
         return has_tool_call
 
     def prompt(self) -> str:
         """加载工具"""
         tools = self.get_all_tools()
         if tools:
-            tools_prompt = "<tools_section>\n"
-            tools_prompt += "  <header>## 可用工具:</header>\n"
-            tools_prompt += "  <tools_list>\n"
+            tools_prompt = "## 可用工具\n"
             for tool in tools:
                 try:
-                    tools_prompt += "    <tool>\n"
-                    tools_prompt += f"      <name>名称: {tool['name']}</name>\n"
-                    tools_prompt += f"      <description>描述: {tool['description']}</description>\n"
-                    tools_prompt += "      <parameters>\n"
-                    tools_prompt += "        <json>|\n"
+                    tools_prompt += f"- **名称**: {tool['name']}\n"
+                    tools_prompt += f"  - 描述: {tool['description']}\n"
+                    tools_prompt += "  - 参数:\n"
+                    tools_prompt += "```json\n"
 
                     # 生成格式化的JSON参数
                     json_params = json.dumps(
@@ -118,18 +132,16 @@ class ToolRegistry(OutputHandlerProtocol):
 
                     # 添加缩进并移除尾部空格
                     for line in json_params.split("\n"):
-                        tools_prompt += f"          {line.rstrip()}\n"
+                        tools_prompt += f"{line.rstrip()}\n"
 
-                    tools_prompt += "        </json>\n"
-                    tools_prompt += "      </parameters>\n"
-                    tools_prompt += "    </tool>\n"
+                    tools_prompt += "```\n"
 
                 except Exception as e:
-                    print(f"❌ 工具 {tool['name']} 参数序列化失败: {str(e)}")
+                    PrettyOutput.auto_print(
+                        f"❌ 工具 {tool['name']} 参数序列化失败: {str(e)}"
+                    )
                     continue
 
-            tools_prompt += "  </tools_list>\n"
-            tools_prompt += "</tools_section>\n"
             tools_prompt += tool_call_help.rstrip()  # 移除帮助文本尾部空格
             return tools_prompt
         return ""
@@ -137,13 +149,16 @@ class ToolRegistry(OutputHandlerProtocol):
     def handle(self, response: str, agent_: Any) -> Tuple[bool, Any]:
         try:
             # 传递agent给_extract_tool_calls，以便在解析失败时调用大模型修复
-            tool_call, err_msg, auto_completed = self._extract_tool_calls(response, agent_)
+            tool_call, err_msg, auto_completed = self._extract_tool_calls(
+                response, agent_
+            )
             if err_msg:
                 # 只要工具解析错误，追加工具使用帮助信息（相当于一次 <ToolUsage>）
                 try:
                     from jarvis.jarvis_agent import Agent
-                    agent: Agent = agent_
-                    tool_usage = agent.get_tool_usage_prompt()
+
+                    agent_obj: Agent = agent_
+                    tool_usage = agent_obj.get_tool_usage_prompt()
                     return False, f"{err_msg}\n\n{tool_usage}"
                 except Exception:
                     # 兼容处理：无法获取Agent或ToolUsage时，至少返回工具系统帮助信息
@@ -154,13 +169,13 @@ class ToolRegistry(OutputHandlerProtocol):
                 result = f"检测到工具调用缺少结束标签，已自动补全{ct('TOOL_CALL')}。请确保后续工具调用包含完整的开始和结束标签。\n\n{result}"
             return False, result
         except Exception as e:
-            print(f"❌ 工具调用处理失败: {str(e)}")
+            PrettyOutput.auto_print(f"❌ 工具调用处理失败: {str(e)}")
             from jarvis.jarvis_agent import Agent
 
-            agent: Agent = agent_
+            agent_final: Agent = agent_
             return (
                 False,
-                f"工具调用处理失败: {str(e)}\n\n{agent.get_tool_usage_prompt()}",
+                f"工具调用处理失败: {str(e)}\n\n{agent_final.get_tool_usage_prompt()}",
             )
 
     def __init__(self) -> None:
@@ -168,6 +183,8 @@ class ToolRegistry(OutputHandlerProtocol):
         self.tools: Dict[str, Tool] = {}
         # 记录内置工具名称，用于区分内置工具和用户自定义工具
         self._builtin_tool_names: set = set()
+        # 定义必选工具列表（这些工具将始终可用）
+        self._required_tools: List[str] = ["execute_script"]
         # 加载内置工具和外部工具
         self._load_builtin_tools()
         self._load_external_tools()
@@ -177,9 +194,10 @@ class ToolRegistry(OutputHandlerProtocol):
 
     def _get_tool_stats(self) -> Dict[str, int]:
         """从数据目录获取工具调用统计"""
-        from jarvis.jarvis_stats.stats import StatsManager
         from datetime import datetime
 
+        from jarvis.jarvis_stats.stats import StatsManager
+
         # 获取所有工具的统计数据
         tool_stats = {}
         tools = self.get_all_tools()
@@ -221,7 +239,9 @@ class ToolRegistry(OutputHandlerProtocol):
         """
         missing_tools = [tool_name for tool_name in name if tool_name not in self.tools]
         if missing_tools:
-            print(f"⚠️ 工具 {missing_tools} 不存在，可用的工具有: {', '.join(self.tools.keys())}")
+            PrettyOutput.auto_print(
+                f"⚠️ 工具 {missing_tools} 不存在，可用的工具有: {', '.join(self.tools.keys())}"
+            )
         self.tools = {
             tool_name: self.tools[tool_name]
             for tool_name in name
@@ -234,13 +254,29 @@ class ToolRegistry(OutputHandlerProtocol):
         参数:
             names: 要移除的工具名称列表
         """
+        # 过滤掉必选工具，确保它们不会被移除
+        filtered_names = [name for name in names if name not in self._required_tools]
+        if filtered_names != names:
+            removed_required = [name for name in names if name in self._required_tools]
+            PrettyOutput.auto_print(
+                f"⚠️ 警告: 无法移除必选工具: {', '.join(removed_required)}"
+            )
         self.tools = {
-            name: tool for name, tool in self.tools.items() if name not in names
+            name: tool
+            for name, tool in self.tools.items()
+            if name not in filtered_names
         }
 
     def _apply_tool_config_filter(self) -> None:
         """应用工具配置组的过滤规则"""
-        from jarvis.jarvis_utils.config import get_tool_use_list, get_tool_dont_use_list
+        from jarvis.jarvis_utils.config import get_tool_dont_use_list
+        from jarvis.jarvis_utils.config import get_tool_use_list
+
+        # 在过滤前保存必选工具的引用
+        required_tools_backup: Dict[str, Tool] = {}
+        for tool_name in self._required_tools:
+            if tool_name in self.tools:
+                required_tools_backup[tool_name] = self.tools[tool_name]
 
         use_list = get_tool_use_list()
         dont_use_list = get_tool_dont_use_list()
@@ -255,15 +291,27 @@ class ToolRegistry(OutputHandlerProtocol):
                 else:
                     missing.append(tool_name)
             if missing:
-                print("⚠️ 警告: 配置的工具不存在: " + ", ".join(f"'{name}'" for name in missing))
+                PrettyOutput.auto_print(
+                    "⚠️ 警告: 配置的工具不存在: "
+                    + ", ".join(f"'{name}'" for name in missing)
+                )
             self.tools = filtered_tools
 
-        # 如果配置了 dont_use 列表，排除列表中的工具
+        # 如果配置了 dont_use 列表，排除列表中的工具（但必选工具除外）
         if dont_use_list:
             for tool_name in dont_use_list:
-                if tool_name in self.tools:
+                if tool_name in self.tools and tool_name not in self._required_tools:
                     del self.tools[tool_name]
 
+        # 确保必选工具始终被包含（如果它们之前被加载过）
+        for tool_name in self._required_tools:
+            if tool_name in required_tools_backup:
+                self.tools[tool_name] = required_tools_backup[tool_name]
+            elif tool_name not in self.tools:
+                PrettyOutput.auto_print(
+                    f"⚠️ 警告: 必选工具 '{tool_name}' 未加载，可能无法正常工作"
+                )
+
     def _load_mcp_tools(self) -> None:
         """加载MCP工具，优先从配置获取，其次从目录扫描"""
         from jarvis.jarvis_utils.config import get_mcp_config
@@ -281,7 +329,9 @@ class ToolRegistry(OutputHandlerProtocol):
             return
 
         # 添加警告信息
-        print("⚠️ 警告: 从文件目录加载MCP工具的方式将在未来版本中废弃，请尽快迁移到JARVIS_MCP配置方式")
+        PrettyOutput.auto_print(
+            "⚠️ 警告: 从文件目录加载MCP工具的方式将在未来版本中废弃，请尽快迁移到mcp配置方式"
+        )
 
         # 遍历目录中的所有.yaml文件
         error_lines = []
@@ -293,7 +343,7 @@ class ToolRegistry(OutputHandlerProtocol):
             except Exception as e:
                 error_lines.append(f"文件 {file_path} 加载失败: {str(e)}")
         if error_lines:
-            print("⚠️ " + "\n⚠️ ".join(error_lines))
+            PrettyOutput.auto_print("⚠️ " + "\n⚠️ ".join(error_lines))
 
     def _load_builtin_tools(self) -> None:
         """从内置工具目录加载工具"""
@@ -306,7 +356,7 @@ class ToolRegistry(OutputHandlerProtocol):
                 continue
 
             self.register_tool_by_file(str(file_path))
-        
+
         # 记录当前已加载的工具名称为内置工具
         self._builtin_tool_names = set(self.tools.keys())
 
@@ -335,10 +385,11 @@ class ToolRegistry(OutputHandlerProtocol):
                         import subprocess
 
                         subprocess.run(
-                            ["git", "clone", central_repo, central_repo_path], check=True
+                            ["git", "clone", central_repo, central_repo_path],
+                            check=True,
                         )
                     except Exception as e:
-                        print(f"❌ 克隆中心工具仓库失败: {str(e)}")
+                        PrettyOutput.auto_print(f"❌ 克隆中心工具仓库失败: {str(e)}")
 
         # --- 全局每日更新检查 ---
         daily_check_git_updates(tool_dirs, "tools")
@@ -367,12 +418,11 @@ class ToolRegistry(OutputHandlerProtocol):
         """
         try:
             if "type" not in config:
-                print(f"⚠️ 配置{config.get('name', '')}缺少type字段")
+                PrettyOutput.auto_print(f"⚠️ 配置{config.get('name', '')}缺少type字段")
                 return False
 
             # 检查enable标志
             if not config.get("enable", True):
-
                 return False
 
             name = config.get("name", "mcp")
@@ -423,18 +473,24 @@ class ToolRegistry(OutputHandlerProtocol):
 
             if config["type"] == "stdio":
                 if "command" not in config:
-                    print(f"⚠️ 配置{config.get('name', '')}缺少command字段")
+                    PrettyOutput.auto_print(
+                        f"⚠️ 配置{config.get('name', '')}缺少command字段"
+                    )
                     return False
             elif config["type"] == "sse":
                 if "base_url" not in config:
-                    print(f"⚠️ 配置{config.get('name', '')}缺少base_url字段")
+                    PrettyOutput.auto_print(
+                        f"⚠️ 配置{config.get('name', '')}缺少base_url字段"
+                    )
                     return False
             elif config["type"] == "streamable":
                 if "base_url" not in config:
-                    print(f"⚠️ 配置{config.get('name', '')}缺少base_url字段")
+                    PrettyOutput.auto_print(
+                        f"⚠️ 配置{config.get('name', '')}缺少base_url字段"
+                    )
                     return False
             else:
-                print(f"⚠️ 不支持的MCP客户端类型: {config['type']}")
+                PrettyOutput.auto_print(f"⚠️ 不支持的MCP客户端类型: {config['type']}")
                 return False
 
             # 创建MCP客户端
@@ -451,7 +507,9 @@ class ToolRegistry(OutputHandlerProtocol):
             # 获取工具信息
             tools = mcp_client.get_tool_list()
             if not tools:
-                print(f"⚠️ 从配置{config.get('name', '')}获取工具列表失败")
+                PrettyOutput.auto_print(
+                    f"⚠️ 从配置{config.get('name', '')}获取工具列表失败"
+                )
                 return False
 
             # 注册每个工具
@@ -489,7 +547,9 @@ class ToolRegistry(OutputHandlerProtocol):
             return True
 
         except Exception as e:
-            print(f"⚠️ MCP配置{config.get('name', '')}加载失败: {str(e)}")
+            PrettyOutput.auto_print(
+                f"⚠️ MCP配置{config.get('name', '')}加载失败: {str(e)}"
+            )
             return False
 
     def register_tool_by_file(self, file_path: str) -> bool:
@@ -504,7 +564,7 @@ class ToolRegistry(OutputHandlerProtocol):
         try:
             p_file_path = Path(file_path).resolve()  # 获取绝对路径
             if not p_file_path.exists() or not p_file_path.is_file():
-                print(f"❌ 文件不存在: {p_file_path}")
+                PrettyOutput.auto_print(f"❌ 文件不存在: {p_file_path}")
                 return False
 
             # 临时将父目录添加到sys.path
@@ -559,37 +619,47 @@ class ToolRegistry(OutputHandlerProtocol):
                 sys.path.remove(parent_dir)
 
         except Exception as e:
-            print(f"❌ 从 {Path(file_path).name} 加载工具失败: {str(e)}")
+            PrettyOutput.auto_print(
+                f"❌ 从 {Path(file_path).name} 加载工具失败: {str(e)}"
+            )
             return False
 
     @staticmethod
     def _has_tool_calls_block(content: str) -> bool:
         """从内容中提取工具调用块（仅匹配行首标签，忽略大小写）"""
-        pattern = rf'(?msi){re.escape(ot("TOOL_CALL"))}(.*?)^{re.escape(ct("TOOL_CALL"))}'
+        pattern = (
+            rf"(?msi){re.escape(ot('TOOL_CALL'))}(.*?)^{re.escape(ct('TOOL_CALL'))}"
+        )
         return re.search(pattern, content) is not None
 
     @staticmethod
     def _get_long_response_hint(content: str) -> str:
         """生成长响应的提示信息
-        
+
         参数:
             content: 响应内容
-            
+
         返回:
             str: 如果响应较长，返回提示信息；否则返回空字符串
         """
         if len(content) > 2048:
-            return "\n\n⚠️ 提示：响应内容较长（超过2048字符），可能是上下文溢出导致工具调用解析失败。如果是修改文件（edit_file）或重写文件（rewrite_file）操作，建议分多次进行，每次处理文件的一部分。"
+            return (
+                "\n\n⚠️ 提示：响应内容较长（超过2048字符），可能是上下文溢出导致工具调用解析失败。"
+                "如果是修改文件（edit_file）操作，"
+                "建议分多次进行，每次处理文件的一部分。"
+            )
         return ""
 
     @staticmethod
-    def _extract_json_from_text(text: str, start_pos: int = 0) -> Tuple[Optional[str], int]:
+    def _extract_json_from_text(
+        text: str, start_pos: int = 0
+    ) -> Tuple[Optional[str], int]:
         """从文本中提取完整的JSON对象（通过括号匹配）
-        
+
         参数:
             text: 要提取的文本
             start_pos: 开始搜索的位置
-            
+
         返回:
             Tuple[Optional[str], int]:
                 - 第一个元素是提取的JSON字符串（如果找到），否则为None
@@ -597,94 +667,95 @@ class ToolRegistry(OutputHandlerProtocol):
         """
         # 跳过空白字符
         pos = start_pos
-        while pos < len(text) and text[pos] in (' ', '\t', '\n', '\r'):
+        while pos < len(text) and text[pos] in (" ", "\t", "\n", "\r"):
             pos += 1
-        
+
         if pos >= len(text):
             return None, pos
-        
+
         # 检查是否以 { 开头
-        if text[pos] != '{':
+        if text[pos] != "{":
             return None, pos
-        
+
         # 使用括号匹配找到完整的JSON对象
         brace_count = 0
         in_string = False
         escape_next = False
         string_char = None
-        
+
         json_start = pos
         for i in range(pos, len(text)):
             char = text[i]
-            
+
             if escape_next:
                 escape_next = False
                 continue
-            
-            if char == '\\':
+
+            if char == "\\":
                 escape_next = True
                 continue
-            
+
             if not in_string:
                 if char in ('"', "'"):
                     in_string = True
                     string_char = char
-                elif char == '{':
+                elif char == "{":
                     brace_count += 1
-                elif char == '}':
+                elif char == "}":
                     brace_count -= 1
                     if brace_count == 0:
                         # 找到完整的JSON对象
-                        return text[json_start:i+1], i + 1
+                        return text[json_start : i + 1], i + 1
             else:
                 if char == string_char:
                     in_string = False
                     string_char = None
-        
+
         return None, len(text)
-    
+
     @staticmethod
     def _clean_extra_markers(text: str) -> str:
         """清理文本中的额外标记（如 <|tool_call_end|> 等）
-        
+
         参数:
             text: 要清理的文本
-            
+
         返回:
             清理后的文本
         """
         # 常见的额外标记模式
         extra_markers = [
-            r'<\|tool_call_end\|>',
-            r'<\|tool_calls_section_end\|>',
-            r'<\|.*?\|>',  # 匹配所有 <|...|> 格式的标记
+            r"<\|tool_call_end\|>",
+            r"<\|tool_calls_section_end\|>",
+            r"<\|.*?\|>",  # 匹配所有 <|...|> 格式的标记
         ]
-        
+
         cleaned = text
         for pattern in extra_markers:
-            cleaned = re.sub(pattern, '', cleaned, flags=re.IGNORECASE)
-        
+            cleaned = re.sub(pattern, "", cleaned, flags=re.IGNORECASE)
+
         return cleaned.strip()
 
     @staticmethod
     def _try_llm_fix(content: str, agent: Any, error_msg: str) -> Optional[str]:
         """尝试使用大模型修复工具调用格式
-        
+
         参数:
             content: 包含错误工具调用的内容
             agent: Agent实例，用于调用大模型
             error_msg: 错误消息
-            
+
         返回:
             Optional[str]: 修复后的内容，如果修复失败则返回None
         """
         try:
             from jarvis.jarvis_agent import Agent
+
             agent_instance: Agent = agent
-            
+
             # 获取工具使用说明
             tool_usage = agent_instance.get_tool_usage_prompt()
-            
+
             # 构建修复提示
             fix_prompt = f"""你之前的工具调用格式有误，请根据工具使用说明修复以下内容。
 
@@ -703,22 +774,75 @@ class ToolRegistry(OutputHandlerProtocol):
 3. 如果使用多行字符串，推荐使用 ||| 或 ``` 分隔符包裹
 
 请直接返回修复后的完整工具调用内容，不要添加其他说明文字。"""
-            
+
             # 调用大模型修复
-            print("🤖 尝试使用大模型修复工具调用格式...")
-            fixed_content = agent_instance.model.chat_until_success(fix_prompt)  # type: ignore
-            
+            PrettyOutput.auto_print("🤖 尝试使用大模型修复工具调用格式...")
+            fixed_content = agent_instance.model.chat_until_success(fix_prompt)
+
             if fixed_content:
-                print("✅ 大模型修复完成")
+                PrettyOutput.auto_print("✅ 大模型修复完成")
                 return fixed_content
             else:
-                print("❌ 大模型修复失败：返回内容为空")
+                PrettyOutput.auto_print("❌ 大模型修复失败：返回内容为空")
                 return None
-                
+
         except Exception as e:
-            print(f"❌ 大模型修复失败：{str(e)}")
+            PrettyOutput.auto_print(f"❌ 大模型修复失败：{str(e)}")
             return None
 
+    @staticmethod
+    def _check_and_handle_multiple_tool_calls(
+        content: str, blocks: List[str]
+    ) -> Tuple[Optional[str], bool]:
+        """检测并处理多个工具调用的情况
+
+        参数:
+            content: 包含工具调用的内容
+            blocks: 工具调用块列表
+
+        返回:
+            Tuple[Optional[str], bool]:
+                - 第一个元素：如果检测到多个工具调用，返回错误消息；否则返回None
+                - 第二个元素：是否检测到多个工具调用
+        """
+        if len(blocks) <= 1:
+            return None, False
+
+        # 尝试解析每个块，收集所有成功解析的工具调用
+        parsed_tools = []
+        for item in blocks:
+            try:
+                cleaned_item = ToolRegistry._clean_extra_markers(item)
+                msg = json_loads(cleaned_item)
+                if "name" in msg and "arguments" in msg:
+                    parsed_tools.append(msg)
+            except Exception:
+                # 如果某个块解析失败，可能是格式问题，继续检查其他块
+                pass
+
+        # 如果成功解析了多个工具调用，返回明确的错误信息
+        if len(parsed_tools) > 1:
+            tool_names = [
+                tool_call.get("name", "未知工具") for tool_call in parsed_tools
+            ]
+            error_msg = f"""检测到多个工具调用（共 {len(parsed_tools)} 个），请一次只处理一个工具调用。
+
+检测到的工具调用：
+{chr(10).join(f"  - {i + 1}. {name}" for i, name in enumerate(tool_names))}
+
+失败原因：
+系统要求每次只能执行一个工具调用，等待结果后再进行下一步操作。同时调用多个工具会导致：
+1. 无法确定工具执行的顺序和依赖关系
+2. 无法正确处理工具之间的交互
+3. 可能导致资源竞争和状态不一致
+
+请修改工具调用，确保每次只包含一个 {ot("TOOL_CALL")}...{ct("TOOL_CALL")} 块。
+
+{tool_call_help}"""
+            return error_msg, True
+
+        return None, False
+
     @staticmethod
     def _extract_tool_calls(
         content: str,
@@ -743,24 +867,45 @@ class ToolRegistry(OutputHandlerProtocol):
         close_tag = ct("TOOL_CALL")
         # 使用正则表达式查找结束标签（忽略大小写），以获取实际位置和原始大小写
         close_tag_pattern = re.escape(close_tag)
-        match = re.search(rf'{close_tag_pattern}$', content.rstrip(), re.IGNORECASE)
+        match = re.search(rf"{close_tag_pattern}$", content.rstrip(), re.IGNORECASE)
         if match:
             pos = match.start()
             if pos > 0 and content[pos - 1] not in ("\n", "\r"):
                 content = content[:pos] + "\n" + content[pos:]
 
         # 首先尝试标准的提取方式（忽略大小写）
-        pattern = rf'(?msi){re.escape(ot("TOOL_CALL"))}(.*?)^{re.escape(ct("TOOL_CALL"))}'
+        pattern = (
+            rf"(?msi){re.escape(ot('TOOL_CALL'))}(.*?)^{re.escape(ct('TOOL_CALL'))}"
+        )
         data = re.findall(pattern, content)
         auto_completed = False
-        
+
+        # 如果检测到多个工具调用块，先检查是否是多个独立的工具调用
+        if len(data) > 1:
+            (
+                error_msg,
+                has_multiple,
+            ) = ToolRegistry._check_and_handle_multiple_tool_calls(content, data)
+            if has_multiple:
+                return (
+                    cast(Dict[str, Dict[str, Any]], {}),
+                    error_msg if error_msg else "",
+                    False,
+                )
+            # 如果解析失败，可能是多个工具调用被当作一个 JSON 来解析了
+            # 继续执行后续的宽松提取逻辑
+
         # 如果标准提取失败，尝试更宽松的提取方式
         if not data:
             # can_handle 确保 ot("TOOL_CALL") 在内容中（行首）。
             # 如果数据为空，则表示行首的 ct("TOOL_CALL") 可能丢失。
-            has_open_at_bol = re.search(rf'(?mi){re.escape(ot("TOOL_CALL"))}', content) is not None
-            has_close_at_bol = re.search(rf'(?mi)^{re.escape(ct("TOOL_CALL"))}', content) is not None
-            
+            has_open_at_bol = (
+                re.search(rf"(?mi){re.escape(ot('TOOL_CALL'))}", content) is not None
+            )
+            has_close_at_bol = (
+                re.search(rf"(?mi)^{re.escape(ct('TOOL_CALL'))}", content) is not None
+            )
+
             if has_open_at_bol and not has_close_at_bol:
                 # 尝试通过附加结束标签来修复它（确保结束标签位于行首）
                 fixed_content = content.strip() + f"\n{ct('TOOL_CALL')}"
@@ -780,50 +925,104 @@ class ToolRegistry(OutputHandlerProtocol):
                         # Even after fixing, it's not valid JSON, or user cancelled.
                         # Fall through to try more lenient extraction.
                         pass
-            
+
             # 如果仍然没有数据，尝试更宽松的提取：直接从开始标签后提取JSON
             if not data:
+                # 先检查是否有多个工具调用块（可能被当作一个 JSON 来解析导致失败）
+                multiple_blocks = re.findall(
+                    rf"(?msi){re.escape(ot('TOOL_CALL'))}(.*?){re.escape(ct('TOOL_CALL'))}",
+                    content,
+                )
+                (
+                    error_msg,
+                    has_multiple,
+                ) = ToolRegistry._check_and_handle_multiple_tool_calls(
+                    content, multiple_blocks
+                )
+                if has_multiple:
+                    return (
+                        cast(Dict[str, Dict[str, Any]], {}),
+                        error_msg if error_msg else "",
+                        False,
+                    )
+
                 # 找到开始标签的位置
-                open_tag_match = re.search(rf'(?i){re.escape(ot("TOOL_CALL"))}', content)
+                open_tag_match = re.search(
+                    rf"(?i){re.escape(ot('TOOL_CALL'))}", content
+                )
                 if open_tag_match:
                     # 从开始标签后提取JSON
                     start_pos = open_tag_match.end()
-                    json_str, end_pos = ToolRegistry._extract_json_from_text(content, start_pos)
-                    
+                    json_str, end_pos = ToolRegistry._extract_json_from_text(
+                        content, start_pos
+                    )
+
                     if json_str:
                         # 清理JSON字符串中的额外标记
                         json_str = ToolRegistry._clean_extra_markers(json_str)
-                        
+
                         # 尝试解析JSON
                         try:
                             parsed = json_loads(json_str)
                             # 验证是否包含必要字段
-                            if "name" in parsed and "arguments" in parsed and "want" in parsed:
+                            if "name" in parsed and "arguments" in parsed:
                                 data = [json_str]
                                 auto_completed = True
+                            else:
+                                # 记录缺少必要字段的错误
+                                missing_fields = []
+                                if "name" not in parsed:
+                                    missing_fields.append("name")
+                                if "arguments" not in parsed:
+                                    missing_fields.append("arguments")
+                                # 不立即返回错误，继续尝试其他方法，但记录信息用于后续错误提示
+                                pass
                         except Exception:
-                            # JSON解析失败，继续尝试其他方法
+                            # JSON解析失败，记录错误信息用于后续错误提示
+                            # 不立即返回错误，继续尝试其他方法（如大模型修复）
                             pass
-            
+                    else:
+                        # JSON提取失败：没有找到有效的JSON对象
+                        # 不立即返回错误，继续尝试其他方法（如大模型修复）
+                        pass
+
             # 如果仍然没有数据，尝试使用大模型修复
             if not data:
                 long_hint = ToolRegistry._get_long_response_hint(content)
-                error_msg = f"只有{ot('TOOL_CALL')}标签，未找到{ct('TOOL_CALL')}标签，调用格式错误，请检查工具调用格式。\n{tool_call_help}{long_hint}"
-                
+                # 检查是否有开始和结束标签，生成更准确的错误消息
+                has_open = (
+                    re.search(rf"(?i){re.escape(ot('TOOL_CALL'))}", content) is not None
+                )
+                has_close = (
+                    re.search(rf"(?i){re.escape(ct('TOOL_CALL'))}", content) is not None
+                )
+
+                if has_open and has_close:
+                    # 有开始和结束标签，但JSON解析失败
+                    error_msg = f"工具调用格式错误：检测到{ot('TOOL_CALL')}和{ct('TOOL_CALL')}标签，但JSON解析失败。请检查JSON格式是否正确，确保包含name和arguments字段。\n{tool_call_help}{long_hint}"
+                elif has_open and not has_close:
+                    # 只有开始标签，没有结束标签
+                    error_msg = f"工具调用格式错误：检测到{ot('TOOL_CALL')}标签，但未找到{ct('TOOL_CALL')}标签。请确保工具调用包含完整的开始和结束标签。\n{tool_call_help}{long_hint}"
+                else:
+                    # 其他情况
+                    error_msg = f"工具调用格式错误：无法解析工具调用内容。请检查工具调用格式。\n{tool_call_help}{long_hint}"
+
                 # 如果提供了agent且long_hint为空，尝试使用大模型修复
                 if agent is not None and not long_hint:
-                    fixed_content = ToolRegistry._try_llm_fix(content, agent, error_msg)
-                    if fixed_content:
+                    llm_fixed_content: Optional[str] = ToolRegistry._try_llm_fix(
+                        content, agent, error_msg
+                    )
+                    if llm_fixed_content is not None:
                         # 递归调用自身，尝试解析修复后的内容
                         return ToolRegistry._extract_tool_calls(fixed_content, None)
-                
+
                 # 如果大模型修复失败或未提供agent或long_hint不为空，返回错误
                 return (
                     {},
                     error_msg,
                     False,
                 )
-        
+
         ret = []
         for item in data:
             try:
@@ -831,20 +1030,46 @@ class ToolRegistry(OutputHandlerProtocol):
                 cleaned_item = ToolRegistry._clean_extra_markers(item)
                 msg = json_loads(cleaned_item)
             except Exception as e:
+                # 如果解析失败，先检查是否是因为有多个工具调用
+                # 检查错误信息中是否包含 "expected a comma" 或类似的多对象错误
+                error_str = str(e).lower()
+                if "expected a comma" in error_str or "multiple" in error_str:
+                    # 尝试检测是否有多个工具调用块
+                    multiple_blocks = re.findall(
+                        rf"(?msi){re.escape(ot('TOOL_CALL'))}(.*?){re.escape(ct('TOOL_CALL'))}",
+                        content,
+                    )
+                    (
+                        error_msg,
+                        has_multiple,
+                    ) = ToolRegistry._check_and_handle_multiple_tool_calls(
+                        content, multiple_blocks
+                    )
+                    if has_multiple:
+                        return (
+                            cast(Dict[str, Dict[str, Any]], {}),
+                            error_msg if error_msg else "",
+                            False,
+                        )
+
                 long_hint = ToolRegistry._get_long_response_hint(content)
                 error_msg = f"""Jsonnet 解析失败：{e}
 
 提示：Jsonnet支持双引号/单引号、尾随逗号、注释。多行字符串推荐使用 ||| 或 ``` 分隔符包裹，直接换行无需转义，支持保留缩进。
 
 {tool_call_help}{long_hint}"""
-                
+
                 # 如果提供了agent且long_hint为空，尝试使用大模型修复
                 if agent is not None and not long_hint:
-                    fixed_content = ToolRegistry._try_llm_fix(content, agent, error_msg)
-                    if fixed_content:
+                    retry_fixed_content: Optional[str] = ToolRegistry._try_llm_fix(
+                        content, agent, error_msg
+                    )
+                    if retry_fixed_content is not None:
                         # 递归调用自身，尝试解析修复后的内容
-                        return ToolRegistry._extract_tool_calls(fixed_content, None)
-                
+                        return ToolRegistry._extract_tool_calls(
+                            retry_fixed_content, None
+                        )
+
                 # 如果大模型修复失败或未提供agent或long_hint不为空，返回错误
                 return (
                     {},
@@ -852,21 +1077,23 @@ class ToolRegistry(OutputHandlerProtocol):
                     False,
                 )
 
-            if "name" in msg and "arguments" in msg and "want" in msg:
+            if "name" in msg and "arguments" in msg:
                 ret.append(msg)
             else:
                 long_hint = ToolRegistry._get_long_response_hint(content)
-                error_msg = f"""工具调用格式错误，请检查工具调用格式（缺少name、arguments、want字段）。
+                error_msg = f"""工具调用格式错误，请检查工具调用格式（缺少name、arguments字段）。
 
                 {tool_call_help}{long_hint}"""
-                
+
                 # 如果提供了agent且long_hint为空，尝试使用大模型修复
                 if agent is not None and not long_hint:
-                    fixed_content = ToolRegistry._try_llm_fix(content, agent, error_msg)
-                    if fixed_content:
+                    fixed_content_3: Optional[str] = ToolRegistry._try_llm_fix(
+                        content, agent, error_msg
+                    )
+                    if fixed_content_3 is not None:
                         # 递归调用自身，尝试解析修复后的内容
-                        return ToolRegistry._extract_tool_calls(fixed_content, None)
-                
+                        return ToolRegistry._extract_tool_calls(fixed_content_3, None)
+
                 # 如果大模型修复失败或未提供agent或long_hint不为空，返回错误
                 return (
                     {},
@@ -894,7 +1121,7 @@ class ToolRegistry(OutputHandlerProtocol):
             func: 工具执行函数
         """
         if name in self.tools:
-            print(f"⚠️ 警告: 工具 '{name}' 已存在，将被覆盖")
+            PrettyOutput.auto_print(f"⚠️ 警告: 工具 '{name}' 已存在，将被覆盖")
         self.tools[name] = Tool(name, description, parameters, func, protocol_version)
 
     def get_tool(self, name: str) -> Optional[Tool]:
@@ -956,7 +1183,7 @@ class ToolRegistry(OutputHandlerProtocol):
         try:
             if getattr(tool, "protocol_version", "1.0") == "2.0":
                 # v2.0: agent与参数分离传递
-                return tool.func(arguments, agent)  # type: ignore[misc]
+                return cast(Dict[str, Any], tool.func(arguments, agent))
             else:
                 # v1.0: 兼容旧实现，将agent注入到arguments（如果提供）
                 args_to_call = arguments.copy() if isinstance(arguments, dict) else {}
@@ -999,7 +1226,7 @@ class ToolRegistry(OutputHandlerProtocol):
         """
         if len(output.splitlines()) > 60:
             lines = output.splitlines()
-            print("⚠️ 输出太长，截取前后30行") 
+            PrettyOutput.auto_print("⚠️ 输出太长，截取前后30行")
             return "\n".join(
                 lines[:30] + ["\n...内容太长，已截取前后30行...\n"] + lines[-30:]
             )
@@ -1009,7 +1236,7 @@ class ToolRegistry(OutputHandlerProtocol):
         try:
             name = tool_call["name"]  # 确保name是str类型
             args = tool_call["arguments"]  # 原始参数（来自外部协议）
-            want = tool_call["want"]
+            want = tool_call.get("want", "")
 
             from jarvis.jarvis_agent import Agent
 
@@ -1025,31 +1252,82 @@ class ToolRegistry(OutputHandlerProtocol):
                         usage_prompt = agent_instance.get_tool_usage_prompt()
                     except Exception:
                         usage_prompt = tool_call_help
-                    print("❌ 工具参数格式无效") 
+                    PrettyOutput.auto_print("❌ 工具参数格式无效")
                     return f"工具参数格式无效: {name}。arguments 应为可解析的 Jsonnet 或对象，请按工具调用格式提供。\n提示：对于多行字符串参数，推荐使用 ||| 或 ``` 分隔符包裹，直接换行无需转义，支持保留缩进。\n\n{usage_prompt}"
 
-            print(f"🛠️ 执行工具调用 {name}") 
+            # 生成参数摘要，过滤敏感信息
+            param_summary = ""
+            if isinstance(args, dict) and args:
+                # 敏感字段列表
+                sensitive_keys = {
+                    "password",
+                    "token",
+                    "key",
+                    "secret",
+                    "auth",
+                    "credential",
+                }
+                summary_parts = []
+
+                for key, value in args.items():
+                    if key.lower() in sensitive_keys:
+                        summary_parts.append(f"{key}='***'")
+                    elif isinstance(value, (dict, list)):
+                        # 复杂类型简化为类型信息
+                        summary_parts.append(
+                            f"{key}={type(value).__name__}({len(value)} items)"
+                        )
+                    elif isinstance(value, str) and len(value) > 50:
+                        # 长字符串截断
+                        summary_parts.append(f"{key}='{value[:47]}...'")
+                    else:
+                        summary_parts.append(f"{key}={repr(value)}")
+
+                if summary_parts:
+                    # 将参数值中的换行符替换为空格，避免摘要中出现换行
+                    cleaned_parts = [
+                        part.replace("\n", " ").replace("\r", " ")
+                        for part in summary_parts
+                    ]
+                    param_summary = " | ".join(cleaned_parts)
+
+            # 合并为一行输出：执行工具调用和参数摘要
+            if param_summary:
+                PrettyOutput.auto_print(f"🛠️ 执行工具调用 {name} [{param_summary}]")
+            else:
+                PrettyOutput.auto_print(f"🛠️ 执行工具调用 {name}")
+
             # 执行工具调用（根据工具实现的协议版本，由系统在内部决定agent的传递方式）
             result = self.execute_tool(name, args, agent)
-            
+
             # 打印执行状态
             if result.get("success", False):
-                print(f"✅ 执行工具调用 {name} 成功")
+                PrettyOutput.auto_print(f"✅ 执行工具调用 {name} 成功")
             else:
-                print(f"❌ 执行工具调用 {name} 失败")
+                # 获取失败原因
+                stderr = result.get("stderr", "")
+                stdout = result.get("stdout", "")
+                error_msg = stderr if stderr else (stdout if stdout else "未知错误")
+                PrettyOutput.auto_print(f"❌ 执行工具调用 {name} 失败")
+                PrettyOutput.auto_print(f"   失败原因: {error_msg}")
 
             # 记录本轮实际执行的工具，供上层逻辑（如记忆保存判定）使用
             try:
                 from jarvis.jarvis_agent import Agent  # 延迟导入避免循环依赖
+
                 agent_instance_for_record: Agent = agent_instance
                 # 记录最后一次执行的工具
-                agent_instance_for_record.set_user_data("__last_executed_tool__", name)  # type: ignore
+                agent_instance_for_record.set_user_data("__last_executed_tool__", name)
                 # 记录本轮累计执行的工具列表
-                executed_list = agent_instance_for_record.get_user_data("__executed_tools__")  # type: ignore
+                executed_list = agent_instance_for_record.get_user_data(
+                    "__executed_tools__"
+                )
                 if not isinstance(executed_list, list):
                     executed_list = []
                 executed_list.append(name)
-                agent_instance_for_record.set_user_data("__executed_tools__", executed_list)  # type: ignore
+                agent_instance_for_record.set_user_data(
+                    "__executed_tools__", executed_list
+                )
             except Exception:
                 pass
 
@@ -1059,7 +1337,9 @@ class ToolRegistry(OutputHandlerProtocol):
                     usage_prompt = agent_instance.get_tool_usage_prompt()
                 except Exception:
                     usage_prompt = tool_call_help
-                err_output = self._format_tool_output(result.get("stdout", ""), result.get("stderr", ""))
+                err_output = self._format_tool_output(
+                    result.get("stdout", ""), result.get("stderr", "")
+                )
                 return f"{err_output}\n\n{usage_prompt}"
 
             # 格式化输出
@@ -1068,11 +1348,9 @@ class ToolRegistry(OutputHandlerProtocol):
             )
 
             # 检查内容是否过大
-            model_group = None
-            platform = None
-            if agent_instance.model:
-                model_group = agent_instance.model.model_group
-                platform = agent_instance.model
+            # 使用全局模型组（不再从 agent 继承）
+            model_group = get_global_model_group()
+            platform = agent_instance.model if agent_instance.model else None
             is_large_content = is_context_overflow(output, model_group, platform)
 
             if is_large_content:
@@ -1106,7 +1384,7 @@ class ToolRegistry(OutputHandlerProtocol):
 </content>
 
 上传的文件是以下工具执行结果：
-{json.dumps({"name":name, "arguments":args, "want":want}, ensure_ascii=False, indent=2)}
+{json.dumps({"name": name, "arguments": args, "want": want}, ensure_ascii=False, indent=2)}
 
 请根据以上信息，继续完成任务。
 """
@@ -1126,17 +1404,18 @@ class ToolRegistry(OutputHandlerProtocol):
             # 尝试获取工具名称（如果已定义）
             tool_name = ""
             try:
-                if 'name' in locals():
+                if "name" in locals():
                     tool_name = name
             except Exception:
                 pass
             if tool_name:
-                print(f"❌ 执行工具调用 {tool_name} 失败：{str(e)}")
+                PrettyOutput.auto_print(f"❌ 执行工具调用 {tool_name} 失败：{str(e)}")
             else:
-                print(f"❌ 工具调用失败：{str(e)}")
+                PrettyOutput.auto_print(f"❌ 工具调用失败：{str(e)}")
             try:
                 from jarvis.jarvis_agent import Agent  # 延迟导入避免循环依赖
-                agent_instance_for_prompt: Agent = agent  # type: ignore
+
+                agent_instance_for_prompt: Agent = agent
                 usage_prompt = agent_instance_for_prompt.get_tool_usage_prompt()
             except Exception:
                 usage_prompt = tool_call_help