jarvis-ai-assistant 0.1.134__py3-none-any.whl → 0.1.138__py3-none-any.whl

jarvis/jarvis_tools/read_webpage.py

@@ -24,38 +24,38 @@ class WebpageTool:
         """Read webpage content using Playwright to handle JavaScript-rendered pages"""
         try:
             url = args["url"].strip()
-            
+
             with sync_playwright() as p:
                 # Launch browser
                 browser = p.chromium.launch(
                     headless=True,
                     args=['--disable-gpu', '--no-sandbox', '--disable-dev-shm-usage']
                 )
-                
+
                 # Create a new page with appropriate settings
                 page = browser.new_page(
                     user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36',
                     viewport={'width': 1920, 'height': 1080}
                 )
-                
+
                 # Set timeout to avoid long waits
                 page.set_default_timeout(30000)  # 30 seconds
-                
+
                 try:
                     # Navigate to URL and wait for page to load
                     response = page.goto(url, wait_until="domcontentloaded")
-                    
+
                     # Additional wait for network to be idle (with a timeout)
                     try:
                         page.wait_for_load_state("networkidle", timeout=10000)
                     except PlaywrightTimeoutError:
                         # Continue even if network doesn't become completely idle
                         pass
-                        
+
                     # Make sure we got a valid response
                     if not response or response.status >= 400:
                         raise Exception(f"Failed to load page: HTTP {response.status if response else 'No response'}")
-                    
+
                     # Get page title safely
                     title = "No title"
                     try:
@@ -68,26 +68,26 @@ class WebpageTool:
                                 title = title_element.text_content() or "No title"
                         except Exception:
                             pass
-                    
+
                     # Get the HTML content after JavaScript execution
                     html_content = page.content()
-                    
+
                 except Exception as e:
                     raise Exception(f"Error navigating to page: {str(e)}")
                 finally:
                     # Always close browser
                     browser.close()
-                
+
                 # Parse with BeautifulSoup and convert to markdown
                 markdown_content = self._html_to_markdown(html_content, url)
-                
+
                 # Build output in markdown format
                 output = [
                     f"# {title}",
                     f"Url: {url}",
                     markdown_content
                 ]
-                
+
                 return {
                     "success": True,
                     "stdout": "\n".join(output),
@@ -101,7 +101,7 @@ class WebpageTool:
                 "stdout": "",
                 "stderr": f"Failed to parse webpage: {str(e)}"
             }
-    
+
     def _create_soup_element(self, content):
         """Safely create a BeautifulSoup element, ensuring it's treated as markup"""
         if isinstance(content, str):
@@ -112,15 +112,15 @@ class WebpageTool:
             # Return an empty list if the div is None
             return []
         return content
-    
+
     def _html_to_markdown(self, html_content: str, base_url: str) -> str:
         """Convert HTML to Markdown format preserving the content structure"""
         soup = BeautifulSoup(html_content, 'html.parser')
-        
+
         # Remove unwanted elements
         for element in soup(['script', 'style', 'meta', 'noscript', 'head']):
             element.decompose()
-        
+
         # Process headings
         for level in range(1, 7):
             for heading in soup.find_all(f'h{level}'):
@@ -128,14 +128,14 @@ class WebpageTool:
                 heading_md = "\n\n" + "#" * level + " " + text + "\n\n"
                 new_element = self._create_soup_element(heading_md)
                 heading.replace_with(*new_element)
-        
+
         # Process paragraphs
         for p in soup.find_all('p'):
             text = p.get_text().strip()
             if text:
                 new_element = self._create_soup_element("\n\n" + text + "\n\n")
                 p.replace_with(*new_element)
-        
+
         # Process unordered lists
         for ul in soup.find_all('ul'):
             items = []
@@ -143,7 +143,7 @@ class WebpageTool:
                 items.append("* " + li.get_text().strip())
             new_element = self._create_soup_element("\n\n" + "\n".join(items) + "\n\n")
             ul.replace_with(*new_element)
-        
+
         # Process ordered lists
         for ol in soup.find_all('ol'):
             items = []
@@ -151,7 +151,7 @@ class WebpageTool:
                 items.append(str(i) + ". " + li.get_text().strip())
             new_element = self._create_soup_element("\n\n" + "\n".join(items) + "\n\n")
             ol.replace_with(*new_element)
-        
+
         # Process links (first pass)
         for a in soup.find_all('a', href=True):
             try:
