universal-mcp 0.1.17__py3-none-any.whl → 0.1.18__py3-none-any.whl

universal_mcp/tools/manager.py

@@ -1,3 +1,4 @@
+import re
 from collections.abc import Callable
 from typing import Any
 
@@ -19,14 +20,21 @@ DEFAULT_IMPORTANT_TAG = "important"
 TOOL_NAME_SEPARATOR = "_"
 
 
-def _filter_by_name(tools: list[Tool], tool_names: list[str]) -> list[Tool]:
+def _filter_by_name(tools: list[Tool], tool_names: list[str] | None) -> list[Tool]:
     if not tool_names:
         return tools
-    return [tool for tool in tools if tool.name in tool_names]
+    logger.debug(f"Filtering tools by name: {tool_names}")
+    filtered_tools = []
+    for tool in tools:
+        for name in tool_names:
+            if re.search(name, tool.name):
+                filtered_tools.append(tool)
+    return filtered_tools
 
 
 def _filter_by_tags(tools: list[Tool], tags: list[str] | None) -> list[Tool]:
-    tags = tags or [DEFAULT_IMPORTANT_TAG]
+    if not tags:
+        return tools
     return [tool for tool in tools if any(tag in tool.tags for tag in tags)]
 
 
@@ -77,7 +85,6 @@ class ToolManager:
         tools = list(self._tools.values())
         if tags:
             tools = _filter_by_tags(tools, tags)
-
         if format == ToolFormat.MCP:
             tools = [convert_tool_to_mcp_tool(tool) for tool in tools]
         elif format == ToolFormat.LANGCHAIN:
@@ -86,7 +93,6 @@ class ToolManager:
             tools = [convert_tool_to_openai_tool(tool) for tool in tools]
         else:
             raise ValueError(f"Invalid format: {format}")
-
         return tools
 
     def add_tool(self, fn: Callable[..., Any] | Tool, name: str | None = None) -> Tool:
@@ -148,14 +154,14 @@ class ToolManager:
     def register_tools_from_app(
         self,
         app: BaseApplication,
-        tool_names: list[str] = None,
-        tags: list[str] = None,
+        tool_names: list[str] | None = None,
+        tags: list[str] | None = None,
     ) -> None:
         """Register tools from an application.
 
         Args:
             app: The application to register tools from.
-            tools: Optional list of specific tool names to register.
+            tool_names: Optional list of specific tool names to register.
             tags: Optional list of tags to filter tools by.
         """
         try:
@@ -186,8 +192,16 @@ class ToolManager:
                 tool_name = getattr(function, "__name__", "unknown")
                 logger.error(f"Failed to create Tool from '{tool_name}' in {app.name}: {e}")
 
-        tools = _filter_by_name(tools, tool_names)
-        tools = _filter_by_tags(tools, tags)
+        if tags:
+            tools = _filter_by_tags(tools, tags)
+
+        if tool_names:
+            tools = _filter_by_name(tools, tool_names)
+
+        # If no tool names or tags are provided, use the default important tag
+        if not tool_names and not tags:
+            tools = _filter_by_tags(tools, [DEFAULT_IMPORTANT_TAG])
+
         self.register_tools(tools)
         return
 

universal_mcp/utils/agentr.py

@@ -5,10 +5,9 @@ from loguru import logger
 
 from universal_mcp.config import AppConfig
 from universal_mcp.exceptions import NotAuthorizedError
-from universal_mcp.utils.singleton import Singleton
 
 
-class AgentrClient(metaclass=Singleton):
+class AgentrClient:
     """Helper class for AgentR API operations.
 
     This class provides utility methods for interacting with the AgentR API,
@@ -27,6 +26,9 @@ class AgentrClient(metaclass=Singleton):
             )
             raise ValueError("AgentR API key required - get one at https://agentr.dev")
         self.base_url = (base_url or os.getenv("AGENTR_BASE_URL", "https://api.agentr.dev")).rstrip("/")
+        self.client = httpx.Client(
+            base_url=self.base_url, headers={"X-API-KEY": self.api_key}, timeout=30, follow_redirects=True
+        )
 
     def get_credentials(self, integration_name: str) -> dict:
         """Get credentials for an integration from the AgentR API.
