jarvis-ai-assistant 0.7.0__py3-none-any.whl → 0.7.6__py3-none-any.whl

jarvis/jarvis_tools/registry.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+from jarvis.jarvis_utils.jsonnet_compat import loads as json_loads
 import json
 import os
 import re
@@ -15,95 +16,58 @@ 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.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.tag import ct, ot
 from jarvis.jarvis_utils.utils import is_context_overflow, daily_check_git_updates
 
+_multiline_example = """  {
+    "multiline_str": |||
+      第一行：直接换行，无需 \\n
+      第二行：包含"双引号"，无需转义
+      第三行：包含'单引号'，直接写
+      第四行：支持缩进保留
+    |||
+  }
+  
+  或使用 ``` 代替 |||：
+  {
+    "multiline_str": ```
+      第一行：直接换行，无需 \\n
+      第二行：包含"双引号"，无需转义
+      第三行：包含'单引号'，直接写
+      第四行：支持缩进保留
+    ```
+  }"""
+
 tool_call_help = f"""
 <tool_system_guide>
-<introduction>
-# 🛠️ 工具使用系统
-您正在使用一个需要精确格式和严格规则的工具执行系统。
-</introduction>
-
-<format>
-# 📋 工具调用格式
+工具调用格式（Jsonnet）：
 {ot("TOOL_CALL")}
-want: 想要从执行结果中获取到的信息，如果工具输出内容过长，会根据此字段尝试提取有效信息
-name: 工具名称
-
-arguments:
-  param1: 值1
-  param2: 值2
+{{
+  "want": "想要从执行结果中获取到的信息",
+  "name": "工具名称",
+  "arguments": {{
+    "param1": "值1",
+    "param2": "值2"
+  }}
+}}
 {ct("TOOL_CALL")}
-</format>
-
-<rules>
-# ❗ 关键规则
-<rule>
-### 1. 每次只使用一个工具
-- 一次只执行一个工具
-- 等待结果后再进行下一步
-</rule>
-
-<rule>
-### 2. 严格遵守格式
-- 完全按照上述格式
-- 使用正确的YAML格式，2个空格作为缩进
-- 包含所有必需参数
-- {ot("TOOL_CALL")} 和 {ct("TOOL_CALL")} 必须出现在行首
-</rule>
-
-<rule>
-### 3. 结果处理
-- 等待执行结果
-- 不要假设结果
-- 不要创建虚假响应
-- 不要想象对话
-</rule>
-
-<rule>
-### 4. 信息管理
-- 如果信息不足，询问用户
-- 跳过不必要的步骤
-- 如果卡住，请求指导
-- 不要在没有完整信息的情况下继续
-</rule>
-</rules>
-
-<string_format>
-# 📝 字符串参数格式
-使用 |2 语法表示字符串参数，防止多行字符串行首空格引起歧义。
-
-{ot("TOOL_CALL")}
-want: 当前的git状态，期望获取xxx的提交记录
-name: execute_script
 
-arguments:
-  interpreter: bash
-  script_content: |
-    git status --porcelain
-{ct("TOOL_CALL")}
-</string_format>
-
-<best_practices>
-# 💡 最佳实践
-- 准备好后立即开始执行
-- 无需请求许可即可开始
-- 使用正确的字符串格式
-- 监控进度并调整
-- 遇到困难时请求帮助
-</best_practices>
-
-<common_errors>
-# ⚠️ 常见错误
-- 同时调用多个工具
-- 假设工具结果
-- 创建虚构对话
-- 在没有所需信息的情况下继续
-- yaml 格式错误
-- {ot("TOOL_CALL")} 和 {ct("TOOL_CALL")} 没有出现在行首
-</common_errors>
+Jsonnet格式特性：
+- 字符串引号：可使用双引号或单引号
+- 多行字符串：推荐使用 ||| 或 ``` 分隔符包裹多行字符串，直接换行无需转义，支持保留缩进
+  示例：
+{_multiline_example}
+- 尾随逗号：对象/数组最后一个元素后可添加逗号
+- 注释：支持 // 单行或 /* */ 多行注释
+
+关键规则：
+1. 每次只使用一个工具，等待结果后再进行下一步
+2. {ot("TOOL_CALL")} 和 {ct("TOOL_CALL")} 必须出现在行首
+3. 多行字符串参数推荐使用 ||| 或 ``` 分隔符包裹，直接换行无需转义，支持保留缩进
+4. 等待执行结果，不要假设或创建虚假响应
+5. 信息不足时询问用户，不要在没有完整信息的情况下继续
+
+常见错误：同时调用多个工具、假设工具结果、Jsonnet格式错误、标签未出现在行首
 </tool_system_guide>
 """
 