@@ -166,7 +166,7 @@ class WebpageTool:
                     a.replace_with(*new_element)
             except (KeyError, AttributeError):
                 continue
-        
+
         # Process images
         for img in soup.find_all('img', src=True):
             try:
@@ -180,37 +180,37 @@ class WebpageTool:
                 img.replace_with(*new_element)
             except (KeyError, AttributeError, UnboundLocalError):
                 continue
-        
+
         # Process code blocks
         for pre in soup.find_all('pre'):
             code = pre.get_text().strip()
             pre_md = "\n\n```\n" + code + "\n```\n\n"
             new_element = self._create_soup_element(pre_md)
             pre.replace_with(*new_element)
-        
+
         # Process inline code
         for code in soup.find_all('code'):
             text = code.get_text().strip()
             code_md = "`" + text + "`"
             new_element = self._create_soup_element(code_md)
             code.replace_with(*new_element)
-        
+
         # Process line breaks
         for br in soup.find_all('br'):
             new_element = self._create_soup_element('\n')
             br.replace_with(*new_element)
-        
+
         # Get the full text
         markdown_text = soup.get_text()
-        
+
         # Clean up extra whitespace and line breaks
         markdown_text = re.sub(r'\n{3,}', '\n\n', markdown_text)
         markdown_text = re.sub(r'\s{2,}', ' ', markdown_text)
-        
+
         # Process links again (for any that might have been missed)
         link_pattern = r'\[([^\]]+)\]\(([^)]+)\)'
         all_links = re.findall(link_pattern, markdown_text)
-        
+
         # Add a section with all links at the end
         if all_links:
             link_section = ["", "## Links", ""]
@@ -220,7 +220,7 @@ class WebpageTool:
                 if link_entry not in seen_links:
                     link_section.append(link_entry)
                     seen_links.add(link_entry)
-            
+
             markdown_text += "\n\n" + "\n".join(link_section)
-        
-        return markdown_text.strip() 
+
+        return markdown_text.strip()

jarvis/jarvis_tools/registry.py

@@ -85,21 +85,40 @@ class ToolRegistry(OutputHandler):
         if self._extract_tool_calls(response):
             return True
         return False
-    
+
     def prompt(self) -> str:
         """加载工具"""
         tools = self.get_all_tools()
         if tools:
             tools_prompt = "## 可用工具:\n"
             for tool in tools:
-                tools_prompt += f"- 名称: {tool['name']}\n"
-                tools_prompt += f"  描述: {tool['description']}\n"
-                tools_prompt += f"  参数: {tool['parameters']}\n"
-            tools_prompt += tool_call_help
+                try:
+                    tools_prompt += f"- 名称: {tool['name']}\n"
+                    tools_prompt += f"  描述: {tool['description']}\n"
+                    tools_prompt += "  参数: |\n"
+
+                    # 生成格式化的YAML参数
+                    yaml_params = yaml.dump(
+                        tool['parameters'],
+                        allow_unicode=True,
+                        indent=4,
+                        sort_keys=False,
+                        width=120  # 增加行宽限制
+                    )
+
+                    # 添加缩进并移除尾部空格
+                    for line in yaml_params.split('\n'):
+                        tools_prompt += f"    {line.rstrip()}\n"
+
+                except yaml.YAMLError as e:
+                    PrettyOutput.print(f"工具 {tool['name']} 参数序列化失败: {str(e)}", OutputType.ERROR)
+                    continue
+
+            tools_prompt += tool_call_help.rstrip()  # 移除帮助文本尾部空格
             return tools_prompt
         return ""
-    
-    def handle(self, response: str) -> Tuple[bool, Any]:
+
+    def handle(self, response: str, agent: Any) -> Tuple[bool, Any]:
         tool_calls = self._extract_tool_calls(response)
         if len(tool_calls) > 1:
             PrettyOutput.print(f"操作失败：检测到多个操作。一次只能执行一个操作。尝试执行的操作：{', '.join([tool_call['name'] for tool_call in tool_calls])}", OutputType.WARNING)
@@ -107,7 +126,7 @@ class ToolRegistry(OutputHandler):
         if len(tool_calls) == 0:
             return False, ""
         tool_call = tool_calls[0]
-        return False, self.handle_tool_calls(tool_call)
+        return False, self.handle_tool_calls(tool_call, agent)
 
     def __init__(self):
         """初始化工具注册表"""
