rootly-mcp-server 2.0.4__py3-none-any.whl → 2.0.6__py3-none-any.whl

rootly_mcp_server/__main__.py

@@ -173,7 +173,7 @@ def main():
         server = create_rootly_mcp_server(
             swagger_path=args.swagger_path,
             name=args.name,
-            allowed_paths=allowed_paths,
+            custom_allowed_paths=allowed_paths,
             hosted=hosted_mode,
             base_url=args.base_url,
         )

rootly_mcp_server/rootly_openapi_loader.py

@@ -18,10 +18,11 @@ 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
+    1. Check for Claude-compatible swagger_claude_fixed.json
+    2. Check current directory for rootly_openapi.json
+    3. Check parent directories for rootly_openapi.json
+    4. Check for swagger.json files  
+    5. Only as last resort, fetch from URL and cache locally
     
     Returns:
         dict: The OpenAPI specification
@@ -31,7 +32,19 @@ def load_rootly_openapi_spec() -> dict:
     """
     current_dir = Path.cwd()
     
-    # Check for rootly_openapi.json in current directory and parents
+    # Priority 1: Check for Claude-compatible swagger file first
+    for check_dir in [current_dir] + list(current_dir.parents):
+        spec_file = check_dir / "swagger_claude_fixed.json"
+        if spec_file.is_file():
+            logger.info(f"Found Claude-compatible 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
+    
+    # Priority 2: 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():
@@ -43,7 +56,7 @@ def load_rootly_openapi_spec() -> dict:
                 logger.warning(f"Failed to load {spec_file}: {e}")
                 continue
     
-    # Check for swagger.json in current directory and parents
+    # Priority 3: 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():

rootly_mcp_server/routemap_server.py

@@ -2,8 +2,7 @@
 """
 Rootly FastMCP Server (RouteMap Version)
 
