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

jarvis/jarvis_tools/registry.py

@@ -51,6 +51,7 @@ arguments:
 - 完全按照上述格式
 - 使用正确的YAML格式，2个空格作为缩进
 - 包含所有必需参数
+- {ot("TOOL_CALL")} 和 {ct("TOOL_CALL")} 必须出现在行首
 </rule>
 
 <rule>
@@ -101,6 +102,7 @@ arguments:
 - 创建虚构对话
 - 在没有所需信息的情况下继续
 - yaml 格式错误
+- {ot("TOOL_CALL")} 和 {ct("TOOL_CALL")} 没有出现在行首
 </common_errors>
 </tool_system_guide>
 """
@@ -121,7 +123,8 @@ class ToolRegistry(OutputHandlerProtocol):
         return "TOOL_CALL"
 
     def can_handle(self, response: str) -> bool:
-        return ot("TOOL_CALL") in response
+        # 仅当 {ot("TOOL_CALL")} 出现在行首时才认为可以处理
+        return re.search(rf'(?m){re.escape(ot("TOOL_CALL"))}', response) is not None
 
     def prompt(self) -> str:
         """加载工具"""
@@ -172,7 +175,15 @@ class ToolRegistry(OutputHandlerProtocol):
         try:
             tool_call, err_msg, auto_completed = self._extract_tool_calls(response)
             if err_msg:
-                return False, err_msg
+                # 只要工具解析错误，追加工具使用帮助信息（相当于一次 <ToolUsage>）
+                try:
+                    from jarvis.jarvis_agent import Agent
+                    agent: Agent = agent_
+                    tool_usage = agent.get_tool_usage_prompt()
+                    return False, f"{err_msg}\n\n{tool_usage}"
+                except Exception:
+                    # 兼容处理：无法获取Agent或ToolUsage时，至少返回工具系统帮助信息
+                    return False, f"{err_msg}\n\n{tool_call_help}"
             result = self.handle_tool_calls(tool_call, agent_)
             if auto_completed:
                 # 如果自动补全了结束标签，在结果中添加说明信息
@@ -347,22 +358,28 @@ class ToolRegistry(OutputHandlerProtocol):
         # 如果配置了中心工具仓库，将其添加到加载路径
         central_repo = get_central_tool_repo()
         if central_repo:
-            # 中心工具仓库存储在数据目录下的特定位置
-            central_repo_path = os.path.join(get_data_dir(), "central_tool_repo")
-            tool_dirs.append(central_repo_path)
+            # 支持本地目录路径或Git仓库URL
+            expanded = os.path.expanduser(os.path.expandvars(central_repo))
+            if os.path.isdir(expanded):
+                # 直接使用本地目录（支持Git仓库的子目录）
+                tool_dirs.append(expanded)
+            else:
+                # 中心工具仓库存储在数据目录下的特定位置
+                central_repo_path = os.path.join(get_data_dir(), "central_tool_repo")
+                tool_dirs.append(central_repo_path)
 
-            # 确保中心工具仓库被克隆/更新
-            if not os.path.exists(central_repo_path):
-                try:
-                    import subprocess
+                # 确保中心工具仓库被克隆/更新
+                if not os.path.exists(central_repo_path):
+                    try:
+                        import subprocess
 
-                    subprocess.run(
-                        ["git", "clone", central_repo, central_repo_path], check=True
-                    )
-                except Exception as e:
-                    PrettyOutput.print(
-                        f"克隆中心工具仓库失败: {str(e)}", OutputType.ERROR
-                    )
+                        subprocess.run(
+                            ["git", "clone", central_repo, central_repo_path], check=True
+                        )
+                    except Exception as e:
+                        PrettyOutput.print(
+                            f"克隆中心工具仓库失败: {str(e)}", OutputType.ERROR
+                        )
 
         # --- 全局每日更新检查 ---
         daily_check_git_updates(tool_dirs, "tools")
@@ -608,11 +625,9 @@ class ToolRegistry(OutputHandlerProtocol):
 
     @staticmethod
     def _has_tool_calls_block(content: str) -> bool:
-        """从内容中提取工具调用块"""
-        return (
-            re.search(ot("TOOL_CALL") + r"(.*?)" + ct("TOOL_CALL"), content, re.DOTALL)
-            is not None
-        )
+        """从内容中提取工具调用块（仅匹配行首标签）"""
+        pattern = rf'(?ms){re.escape(ot("TOOL_CALL"))}(.*?)^{re.escape(ct("TOOL_CALL"))}'
+        return re.search(pattern, content) is not None
 
     @staticmethod
     def _extract_tool_calls(
@@ -632,23 +647,29 @@ class ToolRegistry(OutputHandlerProtocol):
         异常:
             Exception: 如果工具调用缺少必要字段
         """