@@ -132,13 +151,13 @@ class ToolRegistry(OutputHandler):
     def _load_builtin_tools(self):
         """从内置工具目录加载工具"""
         tools_dir = Path(__file__).parent
-        
+
         # 遍历目录中的所有.py文件
         for file_path in tools_dir.glob("*.py"):
             # 跳过base.py和__init__.py
             if file_path.name in ["base.py", "__init__.py", "registry.py"]:
                 continue
-                
+
             self.register_tool_by_file(str(file_path))
 
     def _load_external_tools(self):
@@ -146,21 +165,21 @@ class ToolRegistry(OutputHandler):
         external_tools_dir = Path.home() / '.jarvis/tools'
         if not external_tools_dir.exists():
             return
-            
+
         # 遍历目录中的所有.py文件
         for file_path in external_tools_dir.glob("*.py"):
             # 跳过__init__.py
             if file_path.name == "__init__.py":
                 continue
-                
+
             self.register_tool_by_file(str(file_path))
 
     def register_tool_by_file(self, file_path: str):
         """从指定文件加载并注册工具
-        
+
         参数:
             file_path: 工具文件的路径
-            
+
         返回:
             bool: 工具是否加载成功
         """
@@ -169,35 +188,35 @@ class ToolRegistry(OutputHandler):
             if not p_file_path.exists() or not p_file_path.is_file():
                 PrettyOutput.print(f"文件不存在: {p_file_path}", OutputType.ERROR)
                 return False
-                
+
             # 临时将父目录添加到sys.path
             parent_dir = str(p_file_path.parent)
             sys.path.insert(0, parent_dir)
-            
+
             try:
                 # 使用标准导入机制导入模块
                 module_name = p_file_path.stem
                 module = __import__(module_name)
-                
+
                 # 在模块中查找工具类
                 tool_found = False
                 for item_name in dir(module):
                     item = getattr(module, item_name)
                     # 检查是否是类并具有必要属性
