Formatting

agent/registry.py

@@ -1,8 +1,10 @@
 """Tool registry - defines and registers all available tools for the agent."""
-from dataclasses import dataclass
-from typing import Callable, Any, Dict
-import logging
+
 import inspect
+import logging
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -10,36 +12,37 @@ logger = logging.getLogger(__name__)
 @dataclass
 class Tool:
     """Represents a tool that can be used by the agent."""
+
     name: str
     description: str
-    func: Callable[..., Dict[str, Any]]
-    parameters: Dict[str, Any]
+    func: Callable[..., dict[str, Any]]
+    parameters: dict[str, Any]
 
 
 def _create_tool_from_function(func: Callable) -> Tool:
     """
     Create a Tool object from a function.
-    
+
     Args:
         func: Function to convert to a tool
-        
+
     Returns:
         Tool object with metadata extracted from function
     """
     sig = inspect.signature(func)
     doc = inspect.getdoc(func)
-    
+
     # Extract description from docstring (first line)
-    description = doc.strip().split('\n')[0] if doc else func.__name__
-    
+    description = doc.strip().split("\n")[0] if doc else func.__name__
+
     # Build JSON schema from function signature
     properties = {}
     required = []
-    
+
     for param_name, param in sig.parameters.items():
         if param_name == "self":
             continue
-            
+
         # Map Python types to JSON schema types
         param_type = "string"  # default
         if param.annotation != inspect.Parameter.empty:
@@ -51,22 +54,22 @@ def _create_tool_from_function(func: Callable) -> Tool:
                 param_type = "number"
             elif param.annotation == bool:
                 param_type = "boolean"
-        
+
         properties[param_name] = {
             "type": param_type,
-            "description": f"Parameter {param_name}"
+            "description": f"Parameter {param_name}",
         }
-        
+
         # Add to required if no default value
         if param.default == inspect.Parameter.empty:
             required.append(param_name)
-    
+
     parameters = {
         "type": "object",
         "properties": properties,
         "required": required,
     }
-    
+
     return Tool(
         name=func.__name__,
         description=description,
@@ -75,18 +78,18 @@ def _create_tool_from_function(func: Callable) -> Tool:
     )
 
 
-def make_tools() -> Dict[str, Tool]:
+def make_tools() -> dict[str, Tool]:
     """
     Create and register all available tools.
-    
+
     Returns:
         Dictionary mapping tool names to Tool objects
     """
     # Import tools here to avoid circular dependencies
-    from .tools import filesystem as fs_tools
     from .tools import api as api_tools
+    from .tools import filesystem as fs_tools
     from .tools import language as lang_tools
-    
+
     # List of all tool functions
     tool_functions = [
         fs_tools.set_path_for_folder,
@@ -98,12 +101,12 @@ def make_tools() -> Dict[str, Tool]:
         api_tools.get_torrent_by_index,
         lang_tools.set_language,
     ]
-    
+
     # Create Tool objects from functions
     tools = {}
     for func in tool_functions:
         tool = _create_tool_from_function(func)
         tools[tool.name] = tool
-    
+
     logger.info(f"Registered {len(tools)} tools: {list(tools.keys())}")
     return tools