+        # 如果</TOOL_CALL>出现在响应的末尾，但是前面没有换行符，自动插入一个换行符进行修复
+        if content.rstrip().endswith(ct("TOOL_CALL")):
+            pos = content.rfind(ct("TOOL_CALL"))
+            if pos > 0 and content[pos - 1] not in ("\n", "\r"):
+                content = content[:pos] + "\n" + content[pos:]
+
         # 将内容拆分为行
-        data = re.findall(
-            ot("TOOL_CALL") + r"(.*?)" + ct("TOOL_CALL"), content, re.DOTALL
-        )
+        pattern = rf'(?ms){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") 可能丢失。
-            if ot("TOOL_CALL") in content and ct("TOOL_CALL") not in content:
-                # 尝试通过附加结束标签来修复它
+            # 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
+            if has_open_at_bol and not has_close_at_bol:
+                # 尝试通过附加结束标签来修复它（确保结束标签位于行首）
                 fixed_content = content.strip() + f"\n{ct('TOOL_CALL')}"
 
                 # 再次提取，并检查YAML是否有效
                 temp_data = re.findall(
-                    ot("TOOL_CALL") + r"(.*?)" + ct("TOOL_CALL"),
+                    pattern,
                     fixed_content,
-                    re.DOTALL,
                 )
 
                 if temp_data:
@@ -830,10 +851,12 @@ class ToolRegistry(OutputHandlerProtocol):
                 try:
                     args = json.loads(args)
                 except json.JSONDecodeError:
-                    PrettyOutput.print(
-                        f"工具参数格式无效: {name} {tool_call_help}", OutputType.ERROR
-                    )
-                    return ""
+                    # 返回错误并附带完整的工具使用提示，指导下一次正确调用
+                    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}"
 
             # 执行工具调用（根据工具实现的协议版本，由系统在内部决定agent的传递方式）
             result = self.execute_tool(name, args, agent)
@@ -853,6 +876,15 @@ class ToolRegistry(OutputHandlerProtocol):
             except Exception:
                 pass
 