-                    if (isinstance(item, type) and 
-                        hasattr(item, 'name') and 
-                        hasattr(item, 'description') and 
+                    if (isinstance(item, type) and
+                        hasattr(item, 'name') and
+                        hasattr(item, 'description') and
                         hasattr(item, 'parameters') and
-                        hasattr(item, 'execute') and 
+                        hasattr(item, 'execute') and
                         item.name == module_name):
 
                         if hasattr(item, "check"):
                             if not item.check():
                                 continue
-                        
+
                         # 实例化工具类
                         tool_instance = item()
-                        
+
                         # 注册工具
                         self.register_tool(
                             name=tool_instance.name,
@@ -207,29 +226,29 @@ class ToolRegistry(OutputHandler):
                         )
                         tool_found = True
                         break
-                        
+
                 if not tool_found:
                     return False
-                    
+
                 return True
-                
+
             finally:
                 # 从sys.path中移除目录
                 sys.path.remove(parent_dir)
-                
+
         except Exception as e:
             PrettyOutput.print(f"从 {Path(file_path).name} 加载工具失败: {str(e)}", OutputType.ERROR)
             return False
     @staticmethod
     def _extract_tool_calls(content: str) -> List[Dict]:
         """从内容中提取工具调用。
-        
+
         参数:
             content: 包含工具调用的内容
-            
+
         返回:
             List[Dict]: 包含名称和参数的提取工具调用列表
-            
+
         异常:
             Exception: 如果工具调用缺少必要字段
         """
@@ -264,12 +283,13 @@ class ToolRegistry(OutputHandler):
             return {"success": False, "stderr": f"工具 {name} 不存在，可用的工具有: {', '.join(self.tools.keys())}", "stdout": ""}
         return tool.execute(arguments)
 
-    def handle_tool_calls(self, tool_call: Dict) -> str:
+    def handle_tool_calls(self, tool_call: Dict, agent: Any) -> str:
         """处理工具调用，只处理第一个工具"""
         try:
             # 只处理第一个工具调用
             name = tool_call["name"]
             args = tool_call["arguments"]
+            args["agent"] = agent
 
             tool_call_help = f"""
 # 🛠️ 工具使用系统
@@ -330,14 +350,14 @@ arguments:
 - 创建虚构对话
 - 在没有所需信息的情况下继续
 """
-            
+
             if isinstance(args, str):
                 try:
                     args = json.loads(args)
                 except json.JSONDecodeError:
                     PrettyOutput.print(f"工具参数格式无效: {name} {tool_call_help}", OutputType.ERROR)
                     return ""
-            
+
             # Execute tool call
             result = self.execute_tool(name, args)
 
@@ -350,14 +370,14 @@ arguments:
                 output_parts.append(f"错误:\n{stderr}")
             output = "\n\n".join(output_parts)
             output = "无输出和错误" if not output else output
-            
+
             # Process the result
             if result["success"]:
                 # If the output exceeds 4k characters, use a large model to summarize
                 if get_context_token_count(output) > self.max_token_count:
                     PrettyOutput.section("输出过长，正在总结...", OutputType.SYSTEM)
                     try:
-                        
+
                         model = PlatformRegistry.get_global_platform_registry().get_normal_platform()
                         model.set_suppress_output(False)
                         # If the output exceeds the maximum context length, only take the last part
@@ -391,7 +411,7 @@ arguments:
                         PrettyOutput.print(f"总结失败: {str(e)}", OutputType.ERROR)
                         output = f"输出过长 ({len(output)} 字符)，建议查看原始输出。\n前300字符预览:\n{output[:300]}..."
             return output
-            
+
         except Exception as e:
             PrettyOutput.print(f"工具执行失败：{str(e)}", OutputType.ERROR)
             return f"工具调用失败: {str(e)}"
@@ -419,13 +439,13 @@ def main():
     call_parser.add_argument('--args-file', type=str, help='从文件加载工具参数 (JSON格式)')
 
     args = parser.parse_args()
-    
+
     # 初始化工具注册表
     registry = ToolRegistry()
-    
+
     if args.command == 'list':
         tools = registry.get_all_tools()
-        
+
         if args.json:
             if args.detailed:
                 print(json.dumps(tools, indent=2, ensure_ascii=False))
@@ -445,17 +465,17 @@ def main():
                         req_mark = "*" if param_name in required else ""
                         desc = param_info.get('description', '无描述')
                         print(f"     - {param_name}{req_mark}: {desc}")
-    
+
     elif args.command == 'call':
         tool_name = args.tool_name
         tool = registry.get_tool(tool_name)
-        
+
         if not tool:
             PrettyOutput.print(f"错误: 工具 '{tool_name}' 不存在", OutputType.ERROR)
             available_tools = ", ".join([t["name"] for t in registry.get_all_tools()])
             print(f"可用工具: {available_tools}")
             return 1
-        
+
         # 获取参数
         tool_args = {}
         if args.args:
@@ -464,7 +484,7 @@ def main():
             except json.JSONDecodeError:
                 PrettyOutput.print("错误: 参数必须是有效的JSON格式", OutputType.ERROR)
                 return 1
-        
+
         elif args.args_file:
             try:
                 with open(args.args_file, 'r', encoding='utf-8') as f:
@@ -472,11 +492,11 @@ def main():
             except (json.JSONDecodeError, FileNotFoundError) as e:
                 PrettyOutput.print(f"错误: 无法从文件加载参数: {str(e)}", OutputType.ERROR)
                 return 1
-        
+
         # 检查必需参数
         required_params = tool.parameters.get('required', [])
         missing_params = [p for p in required_params if p not in tool_args]
-        
+
         if missing_params:
             PrettyOutput.print(f"错误: 缺少必需参数: {', '.join(missing_params)}", OutputType.ERROR)
             print("\n参数说明:")
@@ -486,30 +506,30 @@ def main():
                 desc = param_info.get('description', '无描述')
                 print(f"  - {param_name}: {desc}")
             return 1
-        
+
         # 执行工具
         with yaspin(text=f"正在执行工具 {tool_name}...").dots12:
             result = registry.execute_tool(tool_name, tool_args)
-        
+
         # 显示结果
         if result["success"]:
             PrettyOutput.section(f"工具 {tool_name} 执行成功", OutputType.SUCCESS)
         else:
             PrettyOutput.section(f"工具 {tool_name} 执行失败", OutputType.ERROR)
-            
+
         if result.get("stdout"):
             print("\n输出:")
             print(result["stdout"])
-            
+
         if result.get("stderr"):
             PrettyOutput.print("\n错误:", OutputType.ERROR)
             print(result["stderr"])
-            
+
         return 0 if result["success"] else 1
-    
+
     else:
         parser.print_help()
-    
+
     return 0
 
 

jarvis/jarvis_tools/tool_generator.py

@@ -11,7 +11,7 @@ from jarvis.jarvis_utils.utils import ct, ot
 
 class ToolGenerator:
     """工具生成器类，用于自动创建与Jarvis系统集成的新工具"""
-    
+
     name = "tool_generator"
     description = "使用LLM自动生成与系统集成的新工具"
     parameters = {
@@ -22,7 +22,7 @@ class ToolGenerator:
                 "description": "新工具的名称"
             },
             "description": {
-                "type": "string", 
+                "type": "string",
                 "description": "工具用途描述"
             },
             "input_spec": {
@@ -32,7 +32,7 @@ class ToolGenerator:
         },
         "required": ["tool_name", "description", "input_spec"]
     }
