rootly-mcp-server 2.0.5__py3-none-any.whl → 2.0.8__py3-none-any.whl

rootly_mcp_server/__init__.py

@@ -13,7 +13,7 @@ Features:
 from .server import RootlyMCPServer
 from .client import RootlyClient
 
-__version__ = "2.0.0"
+__version__ = "2.0.1"
 __all__ = [
     'RootlyMCPServer',
     'RootlyClient',

rootly_mcp_server/__main__.py

@@ -10,9 +10,7 @@ import logging
 import os
 import sys
 from pathlib import Path
-from typing import Optional, List
-
-from .routemap_server import create_rootly_mcp_server
+from .server import create_rootly_mcp_server
 
 
 def parse_args():
@@ -137,7 +135,7 @@ def get_server():
     return create_rootly_mcp_server(
         swagger_path=swagger_path,
         name=server_name,
-        custom_allowed_paths=allowed_paths,
+        allowed_paths=allowed_paths,
         hosted=hosted,
         base_url=base_url,
     )
@@ -161,7 +159,9 @@ def main():
         logger.warning("--host argument is deprecated, use --hosted instead")
         hosted_mode = True
     
-    check_api_token()
+    # Only check API token if not in hosted mode
+    if not hosted_mode:
+        check_api_token()
     
     try:
         # Parse allowed paths from command line argument
@@ -173,7 +173,7 @@ def main():
         server = create_rootly_mcp_server(
             swagger_path=args.swagger_path,
             name=args.name,
-            custom_allowed_paths=allowed_paths,
+            allowed_paths=allowed_paths,
             hosted=hosted_mode,
             base_url=args.base_url,
         )

rootly_mcp_server/client.py

@@ -6,7 +6,7 @@ import os
 import json
 import logging
 import requests
-from typing import Optional, Dict, Any, Union
+from typing import Optional, Dict, Any
 
 # Set up logger
 logger = logging.getLogger(__name__)
@@ -123,7 +123,7 @@ class RootlyClient:
                 try:
                     error_response["status_code"] = e.response.status_code
                     error_response["response_text"] = e.response.text
-                except:
+                except Exception:
                     pass
 
             return json.dumps(error_response, indent=2)

rootly_mcp_server/routemap_server.py

@@ -11,11 +11,13 @@ from fastmcp import FastMCP
 from fastmcp.server.openapi import RouteMap, MCPType
 import os
 import logging
+import sys
 from pathlib import Path
 from typing import Optional, List
 
 # Import the shared OpenAPI loader
-from .rootly_openapi_loader import load_rootly_openapi_spec
+sys.path.append(str(Path(__file__).parent.parent.parent))
+from rootly_openapi_loader import load_rootly_openapi_spec
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -24,7 +26,7 @@ logger = logging.getLogger(__name__)
 def create_rootly_mcp_server(
     swagger_path: Optional[str] = None,
     name: str = "Rootly API Server (RouteMap Filtered)",
-    custom_allowed_paths: Optional[List[str]] = None,
+    allowed_paths: Optional[List[str]] = None,
     hosted: bool = False,
     base_url: Optional[str] = None,
 ):
@@ -73,76 +75,108 @@ def create_rootly_mcp_server(
     fix_array_types(openapi_spec)
     logger.info("✅ Fixed OpenAPI spec compatibility issues")
     
-    logger.info("Creating FastMCP server with pre-filtered OpenAPI spec...")
+    logger.info("Creating FastMCP server with RouteMap filtering...")
     
-    # Define the specific endpoints we want to include
-    if custom_allowed_paths:
-        allowed_paths = set(custom_allowed_paths)
-    else:
-        allowed_paths = {
-            # Core incident management
-            "/v1/incidents",
-            "/v1/incidents/{incident_id}/alerts", 
-            "/v1/incidents/{incident_id}/action_items",
-            
-            # Alert management  
-            "/v1/alerts",
-            "/v1/alerts/{id}",
-            
-            # Configuration entities
-            "/v1/severities",
-            "/v1/severities/{id}",
-            "/v1/incident_types", 
-            "/v1/incident_types/{id}",
-            "/v1/functionalities",
-            "/v1/functionalities/{id}",
-            
-            # Organization
-            "/v1/teams",
-            "/v1/teams/{id}",
-            "/v1/users",
-            "/v1/users/me", 
-            "/v1/users/{id}",
-            
-            # Infrastructure
-            "/v1/services",
-            "/v1/services/{id}",
-            "/v1/environments",
-            "/v1/environments/{id}",
-            
-            # Action items
-            "/v1/action_items",
-            "/v1/action_items/{id}",
-            
-            # Workflows
-            "/v1/workflows",
-            "/v1/workflows/{id}",
-            
-            # Status pages
-            "/v1/status-pages",
-            "/v1/status-pages/{id}"
-        }
-    
-    # Filter the OpenAPI spec to only include allowed paths
-    original_paths = openapi_spec.get("paths", {})
-    filtered_paths = {path: spec for path, spec in original_paths.items() if path in allowed_paths}
-    
-    logger.info(f"📊 Filtered OpenAPI spec from {len(original_paths)} paths to {len(filtered_paths)} paths")
-    logger.info(f"🔍 Allowed paths: {sorted(allowed_paths)}")
-    logger.info(f"✅ Filtered paths: {sorted(filtered_paths.keys())}")
-    
-    openapi_spec["paths"] = filtered_paths
+    # Define custom route maps for filtering specific endpoints
+    route_maps = [
+        # Core incident management
+        RouteMap(
+            pattern=r"^/v1/incidents$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            pattern=r"^/v1/incidents/\{incident_id\}/alerts$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            pattern=r"^/v1/incidents/\{incident_id\}/action_items$",
+            mcp_type=MCPType.TOOL
+        ),
+        
+        # Alert management
+        RouteMap(
+            pattern=r"^/v1/alerts$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            pattern=r"^/v1/alerts/\{id\}$",
+            mcp_type=MCPType.TOOL
+        ),
+        
+        # Configuration entities
+        RouteMap(
+            pattern=r"^/v1/severities(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            pattern=r"^/v1/incident_types(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            pattern=r"^/v1/functionalities(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        
+        # Organization
+        RouteMap(
+            pattern=r"^/v1/teams(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            pattern=r"^/v1/users(\{id\}|/me)?$",
+            mcp_type=MCPType.TOOL
+        ),
+        
+        # Infrastructure
+        RouteMap(
+            pattern=r"^/v1/services(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            pattern=r"^/v1/environments(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        
+        # Action items
+        RouteMap(
+            pattern=r"^/v1/incident_action_items(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        
+        # Workflows
+        RouteMap(
+            pattern=r"^/v1/workflows(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            pattern=r"^/v1/workflow_runs(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        
+        # Status pages
+        RouteMap(
+            pattern=r"^/v1/status_pages(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        
+        # Exclude everything else
+        RouteMap(
+            pattern=r".*",
+            mcp_type=MCPType.EXCLUDE
+        )
+    ]
     
-    # Create MCP server without route maps for now to test basic functionality  
+    # Create MCP server with custom route maps
     mcp = FastMCP.from_openapi(
         openapi_spec=openapi_spec,
         client=client,
         name=name,
         timeout=30.0,
-        tags={"rootly", "incident-management", "evaluation"}
+        tags={"rootly", "incident-management", "evaluation"},
+        route_maps=route_maps
     )
     
-    logger.info(f"✅ Created MCP server with RouteMap filtering successfully")
+    logger.info("✅ Created MCP server with RouteMap filtering successfully")
     logger.info("🚀 Selected Rootly API endpoints are now available as MCP tools")
     
     return mcp

rootly_mcp_server/server.py

@@ -7,21 +7,18 @@ the Rootly API's OpenAPI (Swagger) specification using FastMCP's OpenAPI integra
 
 import json
 import os
-import re
 import logging
+from copy import deepcopy
 from pathlib import Path
 import requests
 import httpx
-from typing import Any, Dict, List, Optional, Tuple, Union, Callable, Annotated, Literal
-from enum import Enum
+from typing import Any, Dict, List, Optional, Annotated
 
 from fastmcp import FastMCP
 
-from fastmcp.server.dependencies import get_http_request
-from starlette.requests import Request
-from pydantic import BaseModel, Field
+from pydantic import Field
 
-from .client import RootlyClient
+from .utils import sanitize_parameters_in_spec
 
 # Set up logger
 logger = logging.getLogger(__name__)
@@ -29,29 +26,68 @@ logger = logging.getLogger(__name__)
 # Default Swagger URL
 SWAGGER_URL = "https://rootly-heroku.s3.amazonaws.com/swagger/v1/swagger.json"
 
+# Default allowed API paths
+DEFAULT_ALLOWED_PATHS = [
+    "/incidents/{incident_id}/alerts",
+    "/alerts",
+    "/alerts/{alert_id}",
+    "/severities",
+    "/severities/{severity_id}",
+    "/teams",
+    "/teams/{team_id}",
+    "/services",
+    "/services/{service_id}",
+    "/functionalities",
+    "/functionalities/{functionality_id}",
+    # Incident types
+    "/incident_types",
+    "/incident_types/{incident_type_id}",
+    # Action items (all, by id, by incident)
+    "/incident_action_items",
+    "/incident_action_items/{incident_action_item_id}",
+    "/incidents/{incident_id}/action_items",
+    # Workflows
+    "/workflows",
+    "/workflows/{workflow_id}",
+    # Workflow runs
+    "/workflow_runs",
+    "/workflow_runs/{workflow_run_id}",
+    # Environments
+    "/environments",
+    "/environments/{environment_id}",
+    # Users
+    "/users",
+    "/users/{user_id}",
+    "/users/me",
+    # Status pages
+    "/status_pages",
+    "/status_pages/{status_page_id}",
+]
+
 
 class AuthenticatedHTTPXClient:
-    """An HTTPX client wrapper that handles Rootly API authentication."""
-    
-    def __init__(self, base_url: str = "https://api.rootly.com", hosted: bool = False):
+    """An HTTPX client wrapper that handles Rootly API authentication and parameter transformation."""
+
+    def __init__(self, base_url: str = "https://api.rootly.com", hosted: bool = False, parameter_mapping: Optional[Dict[str, str]] = None):
         self.base_url = base_url
         self.hosted = hosted
         self._api_token = None
-        
+        self.parameter_mapping = parameter_mapping or {}
+
         if not self.hosted:
             self._api_token = self._get_api_token()
-        
+
         # Create the HTTPX client
-        headers = {"Content-Type": "application/json", "Accept": "application/json"}
+        headers = {"Content-Type": "application/vnd.api+json", "Accept": "application/vnd.api+json"}
         if self._api_token:
             headers["Authorization"] = f"Bearer {self._api_token}"
-            
+
         self.client = httpx.AsyncClient(
             base_url=base_url,
             headers=headers,
             timeout=30.0
         )
-    
+
     def _get_api_token(self) -> Optional[str]:
         """Get the API token from environment variables."""
         api_token = os.getenv("ROOTLY_API_TOKEN")
@@ -59,13 +95,56 @@ class AuthenticatedHTTPXClient:
             logger.warning("ROOTLY_API_TOKEN environment variable is not set")
             return None
         return api_token
-    
+
+    def _transform_params(self, params: Optional[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
+        """Transform sanitized parameter names back to original names."""
+        if not params or not self.parameter_mapping:
+            return params
+
+        transformed = {}
+        for key, value in params.items():
+            # Use the original name if we have a mapping, otherwise keep the sanitized name
+            original_key = self.parameter_mapping.get(key, key)
+            transformed[original_key] = value
+            if original_key != key:
+                logger.debug(f"Transformed parameter: '{key}' -> '{original_key}'")
+        return transformed
+
+    async def request(self, method: str, url: str, **kwargs):
+        """Override request to transform parameters."""
+        # Transform query parameters
+        if 'params' in kwargs:
+            kwargs['params'] = self._transform_params(kwargs['params'])
+
+        # Call the underlying client's request method
+        return await self.client.request(method, url, **kwargs)
+
+    async def get(self, url: str, **kwargs):
+        """Proxy to request with GET method."""
+        return await self.request('GET', url, **kwargs)
+
+    async def post(self, url: str, **kwargs):
+        """Proxy to request with POST method."""
+        return await self.request('POST', url, **kwargs)
+
+    async def put(self, url: str, **kwargs):
+        """Proxy to request with PUT method."""
+        return await self.request('PUT', url, **kwargs)
+
+    async def patch(self, url: str, **kwargs):
+        """Proxy to request with PATCH method."""
+        return await self.request('PATCH', url, **kwargs)
+
+    async def delete(self, url: str, **kwargs):
+        """Proxy to request with DELETE method."""
+        return await self.request('DELETE', url, **kwargs)
+
     async def __aenter__(self):
-        return self.client
-    
+        return self
+
     async def __aexit__(self, exc_type, exc_val, exc_tb):
-        await self.client.aclose()
-    
+        pass
+
     def __getattr__(self, name):
         # Delegate all other attributes to the underlying client
         return getattr(self.client, name)
@@ -93,44 +172,8 @@ def create_rootly_mcp_server(
     """
     # Set default allowed paths if none provided
     if allowed_paths is None:
-        allowed_paths = [
-            "/incidents",
-            "/incidents/{incident_id}/alerts",
-            "/alerts",
-            "/alerts/{alert_id}",
-            "/severities",
-            "/severities/{severity_id}",
-            "/teams",
-            "/teams/{team_id}",
-            "/services",
-            "/services/{service_id}",
-            "/functionalities",
-            "/functionalities/{functionality_id}",
-            # Incident types
-            "/incident_types",
-            "/incident_types/{incident_type_id}",
-            # Action items (all, by id, by incident)
-            "/incident_action_items",
-            "/incident_action_items/{incident_action_item_id}",
-            "/incidents/{incident_id}/action_items",
-            # Workflows
-            "/workflows",
-            "/workflows/{workflow_id}",
-            # Workflow runs
-            "/workflow_runs",
-            "/workflow_runs/{workflow_run_id}",
-            # Environments
-            "/environments",
-            "/environments/{environment_id}",
-            # Users
-            "/users",
-            "/users/{user_id}",
-            "/users/me",
-            # Status pages
-            "/status_pages",
-            "/status_pages/{status_page_id}",
-        ]
-    
+        allowed_paths = DEFAULT_ALLOWED_PATHS
+
     # Add /v1 prefix to paths if not present
     allowed_paths_v1 = [
         f"/v1{path}" if not path.startswith("/v1") else path
@@ -147,22 +190,23 @@ def create_rootly_mcp_server(
     filtered_spec = _filter_openapi_spec(swagger_spec, allowed_paths_v1)
     logger.info(f"Filtered spec to {len(filtered_spec.get('paths', {}))} allowed paths")
 
+    # Sanitize all parameter names in the filtered spec to be MCP-compliant
+    parameter_mapping = sanitize_parameters_in_spec(filtered_spec)
+    logger.info(f"Sanitized parameter names for MCP compatibility (mapped {len(parameter_mapping)} parameters)")
+
     # Determine the base URL
     if base_url is None:
         base_url = os.getenv("ROOTLY_BASE_URL", "https://api.rootly.com")
-    
+
     logger.info(f"Using Rootly API base URL: {base_url}")
 
-    # Create the authenticated HTTP client
-    try:
-        http_client = AuthenticatedHTTPXClient(
-            base_url=base_url,
-            hosted=hosted
-        )
-    except Exception as e:
-        logger.warning(f"Failed to create authenticated client: {e}")
-        # Create a mock client for testing
-        http_client = httpx.AsyncClient(base_url=base_url)
+    # Create the authenticated HTTP client with parameter mapping
+
+    http_client = AuthenticatedHTTPXClient(
+        base_url=base_url,
+        hosted=hosted,
+        parameter_mapping=parameter_mapping
+    )
 
     # Create the MCP server using OpenAPI integration
     # By default, all routes become tools which is what we want
@@ -173,10 +217,16 @@ def create_rootly_mcp_server(
         timeout=30.0,
         tags={"rootly", "incident-management"},
     )
-
+    
+    @mcp.custom_route("/healthz", methods=["GET"])
+    @mcp.custom_route("/health", methods=["GET"])
+    async def health_check(request):
+        from starlette.responses import PlainTextResponse
+        return PlainTextResponse("OK")
+    
     # Add some custom tools for enhanced functionality
     @mcp.tool()
-    def list_endpoints() -> str:
+    def list_endpoints() -> list:
         """List all available Rootly API endpoints with their descriptions."""
         endpoints = []
         for path, path_item in filtered_spec.get("paths", {}).items():
@@ -186,7 +236,7 @@ def create_rootly_mcp_server(
 
                 summary = operation.get("summary", "")
                 description = operation.get("description", "")
-                
+
                 endpoints.append({
                     "path": path,
                     "method": method.upper(),
@@ -194,106 +244,121 @@ def create_rootly_mcp_server(
                     "description": description,
                 })
 
-        return json.dumps(endpoints, indent=2)
+        return endpoints
+
+    async def make_authenticated_request(method: str, url: str, **kwargs):
+        """Make an authenticated request, extracting token from MCP headers in hosted mode."""
+        # In hosted mode, get token from MCP request headers
+        if hosted:
+            try:
+                from fastmcp.server.dependencies import get_http_headers
+                request_headers = get_http_headers()
+                auth_header = request_headers.get("authorization", "")
+                if auth_header:
+                    # Add authorization header to the request
+                    if "headers" not in kwargs:
+                        kwargs["headers"] = {}
+                    kwargs["headers"]["Authorization"] = auth_header
+            except Exception:
+                pass  # Fallback to default client behavior
+        
+        # Make the request using the underlying httpx client
+        return await http_client.client.request(method, url, **kwargs)
 
     @mcp.tool()
-    async def search_incidents_paginated(
+    async def search_incidents(
         query: Annotated[str, Field(description="Search query to filter incidents by title/summary")] = "",
-        page_size: Annotated[int, Field(description="Number of results per page (max: 100)", ge=1, le=100)] = 100,
-        page_number: Annotated[int, Field(description="Page number to retrieve", ge=1)] = 1,
-    ) -> str:
+        page_size: Annotated[int, Field(description="Number of results per page (max: 20)", ge=1, le=20)] = 10,
+        page_number: Annotated[int, Field(description="Page number to retrieve (use 0 for all pages)", ge=0)] = 1,
+        max_results: Annotated[int, Field(description="Maximum total results when fetching all pages (ignored if page_number > 0)", ge=1, le=100)] = 20,
+    ) -> dict:
         """
-        Search incidents with enhanced pagination control.
-        
-        This tool provides better pagination handling than the standard API endpoint.
+        Search incidents with flexible pagination control.
+
+        Use page_number=0 to fetch all matching results across multiple pages up to max_results.
+        Use page_number>0 to fetch a specific page.
         """
-        params = {
-            "page[size]": min(page_size, 100),
-            "page[number]": page_number,
-        }
-        if query:
-            params["filter[search]"] = query
-        
-        try:
-            async with http_client as client:
-                response = await client.get("/v1/incidents", params=params)
+        # Single page mode
+        if page_number > 0:
+            params = {
+                "page[size]": min(page_size, 20),
+                "page[number]": page_number,
+                "include": "",
+            }
+            if query:
+                params["filter[search]"] = query
+
+            try:
+                response = await make_authenticated_request("GET", "/v1/incidents", params=params)
                 response.raise_for_status()
-                result = response.json()
-        except Exception as e:
-            result = {"error": str(e)}
-        
-        return json.dumps(result, indent=2)
+                return response.json()
+            except Exception as e:
+                return {"error": str(e)}
 
-    @mcp.tool()
-    async def get_all_incidents_matching(
-        query: Annotated[str, Field(description="Search query to filter incidents by title/summary")] = "",
-        max_results: Annotated[int, Field(description="Maximum number of results to return", ge=1, le=1000)] = 500,
-    ) -> str:
-        """
-        Get all incidents matching a query by automatically fetching multiple pages.
-        
-        This tool automatically handles pagination to fetch multiple pages of results.
-        """
+        # Multi-page mode (page_number = 0)
         all_incidents = []
-        page_number = 1
-        page_size = 100
-        
+        current_page = 1
+        effective_page_size = min(page_size, 10)
+
         try:
-            async with http_client as client:
-                while len(all_incidents) < max_results:
-                    params = {
-                        "page[size]": page_size,
-                        "page[number]": page_number,
-                    }
-                    if query:
-                        params["filter[search]"] = query
-                    
-                    try:
-                        response = await client.get("/v1/incidents", params=params)
-                        response.raise_for_status()
-                        response_data = response.json()
+            while len(all_incidents) < max_results:
+                params = {
+                    "page[size]": effective_page_size,
+                    "page[number]": current_page,
+                    "include": "",
+                }
+                if query:
+                    params["filter[search]"] = query
+
+                try:
+                    response = await make_authenticated_request("GET", "/v1/incidents", params=params)
+                    response.raise_for_status()
+                    response_data = response.json()
+
+                    if "data" in response_data:
+                        incidents = response_data["data"]
+                        if not incidents:
+                            break
                         
-                        if "data" in response_data:
-                            incidents = response_data["data"]
-                            if not incidents:  # No more results
-                                break
-                            all_incidents.extend(incidents)
-                            
-                            # Check if we have more pages
-                            meta = response_data.get("meta", {})
-                            current_page = meta.get("current_page", page_number)
-                            total_pages = meta.get("total_pages", 1)
-                            
-                            if current_page >= total_pages:
-                                break  # No more pages
-                                
-                            page_number += 1
-                        else:
-                            break  # Unexpected response format
-                            
-                    except Exception as e:
-                        logger.error(f"Error fetching incidents page {page_number}: {e}")
+                        all_incidents.extend(incidents)
+
+                        # Check if we have more pages
+                        meta = response_data.get("meta", {})
+                        current_page_meta = meta.get("current_page", current_page)
+                        total_pages = meta.get("total_pages", 1)
+
+                        if current_page_meta >= total_pages:
+                            break
+
+                        current_page += 1
+                    else:
                         break
-                
-                # Limit to max_results
-                if len(all_incidents) > max_results:
-                    all_incidents = all_incidents[:max_results]
-                
-                result = {
-                    "data": all_incidents,
-                    "meta": {
-                        "total_fetched": len(all_incidents),
-                        "max_results": max_results,
-                        "query": query
-                    }
+
+                except Exception as e:
+                    # Re-raise authentication or critical errors
+                    if "401" in str(e) or "Unauthorized" in str(e) or "authentication" in str(e).lower():
+                        raise e
+                    break
+
+            # Limit to max_results
+            if len(all_incidents) > max_results:
+                all_incidents = all_incidents[:max_results]
+
+            return {
+                "data": all_incidents,
+                "meta": {
+                    "total_fetched": len(all_incidents),
+                    "max_results": max_results,
+                    "query": query,
+                    "pages_fetched": current_page - 1,
+                    "page_size": effective_page_size
                 }
+            }
         except Exception as e:
-            result = {"error": str(e)}
-        
-        return json.dumps(result, indent=2)
+            return {"error": str(e)}
 
     # Log server creation (tool count will be shown when tools are accessed)
-    logger.info(f"Created Rootly MCP Server successfully")
+    logger.info("Created Rootly MCP Server successfully")
     return mcp
 
 
@@ -395,25 +460,26 @@ def _filter_openapi_spec(spec: Dict[str, Any], allowed_paths: List[str]) -> Dict
     Returns:
         A filtered OpenAPI specification with cleaned schema references.
     """
-    filtered_spec = spec.copy()
-    
+    # Use deepcopy to ensure all nested structures are properly copied
+    filtered_spec = deepcopy(spec)
+
     # Filter paths
-    original_paths = spec.get("paths", {})
+    original_paths = filtered_spec.get("paths", {})
     filtered_paths = {
         path: path_item
         for path, path_item in original_paths.items()
         if path in allowed_paths
     }
-    
+
     filtered_spec["paths"] = filtered_paths
-    
+
     # Clean up schema references that might be broken
     # Remove problematic schema references from request bodies and parameters
     for path, path_item in filtered_paths.items():
         for method, operation in path_item.items():
             if method.lower() not in ["get", "post", "put", "delete", "patch"]:
                 continue
-                
+
             # Clean request body schemas
             if "requestBody" in operation:
                 request_body = operation["requestBody"]
@@ -429,8 +495,21 @@ def _filter_openapi_spec(spec: Dict[str, Any], allowed_paths: List[str]) -> Dict
                                     "description": "Request parameters for this endpoint",
                                     "additionalProperties": True
                                 }
-            
-            # Clean parameter schemas
+
+            # Remove response schemas to avoid validation issues
+            # FastMCP will still return the data, just without strict validation
+            if "responses" in operation:
+                for status_code, response in operation["responses"].items():
+                    if "content" in response:
+                        for content_type, content_info in response["content"].items():
+                            if "schema" in content_info:
+                                # Replace with a simple schema that accepts any response
+                                content_info["schema"] = {
+                                    "type": "object",
+                                    "additionalProperties": True
+                                }
+
+            # Clean parameter schemas (parameter names are already sanitized)
             if "parameters" in operation:
                 for param in operation["parameters"]:
                     if "schema" in param and "$ref" in param["schema"]:
@@ -441,7 +520,7 @@ def _filter_openapi_spec(spec: Dict[str, Any], allowed_paths: List[str]) -> Dict
                                 "type": "string",
                                 "description": param.get("description", "Parameter value")
                             }
-    
+
     # Also clean up any remaining broken references in components
     if "components" in filtered_spec and "schemas" in filtered_spec["components"]:
         schemas = filtered_spec["components"]["schemas"]
@@ -450,11 +529,11 @@ def _filter_openapi_spec(spec: Dict[str, Any], allowed_paths: List[str]) -> Dict
         for schema_name, schema_def in schemas.items():
             if isinstance(schema_def, dict) and _has_broken_references(schema_def):
                 schemas_to_remove.append(schema_name)
-        
+
         for schema_name in schemas_to_remove:
             logger.warning(f"Removing schema with broken references: {schema_name}")
             del schemas[schema_name]
-    
+
     return filtered_spec
 
 
@@ -465,13 +544,13 @@ def _has_broken_references(schema_def: Dict[str, Any]) -> bool:
         # List of known broken references in the Rootly API spec
         broken_refs = [
             "incident_trigger_params",
-            "new_workflow", 
+            "new_workflow",
             "update_workflow",
             "workflow"
         ]
         if any(broken_ref in ref_path for broken_ref in broken_refs):
             return True
-    
+
     # Recursively check nested schemas
     for key, value in schema_def.items():
         if isinstance(value, dict):
@@ -481,7 +560,7 @@ def _has_broken_references(schema_def: Dict[str, Any]) -> bool:
             for item in value:
                 if isinstance(item, dict) and _has_broken_references(item):
                     return True
-    
+
     return False
 
 
@@ -489,10 +568,10 @@ def _has_broken_references(schema_def: Dict[str, Any]) -> bool:
 class RootlyMCPServer(FastMCP):
     """
     Legacy Rootly MCP Server class for backward compatibility.
-    
+
     This class is deprecated. Use create_rootly_mcp_server() instead.
     """
-    
+
     def __init__(
         self,
         swagger_path: Optional[str] = None,
@@ -506,7 +585,7 @@ class RootlyMCPServer(FastMCP):
         logger.warning(
             "RootlyMCPServer class is deprecated. Use create_rootly_mcp_server() function instead."
         )
-        
+
         # Create the server using the new function
         server = create_rootly_mcp_server(
             swagger_path=swagger_path,
@@ -514,7 +593,7 @@ class RootlyMCPServer(FastMCP):
             allowed_paths=allowed_paths,
             hosted=hosted
         )
-        
+
         # Copy the server's state to this instance
         super().__init__(name, *args, **kwargs)
         # For compatibility, store reference to the new server

rootly_mcp_server/test_client.py

@@ -33,7 +33,7 @@ async def test_server():
             hosted=False  # Use local API token
         )
         
-        print(f"✅ Server created successfully")
+        print("✅ Server created successfully")
         print(f"Server type: {type(server)}")
         
         # Use the get_tools method to access tools
@@ -78,11 +78,11 @@ async def test_server():
                         if props:
                             print(f"    Parameters: {', '.join(props.keys())}")
             else:
-                print(f"\n⚠️  No tools found")
+                print("\n⚠️  No tools found")
                 
             # Test accessing a specific tool
             if tool_count > 0:
-                print(f"\n🔍 Testing tool access...")
+                print("\n🔍 Testing tool access...")
                 if isinstance(tools, dict):
                     first_tool_name = tools_names[0]
                     first_tool = tools[first_tool_name]
@@ -93,15 +93,17 @@ async def test_server():
                 print(f"  ✅ First tool: {first_tool_name}")
                 print(f"  Tool details: {first_tool}")
                 
-                # Try to get tool by name
+                # Try to get tools and find the specific tool
                 try:
-                    retrieved_tool = await server.get_tool(first_tool_name)
-                    if retrieved_tool:
+                    all_tools = await server.get_tools()
+                    if first_tool_name in all_tools:
+                        retrieved_tool = all_tools[first_tool_name]
                         print(f"  ✅ Successfully retrieved tool by name: {first_tool_name}")
+                        print(f"  Retrieved tool type: {type(retrieved_tool)}")
                     else:
-                        print(f"  ❌ Could not retrieve tool by name: {first_tool_name}")
+                        print(f"  ❌ Could not find tool by name: {first_tool_name}")
                 except Exception as e:
-                    print(f"  ❌ Error retrieving tool: {e}")
+                    print(f"  ❌ Error retrieving tools: {e}")
             
         except Exception as e:
             print(f"❌ Error accessing tools: {e}")
@@ -109,7 +111,7 @@ async def test_server():
             traceback.print_exc()
             tool_count = 0
         
-        print(f"\n🎉 Test completed successfully!")
+        print("\n🎉 Test completed successfully!")
         print(f"Total tools found: {tool_count}")
         
     except Exception as e:

rootly_mcp_server/utils.py

@@ -0,0 +1,105 @@
+"""
+Shared utilities for Rootly MCP Server.
+"""
+
+import re
+import logging
+from typing import Dict, Any
+
+logger = logging.getLogger(__name__)
+
+
+def sanitize_parameter_name(name: str) -> str:
+    """
+    Sanitize parameter names to match MCP property key pattern ^[a-zA-Z0-9_.-]{1,64}$.
+    
+    Args:
+        name: Original parameter name
+        
+    Returns:
+        Sanitized parameter name
+    """
+    # Replace square brackets with underscores: filter[kind] -> filter_kind
+    sanitized = re.sub(r'\[([^\]]+)\]', r'_\1', name)
+    
+    # Replace any remaining invalid characters with underscores
+    sanitized = re.sub(r'[^a-zA-Z0-9_.-]', '_', sanitized)
+    
+    # Remove multiple consecutive underscores
+    sanitized = re.sub(r'_{2,}', '_', sanitized)
+    
+    # Remove leading/trailing underscores
+    sanitized = sanitized.strip('_')
+    
+    # Ensure the name doesn't exceed 64 characters
+    if len(sanitized) > 64:
+        sanitized = sanitized[:64].rstrip('_')
+    
+    # Ensure the name is not empty and starts with a letter or underscore
+    if not sanitized or sanitized[0].isdigit():
+        sanitized = "param_" + sanitized if sanitized else "param"
+    
+    return sanitized
+
+
+def sanitize_parameters_in_spec(spec: Dict[str, Any]) -> Dict[str, str]:
+    """
+    Sanitize all parameter names in an OpenAPI specification.
+    
+    This function modifies the spec in-place and builds a mapping 
+    of sanitized names to original names.
+    
+    Args:
+        spec: OpenAPI specification dictionary
+        
+    Returns:
+        Dictionary mapping sanitized names to original names
+    """
+    parameter_mapping = {}
+    
+    # Sanitize parameters in paths
+    if "paths" in spec:
+        for path, path_item in spec["paths"].items():
+            if not isinstance(path_item, dict):
+                continue
+                
+            # Sanitize path-level parameters
+            if "parameters" in path_item:
+                for param in path_item["parameters"]:
+                    if "name" in param:
+                        original_name = param["name"]
+                        sanitized_name = sanitize_parameter_name(original_name)
+                        if sanitized_name != original_name:
+                            logger.debug(f"Sanitized path-level parameter: '{original_name}' -> '{sanitized_name}'")
+                            param["name"] = sanitized_name
+                            parameter_mapping[sanitized_name] = original_name
+            
+            # Sanitize operation-level parameters
+            for method, operation in path_item.items():
+                if method.lower() not in ["get", "post", "put", "delete", "patch", "options", "head", "trace"]:
+                    continue
+                if not isinstance(operation, dict):
+                    continue
+                    
+                if "parameters" in operation:
+                    for param in operation["parameters"]:
+                        if "name" in param:
+                            original_name = param["name"]
+                            sanitized_name = sanitize_parameter_name(original_name)
+                            if sanitized_name != original_name:
+                                logger.debug(f"Sanitized operation parameter: '{original_name}' -> '{sanitized_name}'")
+                                param["name"] = sanitized_name
+                                parameter_mapping[sanitized_name] = original_name
+    
+    # Sanitize parameters in components (OpenAPI 3.0)
+    if "components" in spec and "parameters" in spec["components"]:
+        for param_name, param_def in spec["components"]["parameters"].items():
+            if isinstance(param_def, dict) and "name" in param_def:
+                original_name = param_def["name"]
+                sanitized_name = sanitize_parameter_name(original_name)
+                if sanitized_name != original_name:
+                    logger.debug(f"Sanitized component parameter: '{original_name}' -> '{sanitized_name}'")
+                    param_def["name"] = sanitized_name
+                    parameter_mapping[sanitized_name] = original_name
+    
+    return parameter_mapping

{rootly_mcp_server-2.0.5.dist-info → rootly_mcp_server-2.0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rootly-mcp-server
-Version: 2.0.5
+Version: 2.0.8
 Summary: A Model Context Protocol server for Rootly APIs using OpenAPI spec
 Project-URL: Homepage, https://github.com/Rootly-AI-Labs/Rootly-MCP-server
 Project-URL: Issues, https://github.com/Rootly-AI-Labs/Rootly-MCP-server/issues
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Build Tools
 Requires-Python: >=3.12
-Requires-Dist: fastmcp==2.10.5
+Requires-Dist: fastmcp>=2.9.0
 Requires-Dist: httpx>=0.24.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: requests>=2.28.0
@@ -109,6 +109,30 @@ To customize `allowed_paths` and access additional Rootly API paths, clone the r
 }
 ```
 
+### Connect to Hosted MCP Server
+
+Alternatively, connect directly to our hosted MCP server:
+
+```json
+{
+  "mcpServers": {
+    "rootly": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "mcp-remote",
+        "https://mcp.rootly.com/sse",
+        "--header",
+        "Authorization:${ROOTLY_AUTH_HEADER}"
+      ],
+      "env": {
+        "ROOTLY_AUTH_HEADER": "Bearer <YOUR_ROOTLY_API_TOKEN>"
+      }
+    }
+  }
+}
+```
+
 ## Features
 
 - **Dynamic Tool Generation**: Automatically creates MCP resources from Rootly's OpenAPI (Swagger) specification
@@ -197,29 +221,6 @@ uv pip install <package>
 Run the test client to ensure everything is configured correctly:
 
 ```bash
-python test_mcp_client.py
+python src/rootly_mcp_server/test_client.py
 ```
 
-### Connect to Hosted MCP Server
-
-Alternatively, connect directly to our hosted MCP server:
-
-```json
-{
-  "mcpServers": {
-    "rootly": {
-      "command": "npx",
-      "args": [
-        "-y",
-        "mcp-remote",
-        "https://mcp.rootly.com/sse",
-        "--header",
-        "Authorization:${ROOTLY_AUTH_HEADER}"
-      ],
-      "env": {
-        "ROOTLY_AUTH_HEADER": "Bearer <YOUR_ROOTLY_API_TOKEN>"
-      }
-    }
-  }
-}
-```

rootly_mcp_server-2.0.8.dist-info/RECORD

@@ -0,0 +1,13 @@
+rootly_mcp_server/__init__.py,sha256=6pLh19IFyqE-Cve9zergkD-X_yApEkInREKmRa73T6s,628
+rootly_mcp_server/__main__.py,sha256=_F4p65_VjnN84RtmEdESVLLH0tO5tL9qBfb2Xdvbj2E,6480
+rootly_mcp_server/client.py,sha256=diIBINJP_z4nnQIAC1b70vQSiHaNojEfUDARC2nrKHU,4681
+rootly_mcp_server/routemap_server.py,sha256=0LfK2EzwkFQF9SpHNvGcca5ZaxkBC80gIdDojE0aUcs,6100
+rootly_mcp_server/server.py,sha256=os6uxXUOGeaPrPlq3r2GNLAM-iJYVIe2W5loASMkaBc,22953
+rootly_mcp_server/test_client.py,sha256=Ytd5ZP7vImm12CT97k3p9tlkY_JNcXHSzcGGnHCBqv0,5275
+rootly_mcp_server/utils.py,sha256=NyxdcDiFGlV2a8eBO4lKgZg0D7Gxr6xUIB0YyJGgpPA,4165
+rootly_mcp_server/data/__init__.py,sha256=fO8a0bQnRVEoRMHKvhFzj10bhoaw7VsI51czc2MsUm4,143
+rootly_mcp_server-2.0.8.dist-info/METADATA,sha256=F1BHBKiIdJmlblKhzWDX55KLNFPXn4FfomeisilOlrw,6159
+rootly_mcp_server-2.0.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+rootly_mcp_server-2.0.8.dist-info/entry_points.txt,sha256=NE33b8VgigVPGBkboyo6pvN1Vz35HZtLybxMO4Q03PI,70
+rootly_mcp_server-2.0.8.dist-info/licenses/LICENSE,sha256=c9w9ZZGl14r54tsP40oaq5adTVX_HMNHozPIH2ymzmw,11341
+rootly_mcp_server-2.0.8.dist-info/RECORD,,

rootly_mcp_server/rootly_openapi_loader.py

@@ -1,96 +0,0 @@
-#!/usr/bin/env python3
-"""
-Rootly OpenAPI Loader Utility
-
-Shared utility for loading Rootly's OpenAPI specification with smart fallback logic.
-"""
-
-import json
-import logging
-from pathlib import Path
-import httpx
-
-logger = logging.getLogger(__name__)
-
-
-def load_rootly_openapi_spec() -> dict:
-    """
-    Load Rootly OpenAPI spec with smart fallback logic.
-    
-    Loading priority:
-    1. Check current directory for rootly_openapi.json
-    2. Check parent directories for rootly_openapi.json
-    3. Check for swagger.json files  
-    4. Only as last resort, fetch from URL and cache locally
-    
-    Returns:
-        dict: The OpenAPI specification
-        
-    Raises:
-        RuntimeError: If the specification cannot be loaded
-    """
-    current_dir = Path.cwd()
-    
-    # Check for rootly_openapi.json in current directory and parents
-    for check_dir in [current_dir] + list(current_dir.parents):
-        spec_file = check_dir / "rootly_openapi.json"
-        if spec_file.is_file():
-            logger.info(f"Found OpenAPI spec at {spec_file}")
-            try:
-                with open(spec_file, "r") as f:
-                    return json.load(f)
-            except Exception as e:
-                logger.warning(f"Failed to load {spec_file}: {e}")
-                continue
-    
-    # Check for swagger.json in current directory and parents
-    for check_dir in [current_dir] + list(current_dir.parents):
-        spec_file = check_dir / "swagger.json"
-        if spec_file.is_file():
-            logger.info(f"Found Swagger spec at {spec_file}")
-            try:
-                with open(spec_file, "r") as f:
-                    return json.load(f)
-            except Exception as e:
-                logger.warning(f"Failed to load {spec_file}: {e}")
-                continue
-    
-    # Last resort: fetch from URL and cache
-    logger.warning("OpenAPI spec not found locally, fetching from URL (this should only happen once)")
-    return _fetch_and_cache_spec()
-
-
-def _fetch_and_cache_spec() -> dict:
-    """
-    Fetch OpenAPI spec from Rootly's URL and cache it locally.
-    
-    Returns:
-        dict: The OpenAPI specification
-        
-    Raises:
-        RuntimeError: If the specification cannot be fetched
-    """
-    SWAGGER_URL = "https://rootly-heroku.s3.amazonaws.com/swagger/v1/swagger.json"
-    
-    try:
-        logger.info(f"Fetching OpenAPI spec from {SWAGGER_URL}")
-        response = httpx.get(SWAGGER_URL, timeout=30.0)
-        response.raise_for_status()
-        spec_data = response.json()
-        
-        # Cache the spec for next time
-        current_dir = Path.cwd()
-        cache_file = current_dir / "rootly_openapi.json"
-        
-        try:
-            with open(cache_file, "w") as f:
-                json.dump(spec_data, f, indent=2)
-            logger.info(f"Cached OpenAPI spec to {cache_file} for future use")
-        except Exception as e:
-            logger.warning(f"Failed to cache OpenAPI spec: {e}")
-        
-        return spec_data
-        
-    except Exception as e:
-        logger.error(f"Failed to fetch OpenAPI spec: {e}")
-        raise RuntimeError(f"Could not load OpenAPI specification: {e}") 

rootly_mcp_server-2.0.5.dist-info/RECORD

@@ -1,13 +0,0 @@
-rootly_mcp_server/__init__.py,sha256=H3Dd4Od-PEff8VdbMgnblS6cCEBCb9XqYdI_-wmtQqk,628
-rootly_mcp_server/__main__.py,sha256=fQLaI6b91ujqhgK9hiFN9xdGfFQC52a8S9Vk310bJXQ,6461
-rootly_mcp_server/client.py,sha256=05TsHVJ3WtLH0k4R19Yzwwx4xcmjCKH6hS3uKcTMwRA,4678
-rootly_mcp_server/rootly_openapi_loader.py,sha256=GebIDHzEMV6XCuPox3SoBOG42lyaAb3RFlhWoCdIkeE,3159
-rootly_mcp_server/routemap_server.py,sha256=DDcuY68_B4uqg8aOuDmUp0zhrlpIxQtw0h5265ZYULk,5631
-rootly_mcp_server/server.py,sha256=2paE39caYRVuQG4yWEEOqZewbvpFREmf-J01lPQ5elw,19756
-rootly_mcp_server/test_client.py,sha256=8p1aJHrEt_Tj2NuJzTnTHw-ZeW816P99fJi5bhPidyc,5119
-rootly_mcp_server/data/__init__.py,sha256=fO8a0bQnRVEoRMHKvhFzj10bhoaw7VsI51czc2MsUm4,143
-rootly_mcp_server-2.0.5.dist-info/METADATA,sha256=H4RCI47_vv9SklpWfFlgkZOUW4j26ZuW7ZDJ5xnGazs,6141
-rootly_mcp_server-2.0.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-rootly_mcp_server-2.0.5.dist-info/entry_points.txt,sha256=NE33b8VgigVPGBkboyo6pvN1Vz35HZtLybxMO4Q03PI,70
-rootly_mcp_server-2.0.5.dist-info/licenses/LICENSE,sha256=c9w9ZZGl14r54tsP40oaq5adTVX_HMNHozPIH2ymzmw,11341
-rootly_mcp_server-2.0.5.dist-info/RECORD,,