+            # 如果执行失败，附带工具使用提示返回
+            if not result.get("success", False):
+                try:
+                    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", ""))
+                return f"{err_output}\n\n{usage_prompt}"
+
             # 格式化输出
             output = self._format_tool_output(
                 result["stdout"], result.get("stderr", "")
@@ -913,4 +945,10 @@ class ToolRegistry(OutputHandlerProtocol):
 
         except Exception as e:
             PrettyOutput.print(f"工具执行失败：{str(e)}", OutputType.ERROR)
-            return f"工具调用失败: {str(e)}"
+            try:
+                from jarvis.jarvis_agent import Agent  # 延迟导入避免循环依赖
+                agent_instance_for_prompt: Agent = agent  # type: ignore
+                usage_prompt = agent_instance_for_prompt.get_tool_usage_prompt()
+            except Exception:
+                usage_prompt = tool_call_help
+            return f"工具调用失败: {str(e)}\n\n{usage_prompt}"

jarvis/jarvis_tools/search_web.py

@@ -2,7 +2,7 @@
 """网络搜索工具。"""
 from typing import Any, Dict
 
-import requests
+import requests  # type: ignore[import-untyped]
 from markdownify import markdownify as md  # type: ignore
 
 # pylint: disable=import-error,missing-module-docstring
@@ -147,11 +147,13 @@ class SearchWebTool:
                 if model.support_web():
                     model.set_web(True)
                     model.set_suppress_output(False)
-                    return {
-                        "stdout": model.chat_until_success(query),
-                        "stderr": "",
-                        "success": True,
-                    }
+                    response = model.chat_until_success(query)
+                    if response and response.strip():
+                        return {
+                            "stdout": response,
+                            "stderr": "",
+                            "success": True,
+                        }
 
         # 否则使用现有的模型选择流程
         if agent.model.support_web():
@@ -161,11 +163,13 @@ class SearchWebTool:
             model.set_model_name(agent.model.name())
             model.set_web(True)
             model.set_suppress_output(False)
-            return {
-                "stdout": model.chat_until_success(query),
-                "stderr": "",
-                "success": True,
-            }
+            response = model.chat_until_success(query)
+            if response and response.strip():
+                return {
+                    "stdout": response,
+                    "stderr": "",
+                    "success": True,
+                }
 
         return self._search_with_ddgs(query, agent)
 

jarvis/jarvis_tools/sub_agent.py

@@ -4,16 +4,17 @@ sub_agent 工具
 将子任务交给通用 Agent 执行，并返回执行结果。
 
 约定：
-- 必填参数：task, name, background, system_prompt, summary_prompt, use_tools
-- 继承父 Agent 的部分配置：model_group、input_handler、execute_tool_confirm、multiline_inputer；其他参数需显式提供
+- 必填参数：task, name, system_prompt, summary_prompt
+- 可选参数：background
+- 工具集：默认使用系统工具集（无需传入 use_tools）
+- 继承父 Agent 的部分配置：model_group、input_handler、execute_tool_confirm、multiline_inputer、non_interactive、use_methodology、use_analysis；其他参数需显式提供
 - 子Agent必须自动完成(auto_complete=True)且需要summary(need_summary=True)
 """
-from typing import Any, Dict, List
+from typing import Any, Dict
 import json
 
 from jarvis.jarvis_agent import Agent
 from jarvis.jarvis_utils.globals import delete_agent
-from jarvis.jarvis_tools.registry import ToolRegistry
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
@@ -27,7 +28,7 @@ class SubAgentTool:
 
     # 必须与文件名一致，供 ToolRegistry 自动注册
     name = "sub_agent"
-    description = "将子任务交给通用 Agent 执行，并返回执行结果（继承父Agent部分配置：model_group、input_handler、execute_tool_confirm、multiline_inputer；其他参数需显式提供，自动完成并生成总结）。"
+    description = "将子任务交给通用 Agent 执行，并返回执行结果（继承父Agent部分配置：model_group、input_handler、execute_tool_confirm、multiline_inputer、non_interactive、use_methodology、use_analysis；其他参数需显式提供，自动完成并生成总结）。"
     parameters = {
         "type": "object",
         "properties": {
@@ -41,7 +42,7 @@ class SubAgentTool:
             },
             "background": {
                 "type": "string",
-                "description": "任务背景与已知信息（必填，将与任务一并提供给子Agent）",
+                "description": "任务背景与已知信息（可选，将与任务一并提供给子Agent）",
             },
             "system_prompt": {
                 "type": "string",
@@ -51,25 +52,16 @@ class SubAgentTool:
                 "type": "string",
                 "description": "覆盖子Agent的总结提示词（必填）",
             },
-            "use_tools": {
-                "type": "array",
-                "items": {"type": "string"},
-                "description": "限制子Agent可用的工具名称列表（必填）。兼容以逗号分隔的字符串输入。可用的工具列表："
-                + "\n".join(
-                    [
-                        t["name"] + ": " + t["description"]
-                        for t in ToolRegistry().get_all_tools()
-                    ]
-                ),
+            "non_interactive": {
+                "type": "boolean",
+                "description": "是否启用无交互模式（可选，默认继承父Agent或系统默认）",
             },
         },
         "required": [
             "task",
             "name",
-            "background",
             "system_prompt",
             "summary_prompt",
-            "use_tools",
         ],
     }
 
@@ -105,16 +97,6 @@ class SubAgentTool:
             summary_prompt = str(args.get("summary_prompt", "")).strip()
             agent_name = str(args.get("name", "")).strip()
 
-            # 解析可用工具列表（支持数组或以逗号分隔的字符串）
-            _use_tools = args.get("use_tools", None)
-            use_tools: List[str] = []
-            if isinstance(_use_tools, list):
-                use_tools = [str(x).strip() for x in _use_tools if str(x).strip()]
-            elif isinstance(_use_tools, str):
-                use_tools = [s.strip() for s in _use_tools.split(",") if s.strip()]
-            else:
-                use_tools = []
-
             errors = []
             if not system_prompt:
                 errors.append("system_prompt 不能为空")
@@ -122,8 +104,6 @@ class SubAgentTool:
                 errors.append("summary_prompt 不能为空")
             if not agent_name:
                 errors.append("name 不能为空")
-            if not use_tools:
-                errors.append("use_tools 不能为空")
             if not background:
                 errors.append("background 不能为空")
 
@@ -137,20 +117,29 @@ class SubAgentTool:
             # 基于父Agent（如有）继承部分配置后创建子Agent
             parent_agent = args.get("agent", None)
             parent_model_group = None
-            parent_input_handler = None
             parent_execute_tool_confirm = None
             parent_multiline_inputer = None
+            parent_non_interactive = None
+            parent_use_methodology = None
+            parent_use_analysis = None
             try:
                 if parent_agent is not None:
                     if getattr(parent_agent, "model", None):
                         parent_model_group = getattr(parent_agent.model, "model_group", None)
-                    parent_input_handler = getattr(parent_agent, "input_handler", None)
                     parent_execute_tool_confirm = getattr(parent_agent, "execute_tool_confirm", None)
                     parent_multiline_inputer = getattr(parent_agent, "multiline_inputer", None)
+                    parent_non_interactive = getattr(parent_agent, "non_interactive", None)
+                    parent_use_methodology = getattr(parent_agent, "use_methodology", None)
+                    parent_use_analysis = getattr(parent_agent, "use_analysis", None)
             except Exception:
                 # 安全兜底：无法从父Agent获取配置则保持为None，使用系统默认
                 pass
 
+            # 可选参数：允许显式覆盖无交互模式
+            explicit_non_interactive = args.get("non_interactive", None)
+            if explicit_non_interactive is not None:
+                parent_non_interactive = bool(explicit_non_interactive)
+
             agent = Agent(
                 system_prompt=system_prompt,
                 name=agent_name,
@@ -158,24 +147,17 @@ class SubAgentTool:
                 model_group=parent_model_group,
                 summary_prompt=summary_prompt,
                 auto_complete=auto_complete,
-                output_handler=None,
                 use_tools=None,
-                input_handler=parent_input_handler,
                 execute_tool_confirm=parent_execute_tool_confirm,
                 need_summary=need_summary,
                 multiline_inputer=parent_multiline_inputer,
-                use_methodology=None,
-                use_analysis=None,
+                use_methodology=parent_use_methodology,
+                use_analysis=parent_use_analysis,
                 force_save_memory=None,
                 files=None,
+                non_interactive=parent_non_interactive,
             )
 
-            # 设置可用工具列表
-            try:
-                agent.set_use_tools(use_tools)
-            except Exception:
-                pass
-
             # 校验子Agent所用模型是否有效，必要时回退到平台可用模型
             try:
                 platform = getattr(agent, "model", None)

jarvis/jarvis_tools/sub_code_agent.py

@@ -4,12 +4,12 @@ sub_code_agent 工具
 将子任务交给 CodeAgent 执行，并返回执行结果。
 
 约定：
-- 仅接收一个参数：task
+- 必填参数：task
+- 可选参数：background
 - 不依赖父 Agent，所有配置使用系统默认与全局变量
 - 子Agent必须自动完成(auto_complete=True)且需要summary(need_summary=True)
 """
 from typing import Any, Dict, List
-import json
 
 from jarvis.jarvis_code_agent.code_agent import CodeAgent
 from jarvis.jarvis_utils.globals import delete_agent
@@ -19,7 +19,7 @@ from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 class SubCodeAgentTool:
     """
-    使用 CodeAgent 托管执行子任务，执行完立即清理内部 Agent。
+    使用 CodeAgent 托管执行子任务，执行完立即清理 CodeAgent 实例。
     - 不注册至全局
     - 使用系统默认/全局配置
     - 启用自动完成与总结
@@ -84,6 +84,7 @@ class SubCodeAgentTool:
                             parent_agent = None
                 except Exception:
                     parent_agent = None
+            parent_non_interactive = getattr(parent_agent, "non_interactive", None) if parent_agent is not None else None
             model_group = None
             use_tools: List[str] = []
             try:
@@ -115,7 +116,7 @@ class SubCodeAgentTool:
                     "search_web",
                     "ask_user",
                     "read_code",
-                    "rewrite_file",
+
                     "save_memory",
                     "retrieve_memory",
                     "clear_memory",
@@ -138,6 +139,7 @@ class SubCodeAgentTool:
                     need_summary=True,
                     append_tools=append_tools,
                     tool_group=tool_group,
+                    non_interactive=parent_non_interactive,
                 )
             except SystemExit as se:
                 # 将底层 sys.exit 转换为工具错误，避免终止进程
@@ -155,21 +157,21 @@ class SubCodeAgentTool:
 
             # 子Agent需要自动完成
             try:
-                code_agent.agent.auto_complete = True
+                code_agent.auto_complete = True
                 # 同步父Agent工具使用集（如可用）
                 if use_tools:
-                    code_agent.agent.set_use_tools(use_tools)
+                    code_agent.set_use_tools(use_tools)
                 # 同步父Agent的模型名称（如可用），以尽量保持平台与模型一致
                 if (
                     parent_agent is not None
                     and getattr(parent_agent, "model", None)
-                    and getattr(code_agent.agent, "model", None)
+                    and getattr(code_agent, "model", None)
                 ):
                     try:
                         parent_model_name = parent_agent.model.name()  # type: ignore[attr-defined]
                         if parent_model_name:
                             from typing import Any
-                            model_obj: Any = getattr(code_agent.agent, "model", None)
+                            model_obj: Any = getattr(code_agent, "model", None)
                             if model_obj is not None:
                                 model_obj.set_model_name(parent_model_name)
                                 # 模型有效性校验与回退，确保父Agent模型在子Agent平台上可用
@@ -194,18 +196,17 @@ class SubCodeAgentTool:
 
             # 执行子任务（无提交信息前后缀）
             ret = code_agent.run(enhanced_task, prefix="", suffix="")
-            stdout = ret if isinstance(ret, str) and ret else "任务执行完成"
 
-            # 主动清理内部 Agent，避免污染父Agent的全局状态
+            # 主动清理 CodeAgent 实例，避免污染父Agent的全局状态
             try:
-                inner_agent = code_agent.agent
-                delete_agent(inner_agent.name)
+                # CodeAgent 现在直接继承 Agent，所以直接使用 code_agent
+                delete_agent(code_agent.name)
             except Exception:
                 pass
 
             return {
                 "success": True,
-                "stdout": json.dumps({"result": stdout}, ensure_ascii=False, indent=2),
+                "stdout": ret,
                 "stderr": "",
             }
         except Exception as e:

jarvis/jarvis_tools/virtual_tty.py

@@ -279,7 +279,7 @@ class VirtualTTYTool:
                         line = process.stdout.readline()
                         if line:
                             agent.tty_sessions[tty_id]["output_queue"].put(line)
-                    except:
+                    except Exception:
                         break
 
             output_thread = _threading.Thread(target=read_output, daemon=True)