-    
+
     def execute(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
         """
         执行工具生成过程
@@ -43,19 +43,19 @@ class ToolGenerator:
         """
         # 获取代码生成平台实例
         model = PlatformRegistry.get_global_platform_registry().get_normal_platform()
-        
+
         try:
             tool_name = arguments["tool_name"]
             description = arguments["description"]
             input_spec = arguments["input_spec"]
-            
+
             # 使用LLM生成工具实现代码
             with yaspin(text="正在生成工具...", color="cyan") as spinner:
                 prompt = self._create_prompt(tool_name, description, input_spec)
                 llm_response = model.chat_until_success(prompt)
                 spinner.text = "工具生成完成"
                 spinner.ok("✅")
-            
+
             # 从LLM响应中提取实现代码
             with yaspin(text="正在提取工具实现...", color="cyan") as spinner:
                 implementation = self._extract_code(llm_response)
@@ -67,7 +67,7 @@ class ToolGenerator:
                     }
                 spinner.text = "工具实现提取完成"
                 spinner.ok("✅")
-            
+
             # 验证生成的工具代码是否符合返回值格式要求
             with yaspin(text="正在验证工具返回值格式...", color="cyan") as spinner:
                 if not self._validate_return_value_format(implementation):
@@ -78,31 +78,31 @@ class ToolGenerator:
                     }
                 spinner.text = "工具返回值格式验证完成"
                 spinner.ok("✅")
-            
+
             # 保存生成的新工具
             with yaspin(text="正在保存工具...", color="cyan") as spinner:
                 tools_dir = Path.home() / ".jarvis" / "tools"
                 tools_dir.mkdir(parents=True, exist_ok=True)
                 tool_file = tools_dir / f"{tool_name}.py"
-                
+
                 with open(tool_file, "w", errors="ignore") as f:
                     f.write(implementation)
                 spinner.text = "工具保存完成"
                 spinner.ok("✅")
-            
+
             return {
                 "success": True,
                 "stdout": f"工具成功生成于: {tool_file}",
                 "stderr": ""
             }
-            
+
         except Exception as e:
             return {
                 "success": False,
                 "stdout": "",
                 "stderr": f"工具生成失败: {str(e)}"
             }
-    
+
     def _create_prompt(self, tool_name: str, description: str, input_spec: str) -> str:
         """
         创建用于工具生成的LLM提示
@@ -134,10 +134,10 @@ class CustomTool:
 
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
         """执行工具功能
-        
+
         Args:
             args: 传递给工具的参数
-            
+
         Returns:
             {
                 "success": bool,
@@ -148,7 +148,7 @@ class CustomTool:
         try:
             # 在此实现工具逻辑
             # 使用LLM
-            # model = PlatformRegistry.get_global_platform_registry().get_normal_platform() 
+            # model = PlatformRegistry.get_global_platform_registry().get_normal_platform()
             # result = model.chat_until_success(prompt)
 
             result = "工具执行结果"
@@ -189,7 +189,7 @@ class CustomTool:
 示例：
 {example_code}
 '''
-    
+
     def _extract_code(self, response: str) -> str:
         """
         从LLM响应中提取Python代码
@@ -202,7 +202,7 @@ class CustomTool:
         if sm:
             return sm.group(1)
         return ""
-    
+
     def _validate_return_value_format(self, code: str) -> bool:
         """
         验证execute方法的返回值格式是否正确
@@ -216,6 +216,6 @@ class CustomTool:
         if "def execute(self, args: Dict) -> Dict:" not in code and \
            "def execute(self, args: Dict) -> Dict[str, Any]:" not in code:
             return False
-        
+
         # 检查返回值中是否包含所有必需字段
         return all(field in code for field in required_fields)