-Alternative implementation using FastMCP's RouteMap system for filtering
-instead of pre-filtering the OpenAPI spec.
+Working implementation using FastMCP's RouteMap system with proper response handling.
 """
 
 import httpx
@@ -11,7 +10,6 @@ from fastmcp import FastMCP
 from fastmcp.server.openapi import RouteMap, MCPType
 import os
 import logging
-from pathlib import Path
 from typing import Optional, List
 
 # Import the shared OpenAPI loader
@@ -36,8 +34,79 @@ def create_rootly_mcp_server(
         raise ValueError("ROOTLY_API_TOKEN environment variable is required")
     
     logger.info("Creating authenticated HTTP client...")
-    # Create authenticated HTTP client
-    client = httpx.AsyncClient(
+    # Create a custom HTTP client wrapper that ensures string responses
+    class StringifyingClient:
+        def __init__(self, base_url: str, headers: dict, timeout: float):
+            self._client = httpx.AsyncClient(
+                base_url=base_url,
+                headers=headers,
+                timeout=timeout
+            )
+        
+        async def __aenter__(self):
+            await self._client.__aenter__()
+            return self
+        
+        async def __aexit__(self, exc_type, exc_val, exc_tb):
+            await self._client.__aexit__(exc_type, exc_val, exc_tb)
+        
+        async def request(self, method: str, url: str, **kwargs):
+            """Override request to return responses that FastMCP can handle."""
+            response = await self._client.request(method, url, **kwargs)
+            
+            # Create a response that returns the raw text instead of structured JSON
+            class TextResponse:
+                def __init__(self, original_response):
+                    self.status_code = original_response.status_code
+                    self.headers = original_response.headers
+                    self.url = original_response.url
+                    self.request = original_response.request
+                    self._original = original_response
+                    
+                    # Pre-compute the text response
+                    if original_response.status_code == 200:
+                        try:
+                            import json
+                            data = original_response.json()
+                            self._text_response = json.dumps(data, indent=2)
+                        except Exception:
+                            self._text_response = original_response.text or "No content"
+                    else:
+                        self._text_response = f"Error: HTTP {original_response.status_code} - {original_response.text}"
+                
+                def json(self):
+                    """Return the original JSON data for structured_content."""
+                    try:
+                        # Return the original JSON data so FastMCP can handle structured_content
+                        return self._original.json()
+                    except Exception:
+                        # If JSON parsing fails, return a wrapper structure
+                        return {"result": self._text_response}
+                
+                @property
+                def text(self):
+                    """Return the formatted JSON as text."""
+                    return self._text_response
+                
+                @property
+                def content(self):
+                    return self._text_response.encode('utf-8')
+                
+                def raise_for_status(self):
+                    """Delegate to original response."""
+                    return self._original.raise_for_status()
+                
+                def __getattr__(self, name):
+                    """Delegate any missing attributes to original response."""
+                    return getattr(self._original, name)
+            
+            return TextResponse(response)
+        
+        def __getattr__(self, name):
+            return getattr(self._client, name)
+    
+    # Create authenticated HTTP client with string conversion
+    client = StringifyingClient(
         base_url=base_url or "https://api.rootly.com",
         headers={
             "Authorization": f"Bearer {ROOTLY_API_TOKEN}",
@@ -73,73 +142,125 @@ 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())}")
+    # Define custom route maps for filtering specific endpoints
+    route_maps = [
+        # Core incident management - list endpoints
+        RouteMap(
+            pattern=r"^/v1/incidents$",
+            mcp_type=MCPType.TOOL,
+            mcp_tags={"incidents", "core", "list"}
+        ),
+        # Incident detail endpoints  
+        RouteMap(
+            pattern=r"^/v1/incidents/\{.*\}$",
+            mcp_type=MCPType.TOOL,
+            mcp_tags={"incidents", "detail"}
+        ),
+        # Incident relationships
+        RouteMap(
+            pattern=r"^/v1/incidents/\{.*\}/.*$",
+            mcp_type=MCPType.TOOL,
+            mcp_tags={"incidents", "relationships"}
+        ),
+        
+        # Alert management
+        RouteMap(
+            pattern=r"^/v1/alerts$",
+            mcp_type=MCPType.TOOL,
+            mcp_tags={"alerts", "core", "list"}
+        ),
+        RouteMap(
+            pattern=r"^/v1/alerts/\{.*\}$",
+            mcp_type=MCPType.TOOL,
+            mcp_tags={"alerts", "detail"}
+        ),
+        
+        # Users - both list and detail
+        RouteMap(
+            pattern=r"^/v1/users$",
+            mcp_type=MCPType.TOOL,
+            mcp_tags={"users", "list"}
+        ),
+        RouteMap(
+            pattern=r"^/v1/users/me$",
+            mcp_type=MCPType.TOOL,
+            mcp_tags={"users", "current"}
+        ),
+        RouteMap(
+            pattern=r"^/v1/users/\{.*\}$",
+            mcp_type=MCPType.TOOL,
+            mcp_tags={"users", "detail"}
+        ),
+        
+        # Teams
+        RouteMap(
+            pattern=r"^/v1/teams$",
+            mcp_type=MCPType.TOOL,
+            mcp_tags={"teams", "list"}
+        ),
+        RouteMap(
+            pattern=r"^/v1/teams/\{.*\}$",
+            mcp_type=MCPType.TOOL,
+            mcp_tags={"teams", "detail"}
+        ),
+        
+        # Services
+        RouteMap(
+            pattern=r"^/v1/services$",
+            mcp_type=MCPType.TOOL,
+            mcp_tags={"services", "list"}
+        ),
+        RouteMap(
+            pattern=r"^/v1/services/\{.*\}$",
+            mcp_type=MCPType.TOOL,
+            mcp_tags={"services", "detail"}
+        ),
+        
+        # Configuration entities - list patterns
+        RouteMap(
+            pattern=r"^/v1/(severities|incident_types|environments)$",
+            mcp_type=MCPType.TOOL,
+            mcp_tags={"configuration", "list"}
+        ),
+        # Configuration entities - detail patterns  
+        RouteMap(
+            pattern=r"^/v1/(severities|incident_types|environments)/\{.*\}$",
+            mcp_type=MCPType.TOOL,
+            mcp_tags={"configuration", "detail"}
+        ),
+        
+        # Exclude everything else
+        RouteMap(
+            pattern=r".*",
+            mcp_type=MCPType.EXCLUDE
+        )
+    ]
     
-    openapi_spec["paths"] = filtered_paths
+    # Custom response handler to ensure proper MCP output format
+    def ensure_mcp_response(route, component):
+        """Ensure all responses work with FastMCP's structured content system."""
+        # Set output schema to handle structured JSON data
+        component.output_schema = {
+            "type": "object",
+            "description": "Rootly API response data",
+            "additionalProperties": True
+        }
+        
+        # Add description 
+        if hasattr(component, 'description'):
+            component.description = f"🔧 {component.description or 'Rootly API endpoint'}"
     