@@ -123,8 +87,11 @@ class ToolRegistry(OutputHandlerProtocol):
         return "TOOL_CALL"
 
     def can_handle(self, response: str) -> bool:
-        # 仅当 {ot("TOOL_CALL")} 出现在行首时才认为可以处理
-        return re.search(rf'(?m){re.escape(ot("TOOL_CALL"))}', response) is not None
+        # 仅当 {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
+        return has_tool_call
 
     def prompt(self) -> str:
         """加载工具"""
@@ -139,30 +106,26 @@ class ToolRegistry(OutputHandlerProtocol):
                     tools_prompt += f"      <name>名称: {tool['name']}</name>\n"
                     tools_prompt += f"      <description>描述: {tool['description']}</description>\n"
                     tools_prompt += "      <parameters>\n"
-                    tools_prompt += "        <yaml>|\n"
+                    tools_prompt += "        <json>|\n"
 
-                    # 生成格式化的YAML参数
-                    yaml_params = yaml.dump(
+                    # 生成格式化的JSON参数
+                    json_params = json.dumps(
                         tool["parameters"],
-                        allow_unicode=True,
-                        indent=4,
+                        ensure_ascii=False,
+                        indent=2,
                         sort_keys=False,
-                        width=120,  # 增加行宽限制
                     )
 
                     # 添加缩进并移除尾部空格
-                    for line in yaml_params.split("\n"):
+                    for line in json_params.split("\n"):
                         tools_prompt += f"          {line.rstrip()}\n"
 
-                    tools_prompt += "        </yaml>\n"
+                    tools_prompt += "        </json>\n"
                     tools_prompt += "      </parameters>\n"
                     tools_prompt += "    </tool>\n"
 
-                except yaml.YAMLError as e:
-                    PrettyOutput.print(
-                        f"工具 {tool['name']} 参数序列化失败: {str(e)}",
-                        OutputType.ERROR,
-                    )
+                except Exception as e:
+                    print(f"❌ 工具 {tool['name']} 参数序列化失败: {str(e)}")
                     continue
 
             tools_prompt += "  </tools_list>\n"
@@ -173,7 +136,8 @@ class ToolRegistry(OutputHandlerProtocol):
 
     def handle(self, response: str, agent_: Any) -> Tuple[bool, Any]:
         try:
-            tool_call, err_msg, auto_completed = self._extract_tool_calls(response)
+            # 传递agent给_extract_tool_calls，以便在解析失败时调用大模型修复
+            tool_call, err_msg, auto_completed = self._extract_tool_calls(response, agent_)
             if err_msg:
                 # 只要工具解析错误，追加工具使用帮助信息（相当于一次 <ToolUsage>）
                 try:
@@ -190,7 +154,7 @@ class ToolRegistry(OutputHandlerProtocol):
                 result = f"检测到工具调用缺少结束标签，已自动补全{ct('TOOL_CALL')}。请确保后续工具调用包含完整的开始和结束标签。\n\n{result}"
             return False, result
         except Exception as e:
-            PrettyOutput.print(f"工具调用处理失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 工具调用处理失败: {str(e)}")
             from jarvis.jarvis_agent import Agent
 
             agent: Agent = agent_
@@ -202,6 +166,8 @@ class ToolRegistry(OutputHandlerProtocol):
     def __init__(self) -> None:
         """初始化工具注册表"""
         self.tools: Dict[str, Tool] = {}
+        # 记录内置工具名称，用于区分内置工具和用户自定义工具
+        self._builtin_tool_names: set = set()
         # 加载内置工具和外部工具
         self._load_builtin_tools()
         self._load_external_tools()
@@ -255,10 +221,7 @@ class ToolRegistry(OutputHandlerProtocol):
         """
         missing_tools = [tool_name for tool_name in name if tool_name not in self.tools]
         if missing_tools:
-            PrettyOutput.print(
-                f"工具 {missing_tools} 不存在，可用的工具有: {', '.join(self.tools.keys())}",
-                OutputType.WARNING,
-            )
+            print(f"⚠️ 工具 {missing_tools} 不存在，可用的工具有: {', '.join(self.tools.keys())}")
         self.tools = {
             tool_name: self.tools[tool_name]
             for tool_name in name
@@ -292,10 +255,7 @@ class ToolRegistry(OutputHandlerProtocol):
                 else:
                     missing.append(tool_name)
             if missing:
-                PrettyOutput.print(
-                    "警告: 配置的工具不存在: " + ", ".join(f"'{name}'" for name in missing),
-                    OutputType.WARNING,
-                )
+                print("⚠️ 警告: 配置的工具不存在: " + ", ".join(f"'{name}'" for name in missing))
             self.tools = filtered_tools
 
         # 如果配置了 dont_use 列表，排除列表中的工具
@@ -321,21 +281,19 @@ class ToolRegistry(OutputHandlerProtocol):
             return
 
         # 添加警告信息
-        PrettyOutput.print(
-            "警告: 从文件目录加载MCP工具的方式将在未来版本中废弃，请尽快迁移到JARVIS_MCP配置方式",
-            OutputType.WARNING,
-        )
+        print("⚠️ 警告: 从文件目录加载MCP工具的方式将在未来版本中废弃，请尽快迁移到JARVIS_MCP配置方式")
 
         # 遍历目录中的所有.yaml文件
         error_lines = []
         for file_path in mcp_tools_dir.glob("*.yaml"):
             try:
-                config = yaml.safe_load(open(file_path, "r", encoding="utf-8"))
+                with open(file_path, "r", encoding="utf-8") as f:
+                    config = yaml.safe_load(f)
                 self.register_mcp_tool_by_config(config)
             except Exception as e:
                 error_lines.append(f"文件 {file_path} 加载失败: {str(e)}")
         if error_lines:
-            PrettyOutput.print("\n".join(error_lines), OutputType.WARNING)
+            print("⚠️ " + "\n⚠️ ".join(error_lines))
 
     def _load_builtin_tools(self) -> None:
         """从内置工具目录加载工具"""
@@ -348,6 +306,9 @@ class ToolRegistry(OutputHandlerProtocol):
                 continue
 
             self.register_tool_by_file(str(file_path))
+        
+        # 记录当前已加载的工具名称为内置工具
+        self._builtin_tool_names = set(self.tools.keys())
 
     def _load_external_tools(self) -> None:
         """从jarvis_data/tools和配置的目录加载外部工具"""
@@ -377,9 +338,7 @@ class ToolRegistry(OutputHandlerProtocol):
                             ["git", "clone", central_repo, central_repo_path], check=True
                         )
                     except Exception as e:
-                        PrettyOutput.print(
-                            f"克隆中心工具仓库失败: {str(e)}", OutputType.ERROR
-                        )
+                        print(f"❌ 克隆中心工具仓库失败: {str(e)}")
 
         # --- 全局每日更新检查 ---
         daily_check_git_updates(tool_dirs, "tools")
@@ -408,9 +367,7 @@ class ToolRegistry(OutputHandlerProtocol):
         """
         try:
             if "type" not in config:
-                PrettyOutput.print(
-                    f"配置{config.get('name', '')}缺少type字段", OutputType.WARNING
-                )
+                print(f"⚠️ 配置{config.get('name', '')}缺少type字段")
                 return False
 
             # 检查enable标志
@@ -430,7 +387,7 @@ class ToolRegistry(OutputHandlerProtocol):
 
                     return {
                         "success": True,
-                        "stdout": yaml.safe_dump(ret, allow_unicode=True),
+                        "stdout": json.dumps(ret, ensure_ascii=False, indent=2),
                         "stderr": "",
                     }
 
@@ -466,29 +423,18 @@ class ToolRegistry(OutputHandlerProtocol):
 
             if config["type"] == "stdio":
                 if "command" not in config:
-                    PrettyOutput.print(
-                        f"配置{config.get('name', '')}缺少command字段",
-                        OutputType.WARNING,
-                    )
+                    print(f"⚠️ 配置{config.get('name', '')}缺少command字段")
                     return False
             elif config["type"] == "sse":
                 if "base_url" not in config:
-                    PrettyOutput.print(
-                        f"配置{config.get('name', '')}缺少base_url字段",
-                        OutputType.WARNING,
-                    )
+                    print(f"⚠️ 配置{config.get('name', '')}缺少base_url字段")
                     return False
             elif config["type"] == "streamable":
                 if "base_url" not in config:
-                    PrettyOutput.print(
-                        f"配置{config.get('name', '')}缺少base_url字段",
-                        OutputType.WARNING,
-                    )
+                    print(f"⚠️ 配置{config.get('name', '')}缺少base_url字段")
                     return False
             else:
-                PrettyOutput.print(
-                    f"不支持的MCP客户端类型: {config['type']}", OutputType.WARNING
-                )
+                print(f"⚠️ 不支持的MCP客户端类型: {config['type']}")
                 return False
 
             # 创建MCP客户端
@@ -505,10 +451,7 @@ class ToolRegistry(OutputHandlerProtocol):
             # 获取工具信息
             tools = mcp_client.get_tool_list()
             if not tools:
-                PrettyOutput.print(
-                    f"从配置{config.get('name', '')}获取工具列表失败",
-                    OutputType.WARNING,
-                )
+                print(f"⚠️ 从配置{config.get('name', '')}获取工具列表失败")
                 return False
 
             # 注册每个工具
@@ -546,9 +489,7 @@ class ToolRegistry(OutputHandlerProtocol):
             return True
 
         except Exception as e:
-            PrettyOutput.print(
-                f"MCP配置{config.get('name', '')}加载失败: {str(e)}", OutputType.WARNING
-            )
+            print(f"⚠️ MCP配置{config.get('name', '')}加载失败: {str(e)}")
             return False
 
     def register_tool_by_file(self, file_path: str) -> bool:
@@ -563,7 +504,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():
-                PrettyOutput.print(f"文件不存在: {p_file_path}", OutputType.ERROR)
+                print(f"❌ 文件不存在: {p_file_path}")
                 return False
 
             # 临时将父目录添加到sys.path
@@ -618,25 +559,176 @@ class ToolRegistry(OutputHandlerProtocol):
                 sys.path.remove(parent_dir)
 
         except Exception as e:
-            PrettyOutput.print(
-                f"从 {Path(file_path).name} 加载工具失败: {str(e)}", OutputType.ERROR
-            )
+            print(f"❌ 从 {Path(file_path).name} 加载工具失败: {str(e)}")
             return False
 
     @staticmethod
     def _has_tool_calls_block(content: str) -> bool:
-        """从内容中提取工具调用块（仅匹配行首标签）"""
-        pattern = rf'(?ms){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 ""
+
+    @staticmethod
+    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
+                - 第二个元素是JSON结束后的位置
+        """
+        # 跳过空白字符
+        pos = start_pos
+        while pos < len(text) and text[pos] in (' ', '\t', '\n', '\r'):
+            pos += 1
+        
+        if pos >= len(text):
+            return None, 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 == '\\':
+                escape_next = True
+                continue
+            
+            if not in_string:
+                if char in ('"', "'"):
+                    in_string = True
+                    string_char = char
+                elif char == '{':
+                    brace_count += 1
+                elif char == '}':
+                    brace_count -= 1
+                    if brace_count == 0:
+                        # 找到完整的JSON对象
+                        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'<\|.*?\|>',  # 匹配所有 <|...|> 格式的标记
+        ]
+        
+        cleaned = text
+        for pattern in extra_markers:
+            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"""你之前的工具调用格式有误，请根据工具使用说明修复以下内容。
+
+**错误信息：**
+{error_msg}
+
+**工具使用说明：**
+{tool_usage}
+
+**错误的工具调用内容：**
+{content}
+
+请修复上述工具调用内容，确保：
+1. 包含完整的 {ot("TOOL_CALL")} 和 {ct("TOOL_CALL")} 标签
+2. JSON格式正确，包含 name、arguments、want 三个字段
+3. 如果使用多行字符串，推荐使用 ||| 或 ``` 分隔符包裹
+
+请直接返回修复后的完整工具调用内容，不要添加其他说明文字。"""
+            
+            # 调用大模型修复
+            print("🤖 尝试使用大模型修复工具调用格式...")
+            fixed_content = agent_instance.model.chat_until_success(fix_prompt)  # type: ignore
+            
+            if fixed_content:
+                print("✅ 大模型修复完成")
+                return fixed_content
+            else:
+                print("❌ 大模型修复失败：返回内容为空")
+                return None
+                
+        except Exception as e:
+            print(f"❌ 大模型修复失败：{str(e)}")
+            return None
+
     @staticmethod
     def _extract_tool_calls(
         content: str,
+        agent: Optional[Any] = None,
     ) -> Tuple[Dict[str, Dict[str, Any]], str, bool]:
         """从内容中提取工具调用。
 
         参数:
             content: 包含工具调用的内容
+            agent: 可选的Agent实例，用于在解析失败时调用大模型修复
 
         返回:
             Tuple[Dict[str, Dict[str, Any]], str, bool]:
@@ -647,26 +739,33 @@ class ToolRegistry(OutputHandlerProtocol):
         异常:
             Exception: 如果工具调用缺少必要字段
         """
-        # 如果</TOOL_CALL>出现在响应的末尾，但是前面没有换行符，自动插入一个换行符进行修复
-        if content.rstrip().endswith(ct("TOOL_CALL")):
-            pos = content.rfind(ct("TOOL_CALL"))
+        # 如果</TOOL_CALL>出现在响应的末尾，但是前面没有换行符，自动插入一个换行符进行修复（忽略大小写）
+        close_tag = ct("TOOL_CALL")
+        # 使用正则表达式查找结束标签（忽略大小写），以获取实际位置和原始大小写
+        close_tag_pattern = re.escape(close_tag)
+        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'(?ms){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 not data:
             # can_handle 确保 ot("TOOL_CALL") 在内容中（行首）。
             # 如果数据为空，则表示行首的 ct("TOOL_CALL") 可能丢失。
-            has_open_at_bol = re.search(rf'(?m){re.escape(ot("TOOL_CALL"))}', content) is not None
-            has_close_at_bol = re.search(rf'(?m)^{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')}"
 
-                # 再次提取，并检查YAML是否有效
+                # 再次提取，并检查JSON是否有效
                 temp_data = re.findall(
                     pattern,
                     fixed_content,
@@ -674,45 +773,104 @@ class ToolRegistry(OutputHandlerProtocol):
 
                 if temp_data:
                     try:
-                        yaml.safe_load(temp_data[0])  # Check if valid YAML
-
-                        # Ask user for confirmation
-
+                        json_loads(temp_data[0])  # Check if valid JSON
                         data = temp_data
                         auto_completed = True
-                    except (yaml.YAMLError, EOFError, KeyboardInterrupt):
-                        # Even after fixing, it's not valid YAML, or user cancelled.
-                        # Fall through to the original error.
+                    except (Exception, EOFError, KeyboardInterrupt):
+                        # Even after fixing, it's not valid JSON, or user cancelled.
+                        # Fall through to try more lenient extraction.
                         pass
-
+            
+            # 如果仍然没有数据，尝试更宽松的提取：直接从开始标签后提取JSON
+            if not data:
+                # 找到开始标签的位置
+                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)
+                    
+                    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:
+                                data = [json_str]
+                                auto_completed = True
+                        except Exception:
+                            # 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}"
+                
+                # 如果提供了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:
+                        # 递归调用自身，尝试解析修复后的内容
+                        return ToolRegistry._extract_tool_calls(fixed_content, None)
+                
+                # 如果大模型修复失败或未提供agent或long_hint不为空，返回错误
                 return (
                     {},
-                    f"只有{ot('TOOL_CALL')}标签，未找到{ct('TOOL_CALL')}标签，调用格式错误，请检查工具调用格式。\n{tool_call_help}",
+                    error_msg,
                     False,
                 )
+        
         ret = []
         for item in data:
             try:
-                msg = yaml.safe_load(item)
+                # 清理可能存在的额外标记
+                cleaned_item = ToolRegistry._clean_extra_markers(item)
+                msg = json_loads(cleaned_item)
             except Exception as e:
+                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:
+                        # 递归调用自身，尝试解析修复后的内容
+                        return ToolRegistry._extract_tool_calls(fixed_content, None)
+                
+                # 如果大模型修复失败或未提供agent或long_hint不为空，返回错误
                 return (
                     {},
-                    f"""yaml 解析失败，请检查工具调用格式。
-                    {e}
-
-                {tool_call_help}""",
+                    error_msg,
                     False,
                 )
 
             if "name" in msg and "arguments" in msg and "want" in msg:
                 ret.append(msg)
             else:
+                long_hint = ToolRegistry._get_long_response_hint(content)
+                error_msg = f"""工具调用格式错误，请检查工具调用格式（缺少name、arguments、want字段）。
+
+                {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:
+                        # 递归调用自身，尝试解析修复后的内容
+                        return ToolRegistry._extract_tool_calls(fixed_content, None)
+                
+                # 如果大模型修复失败或未提供agent或long_hint不为空，返回错误
                 return (
                     {},
-                    f"""工具调用格式错误，请检查工具调用格式（缺少name、arguments、want字段）。
-
-                {tool_call_help}""",
+                    error_msg,
                     False,
                 )
         if len(ret) > 1:
@@ -736,9 +894,7 @@ class ToolRegistry(OutputHandlerProtocol):
             func: 工具执行函数
         """
         if name in self.tools:
-            PrettyOutput.print(
-                f"警告: 工具 '{name}' 已存在，将被覆盖", OutputType.WARNING
-            )
+            print(f"⚠️ 警告: 工具 '{name}' 已存在，将被覆盖")
         self.tools[name] = Tool(name, description, parameters, func, protocol_version)
 
     def get_tool(self, name: str) -> Optional[Tool]:
@@ -760,6 +916,18 @@ class ToolRegistry(OutputHandlerProtocol):
         """
         return [tool.to_dict() for tool in self.tools.values()]
 
+    def get_custom_tools(self) -> List[Dict[str, Any]]:
+        """获取用户自定义工具（非内置工具）
+
+        返回:
+            List[Dict[str, Any]]: 包含用户自定义工具信息的列表
+        """
+        return [
+            tool.to_dict()
+            for tool in self.tools.values()
+            if tool.name not in self._builtin_tool_names
+        ]
+
     def execute_tool(
         self, name: str, arguments: Dict[str, Any], agent: Optional[Any] = None
     ) -> Dict[str, Any]:
@@ -831,6 +999,7 @@ class ToolRegistry(OutputHandlerProtocol):
         """
         if len(output.splitlines()) > 60:
             lines = output.splitlines()
+            print("⚠️ 输出太长，截取前后30行") 
             return "\n".join(
                 lines[:30] + ["\n...内容太长，已截取前后30行...\n"] + lines[-30:]
             )
@@ -849,17 +1018,25 @@ class ToolRegistry(OutputHandlerProtocol):
             # 如果args是字符串，尝试解析为JSON
             if isinstance(args, str):
                 try:
-                    args = json.loads(args)
-                except json.JSONDecodeError:
+                    args = json_loads(args)
+                except Exception:
                     # 返回错误并附带完整的工具使用提示，指导下一次正确调用
                     try:
                         usage_prompt = agent_instance.get_tool_usage_prompt()
                     except Exception:
                         usage_prompt = tool_call_help
-                    return f"工具参数格式无效: {name}。arguments 应为可解析的 JSON 或对象，请按工具调用格式提供。\n\n{usage_prompt}"
+                    print("❌ 工具参数格式无效") 
+                    return f"工具参数格式无效: {name}。arguments 应为可解析的 Jsonnet 或对象，请按工具调用格式提供。\n提示：对于多行字符串参数，推荐使用 ||| 或 ``` 分隔符包裹，直接换行无需转义，支持保留缩进。\n\n{usage_prompt}"
 
+            print(f"🛠️ 执行工具调用 {name}") 
             # 执行工具调用（根据工具实现的协议版本，由系统在内部决定agent的传递方式）
             result = self.execute_tool(name, args, agent)
+            
+            # 打印执行状态
+            if result.get("success", False):
+                print(f"✅ 执行工具调用 {name} 成功")
+            else:
+                print(f"❌ 执行工具调用 {name} 失败")
 
             # 记录本轮实际执行的工具，供上层逻辑（如记忆保存判定）使用
             try:
@@ -892,9 +1069,11 @@ class ToolRegistry(OutputHandlerProtocol):
 
             # 检查内容是否过大
             model_group = None
+            platform = None
             if agent_instance.model:
                 model_group = agent_instance.model.model_group
-            is_large_content = is_context_overflow(output, model_group)
+                platform = agent_instance.model
+            is_large_content = is_context_overflow(output, model_group, platform)
 
             if is_large_content:
                 # 创建临时文件
@@ -927,7 +1106,7 @@ class ToolRegistry(OutputHandlerProtocol):
 </content>
 
 上传的文件是以下工具执行结果：
-{yaml.safe_dump({"name":name, "arguments":args, "want":want})}
+{json.dumps({"name":name, "arguments":args, "want":want}, ensure_ascii=False, indent=2)}
 
 请根据以上信息，继续完成任务。
 """
@@ -944,7 +1123,17 @@ class ToolRegistry(OutputHandlerProtocol):
             return output
 
         except Exception as e:
-            PrettyOutput.print(f"工具执行失败：{str(e)}", OutputType.ERROR)
+            # 尝试获取工具名称（如果已定义）
+            tool_name = ""
+            try:
+                if 'name' in locals():
+                    tool_name = name
+            except Exception:
+                pass
+            if tool_name:
+                print(f"❌ 执行工具调用 {tool_name} 失败：{str(e)}")
+            else:
+                print(f"❌ 工具调用失败：{str(e)}")
             try:
                 from jarvis.jarvis_agent import Agent  # 延迟导入避免循环依赖
                 agent_instance_for_prompt: Agent = agent  # type: ignore