@@ -41,9 +43,8 @@ class AgentrClient(metaclass=Singleton):
             NotAuthorizedError: If credentials are not found (404 response)
             HTTPError: For other API errors
         """
-        response = httpx.get(
-            f"{self.base_url}/api/{integration_name}/credentials/",
-            headers={"accept": "application/json", "X-API-KEY": self.api_key},
+        response = self.client.get(
+            f"/api/{integration_name}/credentials/",
         )
         if response.status_code == 404:
             logger.warning(f"No credentials found for {integration_name}. Requesting authorization...")
@@ -64,15 +65,14 @@ class AgentrClient(metaclass=Singleton):
         Raises:
             HTTPError: If API request fails
         """
-        response = httpx.get(
-            f"{self.base_url}/api/{integration_name}/authorize/",
-            headers={"X-API-KEY": self.api_key},
+        response = self.client.get(
+            f"/api/{integration_name}/authorize/",
         )
         response.raise_for_status()
         url = response.json()
         return f"Please ask the user to visit the following url to authorize the application: {url}. Render the url in proper markdown format with a clickable link."
 
-    def fetch_apps(self) -> list[dict]:
+    def fetch_apps(self) -> list[AppConfig]:
         """Fetch available apps from AgentR API.
 
         Returns:
@@ -81,11 +81,7 @@ class AgentrClient(metaclass=Singleton):
         Raises:
             httpx.HTTPError: If API request fails
         """
-        response = httpx.get(
-            f"{self.base_url}/api/apps/",
-            headers={"X-API-KEY": self.api_key},
-            timeout=10,
-        )
+        response = self.client.get("/api/apps/")
         response.raise_for_status()
         data = response.json()
         return [AppConfig.model_validate(app) for app in data]

universal_mcp/utils/openapi/api_splitter.py

@@ -0,0 +1,400 @@
+import ast
+import re
+from collections import defaultdict
+from keyword import iskeyword
+from pathlib import Path
+
+API_SEGMENT_BASE_CODE = '''
+from typing import Any
+
+class APISegmentBase:
+    def __init__(self, main_app_client: Any):
+        self.main_app_client = main_app_client
+
+    def _get(self, url: str, params: dict = None, **kwargs):
+        return self.main_app_client._get(url, params=params, **kwargs)
+
+    def _post(self, url: str, data: Any = None, files: Any = None, params: dict = None, content_type: str = None, **kwargs):
+        return self.main_app_client._post(url, data=data, files=files, params=params, content_type=content_type, **kwargs)
+
+    def _put(self, url: str, data: Any = None, files: Any = None, params: dict = None, content_type: str = None, **kwargs):
+        return self.main_app_client._put(url, data=data, files=files, params=params, content_type=content_type, **kwargs)
+
+    def _patch(self, url: str, data: Any = None, params: dict = None, **kwargs):
+        return self.main_app_client._patch(url, data=data, params=params, **kwargs)
+
+    def _delete(self, url: str, params: dict = None, **kwargs):
+        return self.main_app_client._delete(url, params=params, **kwargs)
+'''
+
+def get_sanitized_path_segment(openapi_path: str) -> str:
+    # Remove leading/trailing slashes and split
+    path_parts = [part for part in openapi_path.strip("/").split("/") if part]
+
+    if not path_parts:
+        return "default_api"
+
+    # Handle common prefixes like /api/ or /v1/api/ etc.
+    known_prefixes = ["api"] 
+    while len(path_parts) > 0 and path_parts[0].lower() in known_prefixes:
+        path_parts.pop(0)
+        if not path_parts: 
+            return "default_api" 
+
+    segment_to_use = "default_api" 
+
+    # check if the current first segment is version-like (e.g., "2", "v1", "v0")
+    if path_parts:
+        first_segment = path_parts[0]
+        # Check if it's purely numeric (like "2") or matches "v" followed by digits
+        is_version_segment = first_segment.isdigit() or re.match(r"v\\d+", first_segment.lower())
+
+        if is_version_segment and len(path_parts) > 1:
+            # If it's a version segment and there's something after it, use the next segment
+            segment_to_use = path_parts[1]
+        elif not is_version_segment:
+            # If it's not a version segment, use it directly
+            segment_to_use = path_parts[0]
+        else:
+      
+            segment_to_use = f"api_{first_segment}"
+    else: # Path was empty after stripping prefixes (e.g. "/api/")
+        return "default_api" # segment_to_use remains "default_api"
+
+    # Sanitize the chosen segment to be a valid Python identifier component
+    # Replace non-alphanumeric (excluding underscore) with underscore
+    sanitized_segment = re.sub(r"[^a-zA-Z0-9_]", "_", segment_to_use)
+    
+    # Remove leading/trailing underscores that might result from sanitization
+    sanitized_segment = sanitized_segment.strip("_")
+
+  
+    if not sanitized_segment:
+        return "default_api"
+    if sanitized_segment.isdigit(): # e.g. if path was /2/123 -> segment is 123
+        return f"api_{sanitized_segment}"
+        
+    return sanitized_segment
+
+def get_group_name_from_path(openapi_path: str) -> str:
+    processed_path = openapi_path
+    
+    # Pattern for /vN, /vN.N, /vN.N.N
+    version_pattern_v_prefix = re.compile(r"^/v[0-9]+(?:\\.[0-9]+){0,2}")
+    # Pattern for just /N (like /2)
+    version_pattern_numeric_prefix = re.compile(r"^/[0-9]+")
+    
+    api_prefix_pattern = re.compile(r"^/api")
+
+    # Strip /api prefix first if present
+    if api_prefix_pattern.match(processed_path):
+        processed_path = api_prefix_pattern.sub("", processed_path)
+        processed_path = processed_path.lstrip("/") # Ensure we strip leading slash if api was the only thing
+        if processed_path and not processed_path.startswith("/"):
+             processed_path = "/" + processed_path
+        elif not processed_path: # Path was only /api/
+            processed_path = "/" # Reset to / so subsequent logic doesn't fail
+
+    # Try to strip /vN style version
+    path_after_v_version_strip = version_pattern_v_prefix.sub("", processed_path)
+    
+    if path_after_v_version_strip != processed_path: # /vN was stripped
+        processed_path = path_after_v_version_strip
+    else: # /vN was not found, try to strip /N (like /2/)
+        path_after_numeric_version_strip = version_pattern_numeric_prefix.sub("", processed_path)
+        if path_after_numeric_version_strip != processed_path: # /N was stripped
+            processed_path = path_after_numeric_version_strip
+            
+    processed_path = processed_path.lstrip("/")
+
+    path_segments = [segment for segment in processed_path.split("/") if segment] # Ensure no empty segments
+
+    group_name_raw = "default"
+    if path_segments and path_segments[0]:
+        # Remove {param} style parts from the segment if any
+        group_name_raw = re.sub(r"[{}]", "", path_segments[0]) # Corrected regex string
+    
+    # Sanitize to make it a valid Python identifier component (lowercase, underscores)
+    group_name = re.sub(r"[^a-zA-Z0-9_]", "_", group_name_raw).lower() # Corrected regex string
+    group_name = group_name.strip("_")
+
+    if not group_name or group_name.isdigit(): # If empty after sanitization or purely numeric
+        group_name = f"api_{group_name}" if group_name else "default_api"
+    
+    if iskeyword(group_name): # Avoid Python keywords
+        group_name += "_"
+        
+    return group_name if group_name else "default_api"
+
+
+class MethodTransformer(ast.NodeTransformer):
+    def __init__(self, original_path: str):
+        self.original_path = original_path
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.FunctionDef:
+        # All logic related to adding headers parameter has been removed.
+        self.generic_visit(node)
+        return node
+
+    def visit_Attribute(self, node: ast.Attribute) -> ast.AST:
+        if isinstance(node.value, ast.Name) and node.value.id == 'self' and node.attr == 'base_url':
+            return ast.Attribute(
+                value=ast.Attribute(value=ast.Name(id='self', ctx=ast.Load()), attr='main_app_client', ctx=ast.Load()),
+                attr='base_url',
+                ctx=ast.Load()
+            )
+        return self.generic_visit(node)
+
+    def visit_Call(self, node: ast.Call) -> ast.Call:
+        return self.generic_visit(node)
+
+
+def split_generated_app_file(input_app_file: Path, output_dir: Path):
+    content = input_app_file.read_text()
+    tree = ast.parse(content)
+
+    main_app_class_node = None
+    for node_item in tree.body: # Renamed to avoid conflict with ast.Node
+        if isinstance(node_item, ast.ClassDef) and \
+           any(isinstance(base, ast.Name) and base.id == 'APIApplication' for base in node_item.bases if isinstance(base, ast.Name)):
+            main_app_class_node = node_item
+            break
+    
+    if not main_app_class_node:
+        raise ValueError("Could not find main APIApplication class in the input file.")
+
+    grouped_methods = defaultdict(list)
+    other_main_app_body_nodes = []
+    processed_method_names_in_main = set()
+    
+    openapi_path_regex = re.compile(r"# openapi_path: (.+)")
+
+    for item in main_app_class_node.body:
+        if isinstance(item, ast.FunctionDef):
+            path_from_comment = None
+            if item.body and isinstance(item.body[0], ast.Expr) and \
+               isinstance(item.body[0].value, ast.Constant) and isinstance(item.body[0].value.value, str):
+                docstring_lines = item.body[0].value.value.strip().splitlines()
+                if docstring_lines:
+                    match = openapi_path_regex.match(docstring_lines[0].strip())
+                    if match:
+                        path_from_comment = match.group(1).strip()
+            
+            if path_from_comment:
+                group = get_group_name_from_path(path_from_comment)
+                method_node_copy = ast.parse(ast.unparse(item)).body[0]
+                if not isinstance(method_node_copy, ast.FunctionDef):
+                     method_node_copy = item 
+
+                transformer = MethodTransformer(original_path=path_from_comment)
+                transformed_method_node = transformer.visit(method_node_copy)
+                if hasattr(ast, 'fix_missing_locations'):
+                    transformed_method_node = ast.fix_missing_locations(transformed_method_node)
+
+                # Remove the # openapi_path: comment from the docstring
+                if (transformed_method_node.body and
+                        isinstance(transformed_method_node.body[0], ast.Expr) and
+                        isinstance(transformed_method_node.body[0].value, ast.Constant) and
+                        isinstance(transformed_method_node.body[0].value.value, str)):
+                    
+                    docstring_expr_node = transformed_method_node.body[0]
+                    original_docstring_text = docstring_expr_node.value.value
+                    
+                    all_lines_raw = original_docstring_text.splitlines(True)
+                    line_to_remove_idx = -1
+                    
+                    for i, current_line_raw in enumerate(all_lines_raw):
+                        current_line_stripped = current_line_raw.strip()
+                        if current_line_stripped: # Found the first significant line
+                            if openapi_path_regex.match(current_line_stripped):
+                                line_to_remove_idx = i
+                            break # Only inspect the first significant line
+
+                    if line_to_remove_idx != -1:
+                        del all_lines_raw[line_to_remove_idx]
+                        modified_docstring_text = "".join(all_lines_raw)
+                        
+                        if not modified_docstring_text.strip():
+                            transformed_method_node.body.pop(0) # Docstring is now empty
+                        else:
+                            docstring_expr_node.value.value = modified_docstring_text
+                
+                grouped_methods[group].append(transformed_method_node)
+                processed_method_names_in_main.add(item.name)
+            else:
+                other_main_app_body_nodes.append(item)
+        else:
+            other_main_app_body_nodes.append(item)
+    
+    # Define segments subfolder
+    segments_foldername = "api_segments"
+    segments_dir = output_dir / segments_foldername
+    segments_dir.mkdir(parents=True, exist_ok=True)
+
+    (segments_dir / "api_segment_base.py").write_text(API_SEGMENT_BASE_CODE)
+
+    segment_class_details_for_main_app = []
+
+    for group, method_nodes in grouped_methods.items():
+        SegmentClassName = "".join(word.capitalize() for word in group.split("_")) + "Api"
+        segment_filename = f"{group.lower()}_api.py"
+        
+        method_names_for_list_tools = [method_node.name for method_node in method_nodes]
+
+        list_tools_body = [ast.Return(value=ast.List(
+            elts=[ast.Attribute(value=ast.Name(id='self', ctx=ast.Load()), attr=name, ctx=ast.Load()) for name in method_names_for_list_tools],
+            ctx=ast.Load()
+        ))]
+        list_tools_def = ast.FunctionDef(
+            name='list_tools',
+            args=ast.arguments(posonlyargs=[], args=[ast.arg(arg='self')], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]),
+            body=list_tools_body, decorator_list=[], returns=None
+        )
+        
+        init_method_segment = ast.FunctionDef(
+            name='__init__',
+            args=ast.arguments(
+                posonlyargs=[],
+                args=[ast.arg(arg='self'), ast.arg(arg='main_app_client', annotation=ast.Name(id='Any', ctx=ast.Load()))],
+                vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]
+            ),
+            body=[
+                ast.Expr(value=ast.Call(
+                    func=ast.Attribute(value=ast.Call(func=ast.Name(id='super', ctx=ast.Load()), args=[], keywords=[]), attr='__init__', ctx=ast.Load()),
+                    args=[ast.Name(id='main_app_client', ctx=ast.Load())],
+                    keywords=[]
+                ))
+            ],
+            decorator_list=[], returns=None
+        )
+
+        segment_class_body = [init_method_segment] + method_nodes + [list_tools_def]
+        segment_class_node = ast.ClassDef(
+            name=SegmentClassName,
+            bases=[ast.Name(id='APISegmentBase', ctx=ast.Load())],
+            keywords=[], body=segment_class_body, decorator_list=[]
+        )
+        
+        segment_module_body = [
+            ast.ImportFrom(module='typing', names=[ast.alias(name='Any'), ast.alias(name='Dict'), ast.alias(name='Optional')], level=0),
+            ast.ImportFrom(module='.api_segment_base', names=[ast.alias(name='APISegmentBase')], level=0), # This relative import is fine as they are in the same dir
+            segment_class_node
+        ]
+        segment_module_ast = ast.Module(body=segment_module_body, type_ignores=[])
+        if hasattr(ast, 'fix_missing_locations'):
+            segment_module_ast = ast.fix_missing_locations(segment_module_ast)
+            
+        (segments_dir / segment_filename).write_text(ast.unparse(segment_module_ast))
+        segment_class_details_for_main_app.append({
+            "attr_name": group.lower(),
+            "class_name": SegmentClassName,
+            "module_name": segment_filename.replace(".py", "") # Used for import in main app
+        })
+
+    new_main_app_body = []
+    main_app_init_node = None
+
+    for node in other_main_app_body_nodes:
+        if isinstance(node, ast.FunctionDef):
+            if node.name == '__init__':
+                main_app_init_node = node
+                continue
+            elif node.name == 'list_tools':
+                continue
+        new_main_app_body.append(node)
+
+    if not main_app_init_node:
+        main_app_init_node = ast.FunctionDef(
+            name='__init__',
+            args=ast.arguments(
+                posonlyargs=[], 
+                args=[ast.arg(arg='self'), ast.arg(arg='integration', annotation=ast.Name(id='Integration', ctx=ast.Load()), default=ast.Constant(value=None))],
+                vararg=ast.arg(arg='args'), 
+                kwonlyargs=[], kw_defaults=[], 
+                kwarg=ast.arg(arg='kwargs'), 
+                defaults=[ast.Constant(value=None)]
+            ),
+            body=[
+                ast.Expr(value=ast.Call(
+                    func=ast.Attribute(value=ast.Call(func=ast.Name(id='super', ctx=ast.Load()), args=[], keywords=[]), attr='__init__', ctx=ast.Load()),
+                    args=[ast.keyword(arg='name', value=ast.Constant(value=main_app_class_node.name.lower())), ast.Name(id='integration', ctx=ast.Load())],
+                    keywords=[ast.keyword(arg=None, value=ast.Name(id='kwargs',ctx=ast.Load()))]
+                ))
+            ],
+            decorator_list=[], returns=ast.Constant(value=None)
+        )
+
+    init_segment_instantiations = []
+    for seg_detail in segment_class_details_for_main_app:
+        init_segment_instantiations.append(
+            ast.Assign(
+                targets=[ast.Attribute(value=ast.Name(id='self', ctx=ast.Load()), attr=seg_detail["attr_name"], ctx=ast.Store())],
+                value=ast.Call(func=ast.Name(id=seg_detail["class_name"], ctx=ast.Load()), args=[ast.Name(id='self', ctx=ast.Load())], keywords=[])
+            )
+        )
+    if not isinstance(main_app_init_node.body, list):
+        main_app_init_node.body = [main_app_init_node.body] # type: ignore
+        
+    main_app_init_node.body.extend(init_segment_instantiations)
+    new_main_app_body.insert(0, main_app_init_node)
+
+    list_tools_calls_for_main = [
+        ast.Call(
+            func=ast.Attribute(value=ast.Attribute(value=ast.Name(id='self', ctx=ast.Load()), attr=seg_detail["attr_name"], ctx=ast.Load()), attr='list_tools', ctx=ast.Load()),
+            args=[], keywords=[]
+        ) for seg_detail in segment_class_details_for_main_app
+    ]
+    
+    new_list_tools_body = [ast.Assign(targets=[ast.Name(id='all_tools', ctx=ast.Store())], value=ast.List(elts=[], ctx=ast.Load()))]
+    if list_tools_calls_for_main:
+        for call_node in list_tools_calls_for_main:
+            new_list_tools_body.append(ast.Expr(value=ast.Call(
+                func=ast.Attribute(value=ast.Name(id='all_tools', ctx=ast.Load()), attr='extend', ctx=ast.Load()),
+                args=[call_node], keywords=[]))
+            )
+    new_list_tools_body.append(ast.Return(value=ast.Name(id='all_tools', ctx=ast.Load())))
+
+    new_main_app_list_tools_def = ast.FunctionDef(
+        name='list_tools',
+        args=ast.arguments(posonlyargs=[], args=[ast.arg(arg='self')], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]),
+        body=new_list_tools_body, decorator_list=[], returns=None
+    )
+    new_main_app_body.append(new_main_app_list_tools_def)
+
+    main_app_class_node.body = new_main_app_body
+
+    final_main_module_imports = []
+    other_top_level_nodes_for_main = []
+    original_imports_from_main_file = set()
+
+    for top_node in tree.body:
+        if top_node == main_app_class_node:
+            continue
+        if isinstance(top_node, ast.Import | ast.ImportFrom):
+            final_main_module_imports.append(top_node)
+            if isinstance(top_node, ast.ImportFrom):
+                if top_node.module: # module can be None for from . import x
+                     original_imports_from_main_file.add(top_node.module)
+            elif isinstance(top_node, ast.Import):
+                 for alias in top_node.names:
+                      original_imports_from_main_file.add(alias.name)
+        else:
+            other_top_level_nodes_for_main.append(top_node)
+            
+    if "typing" not in original_imports_from_main_file:
+         final_main_module_imports.insert(0, ast.ImportFrom(module='typing', names=[ast.alias(name='Any'), ast.alias(name='Dict'), ast.alias(name='Optional')], level=0))
+
+    for seg_detail in segment_class_details_for_main_app:
+        # Adjust import path for segments subfolder
+        final_main_module_imports.append(
+            ast.ImportFrom(module=f'.{segments_foldername}.{seg_detail["module_name"]}', names=[ast.alias(name=seg_detail["class_name"])], level=0)
+        )
+    
+    final_main_app_module_ast = ast.Module(body=final_main_module_imports + other_top_level_nodes_for_main + [main_app_class_node], type_ignores=[])
+    if hasattr(ast, 'fix_missing_locations'):
+        final_main_app_module_ast = ast.fix_missing_locations(final_main_app_module_ast)
+
+    (output_dir / "app.py").write_text(ast.unparse(final_main_app_module_ast))
+
+    (output_dir / "__init__.py").touch(exist_ok=True)
+    (segments_dir / "__init__.py").touch(exist_ok=True)