-    # Create MCP server without route maps for now to test basic functionality  
+    # Create MCP server with custom route maps and response handling
     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,
+        mcp_component_fn=ensure_mcp_response
     )
     
     logger.info(f"✅ Created MCP server with RouteMap filtering successfully")
@@ -148,8 +269,6 @@ def create_rootly_mcp_server(
     return mcp
 
 
-
-
 def main():
     """Main entry point."""
     try:

{rootly_mcp_server-2.0.4.dist-info → rootly_mcp_server-2.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rootly-mcp-server
-Version: 2.0.4
+Version: 2.0.6
 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

rootly_mcp_server-2.0.6.dist-info/RECORD

@@ -0,0 +1,13 @@
+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=oVD4jjWBPbuaTshIs_oxEgXQ21i0erONFy5P4yxr7c8,3782
+rootly_mcp_server/routemap_server.py,sha256=LJGMkDJBpuujVdqsnO7aLVTjHIsJ4ojB3iYwrkPIxiw,10370
+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.6.dist-info/METADATA,sha256=LNhgXwDvA7ee1rM-37ofYE41bE6-Xbx4SGCbMqcbRwE,6141
+rootly_mcp_server-2.0.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+rootly_mcp_server-2.0.6.dist-info/entry_points.txt,sha256=NE33b8VgigVPGBkboyo6pvN1Vz35HZtLybxMO4Q03PI,70
+rootly_mcp_server-2.0.6.dist-info/licenses/LICENSE,sha256=c9w9ZZGl14r54tsP40oaq5adTVX_HMNHozPIH2ymzmw,11341
+rootly_mcp_server-2.0.6.dist-info/RECORD,,

rootly_mcp_server-2.0.4.dist-info/RECORD

@@ -1,13 +0,0 @@
-rootly_mcp_server/__init__.py,sha256=H3Dd4Od-PEff8VdbMgnblS6cCEBCb9XqYdI_-wmtQqk,628
-rootly_mcp_server/__main__.py,sha256=MLfP2v4-D3znGMhv6iew6A9oDrv0eSkdv19p30E22mo,6454
-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.4.dist-info/METADATA,sha256=PrhSnP_eZ7xQLW6X-xQV5IScALGY7GaE1cBkcdlSZHw,6141
-rootly_mcp_server-2.0.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-rootly_mcp_server-2.0.4.dist-info/entry_points.txt,sha256=NE33b8VgigVPGBkboyo6pvN1Vz35HZtLybxMO4Q03PI,70
-rootly_mcp_server-2.0.4.dist-info/licenses/LICENSE,sha256=c9w9ZZGl14r54tsP40oaq5adTVX_HMNHozPIH2ymzmw,11341
-rootly_mcp_server-2.0.4.dist-info/RECORD,,