rootly-mcp-server 2.0.15__py3-none-any.whl → 2.1.0__py3-none-any.whl

rootly_mcp_server/server.py

@@ -6,115 +6,385 @@ the Rootly API's OpenAPI (Swagger) specification using FastMCP's OpenAPI integra
 """
 
 import json
-import os
 import logging
+import os
 from copy import deepcopy
 from pathlib import Path
-import requests
-import httpx
-from typing import Any, Dict, List, Optional, Annotated
+from typing import Annotated, Any
 
+import httpx
+import requests
 from fastmcp import FastMCP
-
 from pydantic import Field
 
+from .smart_utils import SolutionExtractor, TextSimilarityAnalyzer
 from .utils import sanitize_parameters_in_spec
-from .smart_utils import TextSimilarityAnalyzer, SolutionExtractor
 
 # Set up logger
 logger = logging.getLogger(__name__)
 
 
+def strip_heavy_nested_data(data: dict[str, Any]) -> dict[str, Any]:
+    """
+    Strip heavy nested relationship data from incident responses to reduce payload size.
+    Removes embedded user objects, roles, permissions, schedules, etc.
+    """
+    if not isinstance(data, dict):
+        return data
+
+    if "data" in data and isinstance(data["data"], list):
+        # Process list of incidents
+        for incident in data["data"]:
+            if "attributes" in incident:
+                attrs = incident["attributes"]
+                # Strip heavy embedded user objects
+                for user_field in [
+                    "user",
+                    "started_by",
+                    "mitigated_by",
+                    "resolved_by",
+                    "closed_by",
+                    "cancelled_by",
+                    "in_triage_by",
+                ]:
+                    if user_field in attrs and isinstance(attrs[user_field], dict):
+                        user_data = attrs[user_field].get("data", {})
+                        if "attributes" in user_data:
+                            # Keep only basic user info
+                            attrs[user_field] = {
+                                "data": {
+                                    "id": user_data.get("id"),
+                                    "type": user_data.get("type"),
+                                    "attributes": {
+                                        "name": user_data.get("attributes", {}).get("name"),
+                                        "email": user_data.get("attributes", {}).get("email"),
+                                    },
+                                }
+                            }
+
+                # Strip heavy severity object, keep only essential info
+                if "severity" in attrs and isinstance(attrs["severity"], dict):
+                    sev_data = attrs["severity"].get("data", {})
+                    if sev_data and "attributes" in sev_data:
+                        # Simplify to just name and slug
+                        attrs["severity"] = {
+                            "name": sev_data.get("attributes", {}).get("name"),
+                            "slug": sev_data.get("attributes", {}).get("slug"),
+                        }
+                    elif not sev_data:
+                        # Severity is null/empty
+                        attrs["severity"] = None
+
+                # Remove heavy integration fields (50+ fields with IDs/URLs)
+                integration_fields = [
+                    "zoom_meeting_start_url",
+                    "zoom_meeting_global_dial_in_numbers",
+                    "shortcut_story_id",
+                    "shortcut_story_url",
+                    "shortcut_task_id",
+                    "shortcut_task_url",
+                    "asana_task_id",
+                    "asana_task_url",
+                    "github_issue_id",
+                    "github_issue_url",
+                    "gitlab_issue_id",
+                    "gitlab_issue_url",
+                    "google_meeting_id",
+                    "trello_card_id",
+                    "trello_card_url",
+                    "linear_issue_id",
+                    "linear_issue_url",
+                    "zendesk_ticket_id",
+                    "zendesk_ticket_url",
+                    "motion_task_id",
+                    "motion_task_url",
+                    "clickup_task_id",
+                    "clickup_task_url",
+                    "slack_channel_deep_link",
+                    "service_now_incident_id",
+                    "service_now_incident_key",
+                    "service_now_incident_url",
+                    "opsgenie_incident_id",
+                    "opsgenie_incident_url",
+                    "opsgenie_alert_id",
+                    "opsgenie_alert_url",
+                    "victor_ops_incident_id",
+                    "victor_ops_incident_url",
+                    "pagerduty_incident_id",
+                    "pagerduty_incident_number",
+                    "pagerduty_incident_url",
+                    "mattermost_channel_id",
+                    "mattermost_channel_name",
+                    "mattermost_channel_url",
+                    "confluence_page_id",
+                    "quip_page_id",
+                    "quip_page_url",
+                    "airtable_base_key",
+                    "airtable_table_name",
+                    "airtable_record_id",
+                    "airtable_record_url",
+                    "google_drive_id",
+                    "google_drive_parent_id",
+                    "google_drive_url",
+                    "sharepoint_page_id",
+                    "sharepoint_page_url",
+                    "datadog_notebook_id",
+                    "datadog_notebook_url",
+                    "freshservice_ticket_id",
+                    "freshservice_ticket_url",
+                    "freshservice_task_id",
+                    "freshservice_task_url",
+                    "zoom_meeting_password",
+                    "zoom_meeting_pstn_password",
+                    "zoom_meeting_h323_password",
+                    "labels",
+                    "slack_last_message_ts",
+                ]
+                for field in integration_fields:
+                    attrs.pop(field, None)
+
+            # Remove heavy relationships data
+            if "relationships" in incident:
+                rels = incident["relationships"]
+                # Keep only counts for heavy relationships, remove the actual data
+                for rel_key in [
+                    "events",
+                    "action_items",
+                    "subscribers",
+                    "roles",
+                    "slack_messages",
+                    "alerts",
+                ]:
+                    if (
+                        rel_key in rels
+                        and isinstance(rels[rel_key], dict)
+                        and "data" in rels[rel_key]
+                    ):
+                        # Replace with just count
+                        rels[rel_key] = {"count": len(rels[rel_key]["data"])}
+
+    # Process "included" section (common in shifts/alerts with user data)
+    if "included" in data and isinstance(data["included"], list):
+        for item in data["included"]:
+            if item.get("type") == "users":
+                # Keep only essential user fields
+                if "attributes" in item:
+                    attrs = item["attributes"]
+                    keep_fields = {"name", "email", "phone", "time_zone", "full_name"}
+                    item["attributes"] = {k: v for k, v in attrs.items() if k in keep_fields}
+                # Strip heavy relationships
+                if "relationships" in item:
+                    for rel_key in [
+                        "schedules",
+                        "notification_rules",
+                        "teams",
+                        "devices",
+                        "email_addresses",
+                        "phone_numbers",
+                    ]:
+                        if rel_key in item["relationships"]:
+                            rel_data = item["relationships"][rel_key]
+                            if isinstance(rel_data, dict) and "data" in rel_data:
+                                data_list = rel_data.get("data", [])
+                                if isinstance(data_list, list):
+                                    item["relationships"][rel_key] = {"count": len(data_list)}
+
+    # Process alerts in data list
+    if "data" in data and isinstance(data["data"], list):
+        for item in data["data"]:
+            if item.get("type") == "alerts":
+                # Strip heavy attributes from alerts
+                if "attributes" in item:
+                    attrs = item["attributes"]
+                    # Remove heavy fields - raw data, embedded objects, integration fields
+                    heavy_fields = [
+                        "data",  # Raw alert payload from source - very large
+                        "labels",
+                        "external_url",
+                        "pagerduty_incident_id",
+                        "pagerduty_incident_url",
+                        "opsgenie_alert_id",
+                        "opsgenie_alert_url",
+                        "deduplication_key",
+                    ]
+                    for field in heavy_fields:
+                        attrs.pop(field, None)
+
+                    # Simplify embedded objects to just IDs/counts
+                    # groups - keep only group_ids
+                    if "groups" in attrs:
+                        attrs.pop("groups", None)
+                    # environments - keep only environment_ids
+                    if "environments" in attrs:
+                        attrs.pop("environments", None)
+                    # services - keep only service_ids
+                    if "services" in attrs:
+                        attrs.pop("services", None)
+                    # incidents - embedded incident objects
+                    if "incidents" in attrs:
+                        attrs.pop("incidents", None)
+                    # responders - embedded responder objects
+                    if "responders" in attrs:
+                        attrs.pop("responders", None)
+                    # notified_users - embedded user objects
+                    if "notified_users" in attrs:
+                        attrs.pop("notified_users", None)
+                    # alerting_targets - embedded target objects
+                    if "alerting_targets" in attrs:
+                        attrs.pop("alerting_targets", None)
+                    # alert_urgency - keep only alert_urgency_id
+                    if "alert_urgency" in attrs:
+                        attrs.pop("alert_urgency", None)
+                    # alert_field_values - embedded custom field values
+                    if "alert_field_values" in attrs:
+                        attrs.pop("alert_field_values", None)
+
+                # Strip heavy relationships
+                if "relationships" in item:
+                    rels = item["relationships"]
+                    for rel_key in ["events", "subscribers", "alerts"]:
+                        if (
+                            rel_key in rels
+                            and isinstance(rels[rel_key], dict)
+                            and "data" in rels[rel_key]
+                        ):
+                            data_list = rels[rel_key].get("data", [])
+                            if isinstance(data_list, list):
+                                rels[rel_key] = {"count": len(data_list)}
+
+    return data
+
+
+class ProcessedResponse:
+    """Wrapper around httpx.Response that processes JSON to reduce payload size."""
+
+    def __init__(self, response: httpx.Response):
+        self._response = response
+        self._processed_json = None
+
+    def json(self, **kwargs):
+        """Parse JSON and strip heavy nested data."""
+        if self._processed_json is None:
+            raw_data = self._response.json(**kwargs)
+            self._processed_json = strip_heavy_nested_data(raw_data)
+        return self._processed_json
+
+    def __getattr__(self, name):
+        """Delegate all other attributes to the wrapped response."""
+        return getattr(self._response, name)
+
+
+class ResponseProcessingClient(httpx.AsyncClient):
+    """AsyncClient subclass that wraps responses to reduce payload size.
+
+    This is necessary because FastMCP.from_openapi() uses the client directly,
+    bypassing any wrapper class. By subclassing httpx.AsyncClient, we ensure
+    all responses go through our processing.
+    """
+
+    async def request(self, method, url, **kwargs):
+        """Override request to wrap response with ProcessedResponse."""
+        response = await super().request(method, url, **kwargs)
+        return ProcessedResponse(response)
+
+
 class MCPError:
     """Enhanced error handling for MCP protocol compliance."""
-    
+
     @staticmethod
-    def protocol_error(code: int, message: str, data: Optional[Dict] = None):
+    def protocol_error(code: int, message: str, data: dict | None = None):
         """Create a JSON-RPC protocol-level error response."""
-        error_response = {
-            "jsonrpc": "2.0",
-            "error": {
-                "code": code,
-                "message": message
-            }
-        }
+        error_response = {"jsonrpc": "2.0", "error": {"code": code, "message": message}}
         if data:
             error_response["error"]["data"] = data
         return error_response
-    
+
     @staticmethod
-    def tool_error(error_message: str, error_type: str = "execution_error", details: Optional[Dict] = None):
+    def tool_error(
+        error_message: str, error_type: str = "execution_error", details: dict | None = None
+    ):
         """Create a tool-level error response (returned as successful tool result)."""
-        error_response = {
-            "error": True,
-            "error_type": error_type,
-            "message": error_message
-        }
+        error_response = {"error": True, "error_type": error_type, "message": error_message}
         if details:
             error_response["details"] = details
         return error_response
-    
+
     @staticmethod
     def categorize_error(exception: Exception) -> tuple[str, str]:
         """Categorize an exception into error type and appropriate message."""
         error_str = str(exception)
         exception_type = type(exception).__name__
-        
+
         # Authentication/Authorization errors
-        if any(keyword in error_str.lower() for keyword in ["401", "unauthorized", "authentication", "token", "forbidden"]):
+        if any(
+            keyword in error_str.lower()
+            for keyword in ["401", "unauthorized", "authentication", "token", "forbidden"]
+        ):
             return "authentication_error", f"Authentication failed: {error_str}"
-        
-        # Network/Connection errors  
-        if any(keyword in exception_type.lower() for keyword in ["connection", "timeout", "network"]):
+
+        # Network/Connection errors
+        if any(
+            keyword in exception_type.lower() for keyword in ["connection", "timeout", "network"]
+        ):
             return "network_error", f"Network error: {error_str}"
-        
+
         # HTTP errors
         if "40" in error_str[:10]:  # 4xx client errors
             return "client_error", f"Client error: {error_str}"
         elif "50" in error_str[:10]:  # 5xx server errors
             return "server_error", f"Server error: {error_str}"
-        
+
         # Validation errors
-        if any(keyword in exception_type.lower() for keyword in ["validation", "pydantic", "field"]):
+        if any(
+            keyword in exception_type.lower() for keyword in ["validation", "pydantic", "field"]
+        ):
             return "validation_error", f"Input validation error: {error_str}"
-            
+
         # Generic execution errors
         return "execution_error", f"Tool execution error: {error_str}"
 
+
 # Default Swagger URL
 SWAGGER_URL = "https://rootly-heroku.s3.amazonaws.com/swagger/v1/swagger.json"
 
+
 # Default allowed API paths
 def _generate_recommendation(solution_data: dict) -> str:
     """Generate a high-level recommendation based on solution analysis."""
     solutions = solution_data.get("solutions", [])
     avg_time = solution_data.get("average_resolution_time")
-    
+
     if not solutions:
         return "No similar incidents found. This may be a novel issue requiring escalation."
-    
+
     recommendation_parts = []
-    
+
     # Time expectation
     if avg_time:
         if avg_time < 1:
             recommendation_parts.append("Similar incidents typically resolve quickly (< 1 hour).")
         elif avg_time > 4:
-            recommendation_parts.append("Similar incidents typically require more time (> 4 hours).")
-    
+            recommendation_parts.append(
+                "Similar incidents typically require more time (> 4 hours)."
+            )
+
     # Top solution
     if solutions:
         top_solution = solutions[0]
         if top_solution.get("suggested_actions"):
             actions = top_solution["suggested_actions"][:2]  # Top 2 actions
             recommendation_parts.append(f"Consider trying: {', '.join(actions)}")
-    
+
     # Pattern insights
     patterns = solution_data.get("common_patterns", [])
     if patterns:
         recommendation_parts.append(f"Common patterns: {patterns[0]}")
-    
-    return " ".join(recommendation_parts) if recommendation_parts else "Review similar incidents above for resolution guidance."
+
+    return (
+        " ".join(recommendation_parts)
+        if recommendation_parts
+        else "Review similar incidents above for resolution guidance."
+    )
 
 
 # Default allowed API paths
@@ -175,7 +445,12 @@ DEFAULT_ALLOWED_PATHS = [
 class AuthenticatedHTTPXClient:
     """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):
+    def __init__(
+        self,
+        base_url: str = "https://api.rootly.com",
+        hosted: bool = False,
+        parameter_mapping: dict[str, str] | None = None,
+    ):
         self._base_url = base_url
         self.hosted = hosted
         self._api_token = None
@@ -184,25 +459,25 @@ class AuthenticatedHTTPXClient:
         if not self.hosted:
             self._api_token = self._get_api_token()
 
-        # Create the HTTPX client  
+        # Create the HTTPX client
         headers = {
-            "Content-Type": "application/vnd.api+json", 
-            "Accept": "application/vnd.api+json"
+            "Content-Type": "application/vnd.api+json",
+            "Accept": "application/vnd.api+json",
             # Let httpx handle Accept-Encoding automatically with all supported formats
         }
         if self._api_token:
             headers["Authorization"] = f"Bearer {self._api_token}"
 
-        self.client = httpx.AsyncClient(
+        self.client = ResponseProcessingClient(
             base_url=base_url,
             headers=headers,
             timeout=30.0,
             follow_redirects=True,
             # Ensure proper handling of compressed responses
-            limits=httpx.Limits(max_keepalive_connections=5, max_connections=10)
+            limits=httpx.Limits(max_keepalive_connections=5, max_connections=10),
         )
 
-    def _get_api_token(self) -> Optional[str]:
+    def _get_api_token(self) -> str | None:
         """Get the API token from environment variables."""
         api_token = os.getenv("ROOTLY_API_TOKEN")
         if not api_token:
@@ -210,7 +485,7 @@ class AuthenticatedHTTPXClient:
             return None
         return api_token
 
-    def _transform_params(self, params: Optional[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
+    def _transform_params(self, params: dict[str, Any] | None) -> dict[str, Any] | None:
         """Transform sanitized parameter names back to original names."""
         if not params or not self.parameter_mapping:
             return params
@@ -225,33 +500,36 @@ class AuthenticatedHTTPXClient:
         return transformed
 
     async def request(self, method: str, url: str, **kwargs):
-        """Override request to transform parameters."""
+        """Override request to transform parameters and wrap response for payload reduction."""
         # Transform query parameters
-        if 'params' in kwargs:
-            kwargs['params'] = self._transform_params(kwargs['params'])
+        if "params" in kwargs:
+            kwargs["params"] = self._transform_params(kwargs["params"])
 
-        # Call the underlying client's request method and let it handle everything
-        return await self.client.request(method, url, **kwargs)
+        # Call the underlying client's request method
+        response = await self.client.request(method, url, **kwargs)
+
+        # Wrap response to process JSON and reduce payload size
+        return ProcessedResponse(response)
 
     async def get(self, url: str, **kwargs):
         """Proxy to request with GET method."""
-        return await self.request('GET', url, **kwargs)
+        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)
+        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)
+        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)
+        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)
+        return await self.request("DELETE", url, **kwargs)
 
     async def __aenter__(self):
         return self
@@ -261,26 +539,26 @@ class AuthenticatedHTTPXClient:
 
     def __getattr__(self, name):
         # Delegate all other attributes to the underlying client, except for request methods
-        if name in ['request', 'get', 'post', 'put', 'patch', 'delete']:
+        if name in ["request", "get", "post", "put", "patch", "delete"]:
             # Use our overridden methods instead
             return getattr(self, name)
         return getattr(self.client, name)
-    
-    @property 
+
+    @property
     def base_url(self):
         return self._base_url
-        
+
     @property
     def headers(self):
         return self.client.headers
 
 
 def create_rootly_mcp_server(
-    swagger_path: Optional[str] = None,
+    swagger_path: str | None = None,
     name: str = "Rootly",
-    allowed_paths: Optional[List[str]] = None,
+    allowed_paths: list[str] | None = None,
     hosted: bool = False,
-    base_url: Optional[str] = None,
+    base_url: str | None = None,
 ) -> FastMCP:
     """
     Create a Rootly MCP Server using FastMCP's OpenAPI integration.
@@ -301,8 +579,7 @@ def create_rootly_mcp_server(
 
     # Add /v1 prefix to paths if not present
     allowed_paths_v1 = [
-        f"/v1{path}" if not path.startswith("/v1") else path
-        for path in allowed_paths
+        f"/v1{path}" if not path.startswith("/v1") else path for path in allowed_paths
     ]
 
     logger.info(f"Creating Rootly MCP Server with allowed paths: {allowed_paths_v1}")
@@ -317,7 +594,9 @@ def create_rootly_mcp_server(
 
     # 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)")
+    logger.info(
+        f"Sanitized parameter names for MCP compatibility (mapped {len(parameter_mapping)} parameters)"
+    )
 
     # Determine the base URL
     if base_url is None:
@@ -328,9 +607,7 @@ def create_rootly_mcp_server(
     # Create the authenticated HTTP client with parameter mapping
 
     http_client = AuthenticatedHTTPXClient(
-        base_url=base_url,
-        hosted=hosted,
-        parameter_mapping=parameter_mapping
+        base_url=base_url, hosted=hosted, parameter_mapping=parameter_mapping
     )
 
     # Create the MCP server using OpenAPI integration
@@ -342,13 +619,14 @@ 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()
@@ -363,12 +641,14 @@ def create_rootly_mcp_server(
                 summary = operation.get("summary", "")
                 description = operation.get("description", "")
 
-                endpoints.append({
-                    "path": path,
-                    "method": method.upper(),
-                    "summary": summary,
-                    "description": description,
-                })
+                endpoints.append(
+                    {
+                        "path": path,
+                        "method": method.upper(),
+                        "summary": summary,
+                        "description": description,
+                    }
+                )
 
         return endpoints
 
@@ -378,6 +658,7 @@ def create_rootly_mcp_server(
         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:
@@ -385,18 +666,33 @@ def create_rootly_mcp_server(
                     if "headers" not in kwargs:
                         kwargs["headers"] = {}
                     kwargs["headers"]["Authorization"] = auth_header
-            except Exception:
-                pass  # Fallback to default client behavior
-        
+            except Exception:  # nosec B110
+                # Intentionally broad exception handling: fallback to default client behavior
+                # if token extraction fails for any reason (missing env var, invalid format, etc.)
+                pass
+
         # Use our custom client with proper error handling instead of bypassing it
         return await http_client.request(method, url, **kwargs)
 
     @mcp.tool()
     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: 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=10)] = 5,
+        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: 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=10,
+            ),
+        ] = 5,
     ) -> dict:
         """
         Search incidents with flexible pagination control.
@@ -410,7 +706,7 @@ def create_rootly_mcp_server(
                 "page[size]": page_size,  # Use requested page size (already limited to max 20)
                 "page[number]": page_number,
                 "include": "",
-                "fields[incidents]": "id,title,summary,status,severity,created_at,updated_at,url,started_at",
+                "fields[incidents]": "id,title,summary,status,created_at,updated_at,url,started_at",
             }
             if query:
                 params["filter[search]"] = query
@@ -418,7 +714,7 @@ def create_rootly_mcp_server(
             try:
                 response = await make_authenticated_request("GET", "/v1/incidents", params=params)
                 response.raise_for_status()
-                return response.json()
+                return strip_heavy_nested_data(response.json())
             except Exception as e:
                 error_type, error_message = MCPError.categorize_error(e)
                 return MCPError.tool_error(error_message, error_type)
@@ -435,13 +731,15 @@ def create_rootly_mcp_server(
                     "page[size]": effective_page_size,
                     "page[number]": current_page,
                     "include": "",
-                    "fields[incidents]": "id,title,summary,status,severity,created_at,updated_at,url,started_at",
+                    "fields[incidents]": "id,title,summary,status,created_at,updated_at,url,started_at",
                 }
                 if query:
                     params["filter[search]"] = query
 
                 try:
-                    response = await make_authenticated_request("GET", "/v1/incidents", params=params)
+                    response = await make_authenticated_request(
+                        "GET", "/v1/incidents", params=params
+                    )
                     response.raise_for_status()
                     response_data = response.json()
 
@@ -450,19 +748,19 @@ def create_rootly_mcp_server(
                         if not incidents:
                             # No more incidents available
                             break
-                        
+
                         # Check if we got fewer incidents than requested (last page)
                         if len(incidents) < effective_page_size:
                             all_incidents.extend(incidents)
                             break
-                        
+
                         all_incidents.extend(incidents)
 
                         # Check metadata if available
                         meta = response_data.get("meta", {})
                         current_page_meta = meta.get("current_page", current_page)
                         total_pages = meta.get("total_pages")
-                        
+
                         # If we have reliable metadata, use it
                         if total_pages and current_page_meta >= total_pages:
                             break
@@ -473,7 +771,11 @@ def create_rootly_mcp_server(
 
                 except Exception as e:
                     # Re-raise authentication or critical errors for immediate handling
-                    if "401" in str(e) or "Unauthorized" in str(e) or "authentication" in str(e).lower():
+                    if (
+                        "401" in str(e)
+                        or "Unauthorized" in str(e)
+                        or "authentication" in str(e).lower()
+                    ):
                         error_type, error_message = MCPError.categorize_error(e)
                         return MCPError.tool_error(error_message, error_type)
                     # For other errors, break loop and return partial results
@@ -483,16 +785,18 @@ def create_rootly_mcp_server(
             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
+            return strip_heavy_nested_data(
+                {
+                    "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:
             error_type, error_message = MCPError.categorize_error(e)
             return MCPError.tool_error(error_message, error_type)
@@ -505,24 +809,37 @@ def create_rootly_mcp_server(
     async def find_related_incidents(
         incident_id: str = "",
         incident_description: str = "",
-        similarity_threshold: Annotated[float, Field(description="Minimum similarity score (0.0-1.0)", ge=0.0, le=1.0)] = 0.15,
-        max_results: Annotated[int, Field(description="Maximum number of related incidents to return", ge=1, le=20)] = 5,
-        status_filter: Annotated[str, Field(description="Filter incidents by status (empty for all, 'resolved', 'investigating', etc.)")] = ""
+        similarity_threshold: Annotated[
+            float, Field(description="Minimum similarity score (0.0-1.0)", ge=0.0, le=1.0)
+        ] = 0.15,
+        max_results: Annotated[
+            int, Field(description="Maximum number of related incidents to return", ge=1, le=20)
+        ] = 5,
+        status_filter: Annotated[
+            str,
+            Field(
+                description="Filter incidents by status (empty for all, 'resolved', 'investigating', etc.)"
+            ),
+        ] = "",
     ) -> dict:
         """Find similar incidents to help with context and resolution strategies. Provide either incident_id OR incident_description (e.g., 'website is down', 'database timeout errors'). Use status_filter to limit to specific incident statuses or leave empty for all incidents."""
         try:
             target_incident = {}
-            
+
             if incident_id:
                 # Get the target incident details by ID
-                target_response = await make_authenticated_request("GET", f"/v1/incidents/{incident_id}")
+                target_response = await make_authenticated_request(
+                    "GET", f"/v1/incidents/{incident_id}"
+                )
                 target_response.raise_for_status()
-                target_incident_data = target_response.json()
-                target_incident = target_incident_data.get("data", {})
-                
+                target_incident_data = strip_heavy_nested_data(
+                    {"data": [target_response.json().get("data", {})]}
+                )
+                target_incident = target_incident_data.get("data", [{}])[0]
+
                 if not target_incident:
                     return MCPError.tool_error("Incident not found", "not_found")
-                    
+
             elif incident_description:
                 # Create synthetic incident for analysis from descriptive text
                 target_incident = {
@@ -530,101 +847,124 @@ def create_rootly_mcp_server(
                     "attributes": {
                         "title": incident_description,
                         "summary": incident_description,
-                        "description": incident_description
-                    }
+                        "description": incident_description,
+                    },
                 }
             else:
-                return MCPError.tool_error("Must provide either incident_id or incident_description", "validation_error")
-            
+                return MCPError.tool_error(
+                    "Must provide either incident_id or incident_description", "validation_error"
+                )
+
             # Get historical incidents for comparison
             params = {
                 "page[size]": 100,  # Get more incidents for better matching
                 "page[number]": 1,
-                "include": ""
+                "include": "",
+                "fields[incidents]": "id,title,summary,status,created_at,url",
             }
-            
+
             # Only add status filter if specified
             if status_filter:
                 params["filter[status]"] = status_filter
-                
-            historical_response = await make_authenticated_request("GET", "/v1/incidents", params=params)
+
+            historical_response = await make_authenticated_request(
+                "GET", "/v1/incidents", params=params
+            )
             historical_response.raise_for_status()
-            historical_data = historical_response.json()
+            historical_data = strip_heavy_nested_data(historical_response.json())
             historical_incidents = historical_data.get("data", [])
-            
+
             # Filter out the target incident itself if it exists
             if incident_id:
-                historical_incidents = [inc for inc in historical_incidents if str(inc.get('id')) != str(incident_id)]
-            
+                historical_incidents = [
+                    inc for inc in historical_incidents if str(inc.get("id")) != str(incident_id)
+                ]
+
             if not historical_incidents:
                 return {
                     "related_incidents": [],
                     "message": "No historical incidents found for comparison",
                     "target_incident": {
                         "id": incident_id or "synthetic",
-                        "title": target_incident.get("attributes", {}).get("title", incident_description)
-                    }
+                        "title": target_incident.get("attributes", {}).get(
+                            "title", incident_description
+                        ),
+                    },
                 }
-            
+
             # Calculate similarities
-            similar_incidents = similarity_analyzer.calculate_similarity(historical_incidents, target_incident)
-            
+            similar_incidents = similarity_analyzer.calculate_similarity(
+                historical_incidents, target_incident
+            )
+
             # Filter by threshold and limit results
             filtered_incidents = [
-                inc for inc in similar_incidents 
-                if inc.similarity_score >= similarity_threshold
+                inc for inc in similar_incidents if inc.similarity_score >= similarity_threshold
             ][:max_results]
-            
+
             # Format response
             related_incidents = []
             for incident in filtered_incidents:
-                related_incidents.append({
-                    "incident_id": incident.incident_id,
-                    "title": incident.title,
-                    "similarity_score": round(incident.similarity_score, 3),
-                    "matched_services": incident.matched_services,
-                    "matched_keywords": incident.matched_keywords,
-                    "resolution_summary": incident.resolution_summary,
-                    "resolution_time_hours": incident.resolution_time_hours
-                })
-            
+                related_incidents.append(
+                    {
+                        "incident_id": incident.incident_id,
+                        "title": incident.title,
+                        "similarity_score": round(incident.similarity_score, 3),
+                        "matched_services": incident.matched_services,
+                        "matched_keywords": incident.matched_keywords,
+                        "resolution_summary": incident.resolution_summary,
+                        "resolution_time_hours": incident.resolution_time_hours,
+                    }
+                )
+
             return {
                 "target_incident": {
                     "id": incident_id or "synthetic",
-                    "title": target_incident.get("attributes", {}).get("title", incident_description)
+                    "title": target_incident.get("attributes", {}).get(
+                        "title", incident_description
+                    ),
                 },
                 "related_incidents": related_incidents,
                 "total_found": len(filtered_incidents),
                 "similarity_threshold": similarity_threshold,
-                "analysis_summary": f"Found {len(filtered_incidents)} similar incidents out of {len(historical_incidents)} historical incidents"
+                "analysis_summary": f"Found {len(filtered_incidents)} similar incidents out of {len(historical_incidents)} historical incidents",
             }
-            
+
         except Exception as e:
             error_type, error_message = MCPError.categorize_error(e)
-            return MCPError.tool_error(f"Failed to find related incidents: {error_message}", error_type)
+            return MCPError.tool_error(
+                f"Failed to find related incidents: {error_message}", error_type
+            )
 
     @mcp.tool()
     async def suggest_solutions(
         incident_id: str = "",
         incident_title: str = "",
         incident_description: str = "",
-        max_solutions: Annotated[int, Field(description="Maximum number of solution suggestions", ge=1, le=10)] = 3,
-        status_filter: Annotated[str, Field(description="Filter incidents by status (default 'resolved', empty for all, 'investigating', etc.)")] = "resolved"
+        max_solutions: Annotated[
+            int, Field(description="Maximum number of solution suggestions", ge=1, le=10)
+        ] = 3,
+        status_filter: Annotated[
+            str,
+            Field(
+                description="Filter incidents by status (default 'resolved', empty for all, 'investigating', etc.)"
+            ),
+        ] = "resolved",
     ) -> dict:
         """Suggest solutions based on similar incidents. Provide either incident_id OR title/description. Defaults to resolved incidents for solution mining, but can search all statuses."""
         try:
             target_incident = {}
-            
+
             if incident_id:
                 # Get incident details by ID
                 response = await make_authenticated_request("GET", f"/v1/incidents/{incident_id}")
                 response.raise_for_status()
-                incident_data = response.json()
-                target_incident = incident_data.get("data", {})
-                
+                incident_data = strip_heavy_nested_data({"data": [response.json().get("data", {})]})
+                target_incident = incident_data.get("data", [{}])[0]
+
                 if not target_incident:
                     return MCPError.tool_error("Incident not found", "not_found")
-                    
+
             elif incident_title or incident_description:
                 # Create synthetic incident for analysis
                 target_incident = {
@@ -632,83 +972,117 @@ def create_rootly_mcp_server(
                     "attributes": {
                         "title": incident_title,
                         "summary": incident_description,
-                        "description": incident_description
-                    }
+                        "description": incident_description,
+                    },
                 }
             else:
-                return MCPError.tool_error("Must provide either incident_id or incident_title/description", "validation_error")
-            
+                return MCPError.tool_error(
+                    "Must provide either incident_id or incident_title/description",
+                    "validation_error",
+                )
+
             # Get incidents for solution mining
             params = {
                 "page[size]": 150,  # Get more incidents for better solution matching
                 "page[number]": 1,
-                "include": ""
+                "include": "",
             }
-            
+
             # Only add status filter if specified
             if status_filter:
                 params["filter[status]"] = status_filter
-                
-            historical_response = await make_authenticated_request("GET", "/v1/incidents", params=params)
+
+            historical_response = await make_authenticated_request(
+                "GET", "/v1/incidents", params=params
+            )
             historical_response.raise_for_status()
-            historical_data = historical_response.json()
+            historical_data = strip_heavy_nested_data(historical_response.json())
             historical_incidents = historical_data.get("data", [])
-            
+
             # Filter out target incident if it exists
             if incident_id:
-                historical_incidents = [inc for inc in historical_incidents if str(inc.get('id')) != str(incident_id)]
-            
+                historical_incidents = [
+                    inc for inc in historical_incidents if str(inc.get("id")) != str(incident_id)
+                ]
+
             if not historical_incidents:
                 status_msg = f" with status '{status_filter}'" if status_filter else ""
                 return {
                     "solutions": [],
-                    "message": f"No historical incidents found{status_msg} for solution mining"
+                    "message": f"No historical incidents found{status_msg} for solution mining",
                 }
-            
+
             # Find similar incidents
-            similar_incidents = similarity_analyzer.calculate_similarity(historical_incidents, target_incident)
-            
+            similar_incidents = similarity_analyzer.calculate_similarity(
+                historical_incidents, target_incident
+            )
+
             # Filter to reasonably similar incidents (lower threshold for solution suggestions)
-            relevant_incidents = [inc for inc in similar_incidents if inc.similarity_score >= 0.2][:max_solutions * 2]
-            
+            relevant_incidents = [inc for inc in similar_incidents if inc.similarity_score >= 0.2][
+                : max_solutions * 2
+            ]
+
             if not relevant_incidents:
                 return {
                     "solutions": [],
                     "message": "No sufficiently similar incidents found for solution suggestions",
-                    "suggestion": "This appears to be a unique incident. Consider escalating or consulting documentation."
+                    "suggestion": "This appears to be a unique incident. Consider escalating or consulting documentation.",
                 }
-            
+
             # Extract solutions
             solution_data = solution_extractor.extract_solutions(relevant_incidents)
-            
+
             # Format response
             return {
                 "target_incident": {
                     "id": incident_id or "synthetic",
                     "title": target_incident.get("attributes", {}).get("title", incident_title),
-                    "description": target_incident.get("attributes", {}).get("summary", incident_description)
+                    "description": target_incident.get("attributes", {}).get(
+                        "summary", incident_description
+                    ),
                 },
                 "solutions": solution_data["solutions"][:max_solutions],
                 "insights": {
                     "common_patterns": solution_data["common_patterns"],
                     "average_resolution_time_hours": solution_data["average_resolution_time"],
-                    "total_similar_incidents": solution_data["total_similar_incidents"]
+                    "total_similar_incidents": solution_data["total_similar_incidents"],
                 },
-                "recommendation": _generate_recommendation(solution_data)
+                "recommendation": _generate_recommendation(solution_data),
             }
-            
+
         except Exception as e:
             error_type, error_message = MCPError.categorize_error(e)
             return MCPError.tool_error(f"Failed to suggest solutions: {error_message}", error_type)
 
     @mcp.tool()
     async def get_oncall_shift_metrics(
-        start_date: Annotated[str, Field(description="Start date for metrics (ISO 8601 format, e.g., '2025-10-01' or '2025-10-01T00:00:00Z')")],
-        end_date: Annotated[str, Field(description="End date for metrics (ISO 8601 format, e.g., '2025-10-31' or '2025-10-31T23:59:59Z')")],
-        user_ids: Annotated[str, Field(description="Comma-separated list of user IDs to filter by (optional)")] = "",
-        schedule_ids: Annotated[str, Field(description="Comma-separated list of schedule IDs to filter by (optional)")] = "",
-        team_ids: Annotated[str, Field(description="Comma-separated list of team IDs to filter by (requires querying schedules first)")] = "",
-        group_by: Annotated[str, Field(description="Group results by: 'user', 'schedule', 'team', or 'none'")] = "user"
+        start_date: Annotated[
+            str,
+            Field(
+                description="Start date for metrics (ISO 8601 format, e.g., '2025-10-01' or '2025-10-01T00:00:00Z')"
+            ),
+        ],
+        end_date: Annotated[
+            str,
+            Field(
+                description="End date for metrics (ISO 8601 format, e.g., '2025-10-31' or '2025-10-31T23:59:59Z')"
+            ),
+        ],
+        user_ids: Annotated[
+            str, Field(description="Comma-separated list of user IDs to filter by (optional)")
+        ] = "",
+        schedule_ids: Annotated[
+            str, Field(description="Comma-separated list of schedule IDs to filter by (optional)")
+        ] = "",
+        team_ids: Annotated[
+            str,
+            Field(
+                description="Comma-separated list of team IDs to filter by (requires querying schedules first)"
+            ),
+        ] = "",
+        group_by: Annotated[
+            str, Field(description="Group results by: 'user', 'schedule', 'team', or 'none'")
+        ] = "user",
     ) -> dict:
         """
         Get on-call shift metrics for a specified time period. Returns shift counts, total hours,
@@ -720,21 +1094,25 @@ def create_rootly_mcp_server(
         - Specific team: team_ids='team-1' (will query schedules for that team first)
         """
         try:
-            from datetime import datetime, timedelta
             from collections import defaultdict
-            from typing import Any, Dict
+            from datetime import datetime, timedelta
+            from typing import Any
 
             # Build query parameters
-            params: Dict[str, Any] = {
+            params: dict[str, Any] = {
                 "from": start_date,
                 "to": end_date,
             }
 
             # Fetch schedules (schedules don't have team relationship, they have owner_group_ids)
-            schedules_response = await make_authenticated_request("GET", "/v1/schedules", params={"page[size]": 100})
+            schedules_response = await make_authenticated_request(
+                "GET", "/v1/schedules", params={"page[size]": 100}
+            )
 
             if schedules_response is None:
-                return MCPError.tool_error("Failed to get schedules: API request returned None", "execution_error")
+                return MCPError.tool_error(
+                    "Failed to get schedules: API request returned None", "execution_error"
+                )
 
             schedules_response.raise_for_status()
             schedules_data = schedules_response.json()
@@ -750,7 +1128,9 @@ def create_rootly_mcp_server(
             # Fetch all teams
             teams_map = {}
             if team_ids_set:
-                teams_response = await make_authenticated_request("GET", "/v1/teams", params={"page[size]": 100})
+                teams_response = await make_authenticated_request(
+                    "GET", "/v1/teams", params={"page[size]": 100}
+                )
                 if teams_response and teams_response.status_code == 200:
                     teams_data = teams_response.json()
                     for team in teams_data.get("data", []):
@@ -771,7 +1151,7 @@ def create_rootly_mcp_server(
                     schedule_to_team_map[schedule_id] = {
                         "team_id": team_id,
                         "team_name": team_name,
-                        "schedule_name": schedule_name
+                        "schedule_name": schedule_name,
                     }
 
             # Handle team filtering (requires multi-step query)
@@ -802,23 +1182,39 @@ def create_rootly_mcp_server(
 
             # Query shifts
             try:
-                shifts_response = await make_authenticated_request("GET", "/v1/shifts", params=params)
+                shifts_response = await make_authenticated_request(
+                    "GET", "/v1/shifts", params=params
+                )
 
                 if shifts_response is None:
-                    return MCPError.tool_error("Failed to get shifts: API request returned None", "execution_error")
+                    return MCPError.tool_error(
+                        "Failed to get shifts: API request returned None", "execution_error"
+                    )
 
                 shifts_response.raise_for_status()
                 shifts_data = shifts_response.json()
 
                 if shifts_data is None:
-                    return MCPError.tool_error("Failed to get shifts: API returned null/empty response", "execution_error", details={"status": shifts_response.status_code})
+                    return MCPError.tool_error(
+                        "Failed to get shifts: API returned null/empty response",
+                        "execution_error",
+                        details={"status": shifts_response.status_code},
+                    )
 
                 shifts = shifts_data.get("data", [])
                 included = shifts_data.get("included", [])
             except AttributeError as e:
-                return MCPError.tool_error(f"Failed to get shifts: Response object error - {str(e)}", "execution_error", details={"params": params})
+                return MCPError.tool_error(
+                    f"Failed to get shifts: Response object error - {str(e)}",
+                    "execution_error",
+                    details={"params": params},
+                )
             except Exception as e:
-                return MCPError.tool_error(f"Failed to get shifts: {str(e)}", "execution_error", details={"params": params, "error_type": type(e).__name__})
+                return MCPError.tool_error(
+                    f"Failed to get shifts: {str(e)}",
+                    "execution_error",
+                    details={"params": params, "error_type": type(e).__name__},
+                )
 
             # Build lookup maps for included resources
             users_map = {}
@@ -830,19 +1226,21 @@ def create_rootly_mcp_server(
                     on_call_roles_map[resource.get("id")] = resource
 
             # Calculate metrics
-            metrics: Dict[str, Dict[str, Any]] = defaultdict(lambda: {
-                "shift_count": 0,
-                "total_hours": 0.0,
-                "override_count": 0,
-                "regular_count": 0,
-                "primary_count": 0,
-                "secondary_count": 0,
-                "primary_hours": 0.0,
-                "secondary_hours": 0.0,
-                "unknown_role_count": 0,
-                "unique_days": set(),
-                "shifts": []
-            })
+            metrics: dict[str, dict[str, Any]] = defaultdict(
+                lambda: {
+                    "shift_count": 0,
+                    "total_hours": 0.0,
+                    "override_count": 0,
+                    "regular_count": 0,
+                    "primary_count": 0,
+                    "secondary_count": 0,
+                    "primary_hours": 0.0,
+                    "secondary_hours": 0.0,
+                    "unknown_role_count": 0,
+                    "unique_days": set(),
+                    "shifts": [],
+                }
+            )
 
             for shift in shifts:
                 attrs = shift.get("attributes", {})
@@ -937,19 +1335,21 @@ def create_rootly_mcp_server(
                 # Track unique days
                 metrics[key]["unique_days"].update(shift_days)
 
-                metrics[key]["shifts"].append({
-                    "shift_id": shift.get("id"),
-                    "starts_at": starts_at,
-                    "ends_at": ends_at,
-                    "duration_hours": round(duration_hours, 2),
-                    "is_override": is_override,
-                    "schedule_id": schedule_id,
-                    "user_id": user_id,
-                    "user_name": user_name,
-                    "user_email": user_email,
-                    "role_name": role_name,
-                    "is_primary": is_primary
-                })
+                metrics[key]["shifts"].append(
+                    {
+                        "shift_id": shift.get("id"),
+                        "starts_at": starts_at,
+                        "ends_at": ends_at,
+                        "duration_hours": round(duration_hours, 2),
+                        "is_override": is_override,
+                        "schedule_id": schedule_id,
+                        "user_id": user_id,
+                        "user_name": user_name,
+                        "user_email": user_email,
+                        "role_name": role_name,
+                        "is_primary": is_primary,
+                    }
+                )
 
             # Format results
             results = []
@@ -1023,10 +1423,7 @@ def create_rootly_mcp_server(
             results.sort(key=lambda x: x["shift_count"], reverse=True)
 
             return {
-                "period": {
-                    "start_date": start_date,
-                    "end_date": end_date
-                },
+                "period": {"start_date": start_date, "end_date": end_date},
                 "total_shifts": len(shifts),
                 "grouped_by": group_by,
                 "metrics": results,
@@ -1034,12 +1431,13 @@ def create_rootly_mcp_server(
                     "total_hours": round(sum(m["total_hours"] for m in results), 2),
                     "total_regular_shifts": sum(m["regular_shifts"] for m in results),
                     "total_override_shifts": sum(m["override_shifts"] for m in results),
-                    "unique_people": len(results) if group_by == "user" else None
-                }
+                    "unique_people": len(results) if group_by == "user" else None,
+                },
             }
 
         except Exception as e:
             import traceback
+
             error_type, error_message = MCPError.categorize_error(e)
             return MCPError.tool_error(
                 f"Failed to get on-call shift metrics: {error_message}",
@@ -1048,17 +1446,37 @@ def create_rootly_mcp_server(
                     "params": {"start_date": start_date, "end_date": end_date},
                     "exception_type": type(e).__name__,
                     "exception_str": str(e),
-                    "traceback": traceback.format_exc()
-                }
+                    "traceback": traceback.format_exc(),
+                },
             )
 
     @mcp.tool()
     async def get_oncall_handoff_summary(
-        team_ids: Annotated[str, Field(description="Comma-separated list of team IDs to filter schedules (optional)")] = "",
-        schedule_ids: Annotated[str, Field(description="Comma-separated list of schedule IDs (optional)")] = "",
-        timezone: Annotated[str, Field(description="Timezone to use for display and filtering (e.g., 'America/Los_Angeles', 'Europe/London', 'Asia/Tokyo'). IMPORTANT: If user mentions a city, location, or region (e.g., 'Toronto', 'APAC', 'my time'), infer the appropriate IANA timezone. Defaults to UTC if not specified.")] = "UTC",
-        filter_by_region: Annotated[bool, Field(description="If True, only show on-call for people whose shifts are during business hours (9am-5pm) in the specified timezone. Defaults to False.")] = False,
-        include_incidents: Annotated[bool, Field(description="If True, fetch incidents for each shift (slower). If False, only show on-call info (faster). Defaults to False for better performance.")] = False
+        team_ids: Annotated[
+            str,
+            Field(description="Comma-separated list of team IDs to filter schedules (optional)"),
+        ] = "",
+        schedule_ids: Annotated[
+            str, Field(description="Comma-separated list of schedule IDs (optional)")
+        ] = "",
+        timezone: Annotated[
+            str,
+            Field(
+                description="Timezone to use for display and filtering (e.g., 'America/Los_Angeles', 'Europe/London', 'Asia/Tokyo'). IMPORTANT: If user mentions a city, location, or region (e.g., 'Toronto', 'APAC', 'my time'), infer the appropriate IANA timezone. Defaults to UTC if not specified."
+            ),
+        ] = "UTC",
+        filter_by_region: Annotated[
+            bool,
+            Field(
+                description="If True, only show on-call for people whose shifts are during business hours (9am-5pm) in the specified timezone. Defaults to False."
+            ),
+        ] = False,
+        include_incidents: Annotated[
+            bool,
+            Field(
+                description="If True, fetch incidents for each shift (slower). If False, only show on-call info (faster). Defaults to False for better performance."
+            ),
+        ] = False,
     ) -> dict:
         """
         Get current on-call handoff summary. Shows who's currently on-call and who's next.
@@ -1109,15 +1527,19 @@ def create_rootly_mcp_server(
             max_pages = 5  # Schedules shouldn't have many pages
 
             while page <= max_pages:
-                schedules_response = await make_authenticated_request("GET", "/v1/schedules", params={"page[size]": 100, "page[number]": page})
+                schedules_response = await make_authenticated_request(
+                    "GET", "/v1/schedules", params={"page[size]": 100, "page[number]": page}
+                )
                 if not schedules_response:
-                    return MCPError.tool_error("Failed to fetch schedules - no response from API", "execution_error")
+                    return MCPError.tool_error(
+                        "Failed to fetch schedules - no response from API", "execution_error"
+                    )
 
                 if schedules_response.status_code != 200:
                     return MCPError.tool_error(
                         f"Failed to fetch schedules - API returned status {schedules_response.status_code}",
                         "execution_error",
-                        details={"status_code": schedules_response.status_code}
+                        details={"status_code": schedules_response.status_code},
                     )
 
                 schedules_data = schedules_response.json()
@@ -1145,7 +1567,9 @@ def create_rootly_mcp_server(
 
             teams_map = {}
             if team_ids_set:
-                teams_response = await make_authenticated_request("GET", "/v1/teams", params={"page[size]": 100})
+                teams_response = await make_authenticated_request(
+                    "GET", "/v1/teams", params={"page[size]": 100}
+                )
                 if teams_response and teams_response.status_code == 200:
                     teams_data = teams_response.json()
                     for team in teams_data.get("data", []):
@@ -1153,8 +1577,14 @@ def create_rootly_mcp_server(
 
             # Filter schedules
             target_schedules = []
-            team_filter = [tid.strip() for tid in team_ids.split(",") if tid.strip()] if team_ids else []
-            schedule_filter = [sid.strip() for sid in schedule_ids.split(",") if sid.strip()] if schedule_ids else []
+            team_filter = (
+                [tid.strip() for tid in team_ids.split(",") if tid.strip()] if team_ids else []
+            )
+            schedule_filter = (
+                [sid.strip() for sid in schedule_ids.split(",") if sid.strip()]
+                if schedule_ids
+                else []
+            )
 
             for schedule in all_schedules:
                 schedule_id = schedule.get("id")
@@ -1192,8 +1622,8 @@ def create_rootly_mcp_server(
                         "filter[starts_at][gte]": (now - timedelta(days=1)).isoformat(),
                         "filter[starts_at][lte]": (now + timedelta(days=7)).isoformat(),
                         "include": "user,on_call_role",
-                        "page[size]": 50
-                    }
+                        "page[size]": 50,
+                    },
                 )
 
                 if not shifts_response:
@@ -1216,7 +1646,9 @@ def create_rootly_mcp_server(
                 current_shift = None
                 next_shift = None
 
-                for shift in sorted(shifts, key=lambda s: s.get("attributes", {}).get("starts_at", "")):
+                for shift in sorted(
+                    shifts, key=lambda s: s.get("attributes", {}).get("starts_at", "")
+                ):
                     attrs = shift.get("attributes", {})
                     starts_at_str = attrs.get("starts_at")
                     ends_at_str = attrs.get("ends_at")
@@ -1244,21 +1676,23 @@ def create_rootly_mcp_server(
                     "schedule_name": schedule_name,
                     "team_name": team_name,
                     "current_oncall": None,
-                    "next_oncall": None
+                    "next_oncall": None,
                 }
 
                 if current_shift:
                     current_attrs = current_shift.get("attributes", {})
                     current_rels = current_shift.get("relationships", {})
-                    user_data = (current_rels.get("user", {}).get("data") or {})
+                    user_data = current_rels.get("user", {}).get("data") or {}
                     user_id = user_data.get("id")
-                    role_data = (current_rels.get("on_call_role", {}).get("data") or {})
+                    role_data = current_rels.get("on_call_role", {}).get("data") or {}
                     role_id = role_data.get("id")
 
                     user_name = "Unknown"
                     if user_id and user_id in users_map:
                         user_attrs = users_map[user_id].get("attributes", {})
-                        user_name = user_attrs.get("full_name") or user_attrs.get("email", "Unknown")
+                        user_name = user_attrs.get("full_name") or user_attrs.get(
+                            "email", "Unknown"
+                        )
 
                     role_name = "Unknown Role"
                     if role_id and role_id in roles_map:
@@ -1271,21 +1705,23 @@ def create_rootly_mcp_server(
                         "role": role_name,
                         "starts_at": convert_to_timezone(current_attrs.get("starts_at")),
                         "ends_at": convert_to_timezone(current_attrs.get("ends_at")),
-                        "is_override": current_attrs.get("is_override", False)
+                        "is_override": current_attrs.get("is_override", False),
                     }
 
                 if next_shift:
                     next_attrs = next_shift.get("attributes", {})
                     next_rels = next_shift.get("relationships", {})
-                    user_data = (next_rels.get("user", {}).get("data") or {})
+                    user_data = next_rels.get("user", {}).get("data") or {}
                     user_id = user_data.get("id")
-                    role_data = (next_rels.get("on_call_role", {}).get("data") or {})
+                    role_data = next_rels.get("on_call_role", {}).get("data") or {}
                     role_id = role_data.get("id")
 
                     user_name = "Unknown"
                     if user_id and user_id in users_map:
                         user_attrs = users_map[user_id].get("attributes", {})
-                        user_name = user_attrs.get("full_name") or user_attrs.get("email", "Unknown")
+                        user_name = user_attrs.get("full_name") or user_attrs.get(
+                            "email", "Unknown"
+                        )
 
                     role_name = "Unknown Role"
                     if role_id and role_id in roles_map:
@@ -1298,7 +1734,7 @@ def create_rootly_mcp_server(
                         "role": role_name,
                         "starts_at": convert_to_timezone(next_attrs.get("starts_at")),
                         "ends_at": convert_to_timezone(next_attrs.get("ends_at")),
-                        "is_override": next_attrs.get("is_override", False)
+                        "is_override": next_attrs.get("is_override", False),
                     }
 
                 handoff_data.append(schedule_info)
@@ -1310,8 +1746,12 @@ def create_rootly_mcp_server(
                 business_end_hour = 17
 
                 # Create datetime objects for today's business hours in target timezone
-                today_business_start = now.replace(hour=business_start_hour, minute=0, second=0, microsecond=0)
-                today_business_end = now.replace(hour=business_end_hour, minute=0, second=0, microsecond=0)
+                today_business_start = now.replace(
+                    hour=business_start_hour, minute=0, second=0, microsecond=0
+                )
+                today_business_end = now.replace(
+                    hour=business_end_hour, minute=0, second=0, microsecond=0
+                )
 
                 # Filter schedules where current shift overlaps with business hours
                 filtered_data = []
@@ -1324,12 +1764,19 @@ def create_rootly_mcp_server(
 
                         if shift_start_str and shift_end_str:
                             try:
-                                shift_start = datetime.fromisoformat(shift_start_str.replace("Z", "+00:00"))
-                                shift_end = datetime.fromisoformat(shift_end_str.replace("Z", "+00:00"))
+                                shift_start = datetime.fromisoformat(
+                                    shift_start_str.replace("Z", "+00:00")
+                                )
+                                shift_end = datetime.fromisoformat(
+                                    shift_end_str.replace("Z", "+00:00")
+                                )
 
                                 # Check if shift overlaps with today's business hours
                                 # Shift overlaps if: shift_start < business_end AND shift_end > business_start
-                                if shift_start < today_business_end and shift_end > today_business_start:
+                                if (
+                                    shift_start < today_business_end
+                                    and shift_end > today_business_start
+                                ):
                                     filtered_data.append(schedule_info)
                             except (ValueError, AttributeError):
                                 # Skip if we can't parse times
@@ -1351,10 +1798,12 @@ def create_rootly_mcp_server(
                             schedule_ids="",
                             severity="",
                             status="",
-                            tags=""
+                            tags="",
                         )
 
-                        schedule_info["shift_incidents"] = incidents_result if incidents_result.get("success") else None
+                        schedule_info["shift_incidents"] = (
+                            incidents_result if incidents_result.get("success") else None
+                        )
                     else:
                         schedule_info["shift_incidents"] = None
             else:
@@ -1369,18 +1818,21 @@ def create_rootly_mcp_server(
                 "schedules": handoff_data,
                 "summary": {
                     "total_schedules": len(handoff_data),
-                    "schedules_with_current_oncall": sum(1 for s in handoff_data if s["current_oncall"]),
+                    "schedules_with_current_oncall": sum(
+                        1 for s in handoff_data if s["current_oncall"]
+                    ),
                     "schedules_with_next_oncall": sum(1 for s in handoff_data if s["next_oncall"]),
                     "total_incidents": sum(
                         s.get("shift_incidents", {}).get("summary", {}).get("total_incidents", 0)
                         for s in handoff_data
                         if s.get("shift_incidents")
-                    )
-                }
+                    ),
+                },
             }
 
         except Exception as e:
             import traceback
+
             error_type, error_message = MCPError.categorize_error(e)
             return MCPError.tool_error(
                 f"Failed to get on-call handoff summary: {error_message}",
@@ -1388,8 +1840,8 @@ def create_rootly_mcp_server(
                 details={
                     "exception_type": type(e).__name__,
                     "exception_str": str(e),
-                    "traceback": traceback.format_exc()
-                }
+                    "traceback": traceback.format_exc(),
+                },
             )
 
     async def _fetch_shift_incidents_internal(
@@ -1398,7 +1850,7 @@ def create_rootly_mcp_server(
         schedule_ids: str = "",
         severity: str = "",
         status: str = "",
-        tags: str = ""
+        tags: str = "",
     ) -> dict:
         """Internal helper to fetch incidents - used by both get_shift_incidents and get_oncall_handoff_summary."""
         try:
@@ -1408,10 +1860,7 @@ def create_rootly_mcp_server(
             # Fetch incidents that:
             # 1. Were created during the shift (created_at in range)
             # 2. OR are currently active/unresolved (started but not resolved yet)
-            params = {
-                "page[size]": 100,
-                "sort": "-created_at"
-            }
+            params = {"page[size]": 100, "sort": "-created_at"}
 
             # Get incidents created during shift OR still active
             # We'll fetch all incidents and filter in-memory for active ones
@@ -1438,16 +1887,23 @@ def create_rootly_mcp_server(
 
             while page <= max_pages:
                 params["page[number]"] = page
-                incidents_response = await make_authenticated_request("GET", "/v1/incidents", params=params)
+                incidents_response = await make_authenticated_request(
+                    "GET", "/v1/incidents", params=params
+                )
 
                 if not incidents_response:
-                    return MCPError.tool_error("Failed to fetch incidents - no response from API", "execution_error")
+                    return MCPError.tool_error(
+                        "Failed to fetch incidents - no response from API", "execution_error"
+                    )
 
                 if incidents_response.status_code != 200:
                     return MCPError.tool_error(
                         f"Failed to fetch incidents - API returned status {incidents_response.status_code}",
                         "execution_error",
-                        details={"status_code": incidents_response.status_code, "time_range": f"{start_time} to {end_time}"}
+                        details={
+                            "status_code": incidents_response.status_code,
+                            "time_range": f"{start_time} to {end_time}",
+                        },
                     )
 
                 incidents_data = incidents_response.json()
@@ -1471,6 +1927,7 @@ def create_rootly_mcp_server(
             # 1. Created during shift (created_at between start_time and end_time)
             # 2. Currently active (started but not resolved, regardless of when created)
             from datetime import timezone as dt_timezone
+
             shift_start_dt = datetime.fromisoformat(start_time.replace("Z", "+00:00"))
             shift_end_dt = datetime.fromisoformat(end_time.replace("Z", "+00:00"))
             now_dt = datetime.now(dt_timezone.utc)
@@ -1488,9 +1945,21 @@ def create_rootly_mcp_server(
 
                 # Parse timestamps
                 try:
-                    created_dt = datetime.fromisoformat(created_at.replace("Z", "+00:00")) if created_at else None
-                    started_dt = datetime.fromisoformat(started_at.replace("Z", "+00:00")) if started_at else None
-                    resolved_dt = datetime.fromisoformat(resolved_at.replace("Z", "+00:00")) if resolved_at else None
+                    created_dt = (
+                        datetime.fromisoformat(created_at.replace("Z", "+00:00"))
+                        if created_at
+                        else None
+                    )
+                    started_dt = (
+                        datetime.fromisoformat(started_at.replace("Z", "+00:00"))
+                        if started_at
+                        else None
+                    )
+                    resolved_dt = (
+                        datetime.fromisoformat(resolved_at.replace("Z", "+00:00"))
+                        if resolved_at
+                        else None
+                    )
                 except (ValueError, AttributeError):
                     continue  # Skip if we can't parse dates
 
@@ -1551,24 +2020,28 @@ def create_rootly_mcp_server(
                 if attrs.get("mitigation"):
                     narrative_parts.append(f"Resolution: {attrs.get('mitigation')}")
                 elif attrs.get("action_items_count") and attrs.get("action_items_count") > 0:
-                    narrative_parts.append(f"Action items created: {attrs.get('action_items_count')}")
+                    narrative_parts.append(
+                        f"Action items created: {attrs.get('action_items_count')}"
+                    )
 
                 narrative = " | ".join(narrative_parts)
 
-                incidents_summary.append({
-                    "incident_id": incident_id,
-                    "title": attrs.get("title", "Untitled Incident"),
-                    "severity": attrs.get("severity"),
-                    "status": attrs.get("status"),
-                    "started_at": started_at,
-                    "resolved_at": resolved_at,
-                    "duration_minutes": duration_minutes,
-                    "summary": attrs.get("summary"),
-                    "impact": attrs.get("customer_impact_summary"),
-                    "mitigation": attrs.get("mitigation"),
-                    "narrative": narrative,
-                    "incident_url": attrs.get("incident_url")
-                })
+                incidents_summary.append(
+                    {
+                        "incident_id": incident_id,
+                        "title": attrs.get("title", "Untitled Incident"),
+                        "severity": attrs.get("severity"),
+                        "status": attrs.get("status"),
+                        "started_at": started_at,
+                        "resolved_at": resolved_at,
+                        "duration_minutes": duration_minutes,
+                        "summary": attrs.get("summary"),
+                        "impact": attrs.get("customer_impact_summary"),
+                        "mitigation": attrs.get("mitigation"),
+                        "narrative": narrative,
+                        "incident_url": attrs.get("incident_url"),
+                    }
+                )
 
             # Group by severity
             by_severity = {}
@@ -1584,28 +2057,28 @@ def create_rootly_mcp_server(
             ongoing_count = total_incidents - resolved_count
 
             avg_resolution_time = None
-            durations = [inc["duration_minutes"] for inc in incidents_summary if inc["duration_minutes"]]
+            durations = [
+                inc["duration_minutes"] for inc in incidents_summary if inc["duration_minutes"]
+            ]
             if durations:
                 avg_resolution_time = int(sum(durations) / len(durations))
 
             return {
                 "success": True,
-                "period": {
-                    "start_time": start_time,
-                    "end_time": end_time
-                },
+                "period": {"start_time": start_time, "end_time": end_time},
                 "summary": {
                     "total_incidents": total_incidents,
                     "resolved": resolved_count,
                     "ongoing": ongoing_count,
                     "average_resolution_minutes": avg_resolution_time,
-                    "by_severity": {k: len(v) for k, v in by_severity.items()}
+                    "by_severity": {k: len(v) for k, v in by_severity.items()},
                 },
-                "incidents": incidents_summary
+                "incidents": incidents_summary,
             }
 
         except Exception as e:
             import traceback
+
             error_type, error_message = MCPError.categorize_error(e)
             return MCPError.tool_error(
                 f"Failed to get shift incidents: {error_message}",
@@ -1614,18 +2087,44 @@ def create_rootly_mcp_server(
                     "params": {"start_time": start_time, "end_time": end_time},
                     "exception_type": type(e).__name__,
                     "exception_str": str(e),
-                    "traceback": traceback.format_exc()
-                }
+                    "traceback": traceback.format_exc(),
+                },
             )
 
     @mcp.tool()
     async def get_shift_incidents(
-        start_time: Annotated[str, Field(description="Start time for incident search (ISO 8601 format, e.g., '2025-10-01T00:00:00Z')")],
-        end_time: Annotated[str, Field(description="End time for incident search (ISO 8601 format, e.g., '2025-10-01T23:59:59Z')")],
-        schedule_ids: Annotated[str, Field(description="Comma-separated list of schedule IDs to filter incidents (optional)")] = "",
-        severity: Annotated[str, Field(description="Filter by severity: 'critical', 'high', 'medium', 'low' (optional)")] = "",
-        status: Annotated[str, Field(description="Filter by status: 'started', 'detected', 'acknowledged', 'investigating', 'identified', 'monitoring', 'resolved', 'cancelled' (optional)")] = "",
-        tags: Annotated[str, Field(description="Comma-separated list of tag slugs to filter incidents (optional)")] = ""
+        start_time: Annotated[
+            str,
+            Field(
+                description="Start time for incident search (ISO 8601 format, e.g., '2025-10-01T00:00:00Z')"
+            ),
+        ],
+        end_time: Annotated[
+            str,
+            Field(
+                description="End time for incident search (ISO 8601 format, e.g., '2025-10-01T23:59:59Z')"
+            ),
+        ],
+        schedule_ids: Annotated[
+            str,
+            Field(
+                description="Comma-separated list of schedule IDs to filter incidents (optional)"
+            ),
+        ] = "",
+        severity: Annotated[
+            str,
+            Field(description="Filter by severity: 'critical', 'high', 'medium', 'low' (optional)"),
+        ] = "",
+        status: Annotated[
+            str,
+            Field(
+                description="Filter by status: 'started', 'detected', 'acknowledged', 'investigating', 'identified', 'monitoring', 'resolved', 'cancelled' (optional)"
+            ),
+        ] = "",
+        tags: Annotated[
+            str,
+            Field(description="Comma-separated list of tag slugs to filter incidents (optional)"),
+        ] = "",
     ) -> dict:
         """
         Get incidents and alerts that occurred during a specific shift or time period.
@@ -1638,7 +2137,9 @@ def create_rootly_mcp_server(
 
         Returns incident details including severity, status, duration, and basic summary.
         """
-        return await _fetch_shift_incidents_internal(start_time, end_time, schedule_ids, severity, status, tags)
+        return await _fetch_shift_incidents_internal(
+            start_time, end_time, schedule_ids, severity, status, tags
+        )
 
     # Add MCP resources for incidents and teams
     @mcp.resource("incident://{incident_id}")
@@ -1647,26 +2148,26 @@ def create_rootly_mcp_server(
         try:
             response = await make_authenticated_request("GET", f"/v1/incidents/{incident_id}")
             response.raise_for_status()
-            incident_data = response.json()
-            
+            incident_data = strip_heavy_nested_data({"data": [response.json().get("data", {})]})
+
             # Format incident data as readable text
-            incident = incident_data.get("data", {})
+            incident = incident_data.get("data", [{}])[0]
             attributes = incident.get("attributes", {})
-            
+
             text_content = f"""Incident #{incident_id}
-Title: {attributes.get('title', 'N/A')}
-Status: {attributes.get('status', 'N/A')}  
-Severity: {attributes.get('severity', 'N/A')}
-Created: {attributes.get('created_at', 'N/A')}
-Updated: {attributes.get('updated_at', 'N/A')}
-Summary: {attributes.get('summary', 'N/A')}
-URL: {attributes.get('url', 'N/A')}"""
-            
+Title: {attributes.get("title", "N/A")}
+Status: {attributes.get("status", "N/A")}
+Severity: {attributes.get("severity", "N/A")}
+Created: {attributes.get("created_at", "N/A")}
+Updated: {attributes.get("updated_at", "N/A")}
+Summary: {attributes.get("summary", "N/A")}
+URL: {attributes.get("url", "N/A")}"""
+
             return {
                 "uri": f"incident://{incident_id}",
                 "name": f"Incident #{incident_id}",
                 "text": text_content,
-                "mimeType": "text/plain"
+                "mimeType": "text/plain",
             }
         except Exception as e:
             error_type, error_message = MCPError.categorize_error(e)
@@ -1674,7 +2175,7 @@ URL: {attributes.get('url', 'N/A')}"""
                 "uri": f"incident://{incident_id}",
                 "name": f"Incident #{incident_id} (Error)",
                 "text": f"Error ({error_type}): {error_message}",
-                "mimeType": "text/plain"
+                "mimeType": "text/plain",
             }
 
     @mcp.resource("team://{team_id}")
@@ -1684,23 +2185,23 @@ URL: {attributes.get('url', 'N/A')}"""
             response = await make_authenticated_request("GET", f"/v1/teams/{team_id}")
             response.raise_for_status()
             team_data = response.json()
-            
+
             # Format team data as readable text
             team = team_data.get("data", {})
             attributes = team.get("attributes", {})
-            
+
             text_content = f"""Team #{team_id}
-Name: {attributes.get('name', 'N/A')}
-Color: {attributes.get('color', 'N/A')}
-Slug: {attributes.get('slug', 'N/A')}
-Created: {attributes.get('created_at', 'N/A')}
-Updated: {attributes.get('updated_at', 'N/A')}"""
-            
+Name: {attributes.get("name", "N/A")}
+Color: {attributes.get("color", "N/A")}
+Slug: {attributes.get("slug", "N/A")}
+Created: {attributes.get("created_at", "N/A")}
+Updated: {attributes.get("updated_at", "N/A")}"""
+
             return {
                 "uri": f"team://{team_id}",
                 "name": f"Team: {attributes.get('name', team_id)}",
                 "text": text_content,
-                "mimeType": "text/plain"
+                "mimeType": "text/plain",
             }
         except Exception as e:
             error_type, error_message = MCPError.categorize_error(e)
@@ -1708,50 +2209,56 @@ Updated: {attributes.get('updated_at', 'N/A')}"""
                 "uri": f"team://{team_id}",
                 "name": f"Team #{team_id} (Error)",
                 "text": f"Error ({error_type}): {error_message}",
-                "mimeType": "text/plain"
+                "mimeType": "text/plain",
             }
 
     @mcp.resource("rootly://incidents")
     async def list_incidents_resource():
         """List recent incidents as an MCP resource for quick reference."""
         try:
-            response = await make_authenticated_request("GET", "/v1/incidents", params={
-                "page[size]": 10,
-                "page[number]": 1,
-                "include": ""
-            })
+            response = await make_authenticated_request(
+                "GET",
+                "/v1/incidents",
+                params={
+                    "page[size]": 10,
+                    "page[number]": 1,
+                    "include": "",
+                    "fields[incidents]": "id,title,status",
+                },
+            )
             response.raise_for_status()
-            data = response.json()
-            
+            data = strip_heavy_nested_data(response.json())
+
             incidents = data.get("data", [])
             text_lines = ["Recent Incidents:\n"]
-            
+
             for incident in incidents:
                 attrs = incident.get("attributes", {})
-                text_lines.append(f"• #{incident.get('id', 'N/A')} - {attrs.get('title', 'N/A')} [{attrs.get('status', 'N/A')}]")
-            
+                text_lines.append(
+                    f"• #{incident.get('id', 'N/A')} - {attrs.get('title', 'N/A')} [{attrs.get('status', 'N/A')}]"
+                )
+
             return {
                 "uri": "rootly://incidents",
                 "name": "Recent Incidents",
                 "text": "\n".join(text_lines),
-                "mimeType": "text/plain"
+                "mimeType": "text/plain",
             }
         except Exception as e:
             error_type, error_message = MCPError.categorize_error(e)
             return {
-                "uri": "rootly://incidents", 
+                "uri": "rootly://incidents",
                 "name": "Recent Incidents (Error)",
                 "text": f"Error ({error_type}): {error_message}",
-                "mimeType": "text/plain"
+                "mimeType": "text/plain",
             }
 
-
     # Log server creation (tool count will be shown when tools are accessed)
     logger.info("Created Rootly MCP Server successfully")
     return mcp
 
 
-def _load_swagger_spec(swagger_path: Optional[str] = None) -> Dict[str, Any]:
+def _load_swagger_spec(swagger_path: str | None = None) -> dict[str, Any]:
     """
     Load the Swagger specification from a file or URL.
 
@@ -1766,7 +2273,7 @@ def _load_swagger_spec(swagger_path: Optional[str] = None) -> Dict[str, Any]:
         logger.info(f"Using provided Swagger path: {swagger_path}")
         if not os.path.isfile(swagger_path):
             raise FileNotFoundError(f"Swagger file not found at {swagger_path}")
-        with open(swagger_path, "r", encoding="utf-8") as f:
+        with open(swagger_path, encoding="utf-8") as f:
             return json.load(f)
     else:
         # First, check in the package data directory
@@ -1774,7 +2281,7 @@ def _load_swagger_spec(swagger_path: Optional[str] = None) -> Dict[str, Any]:
             package_data_path = Path(__file__).parent / "data" / "swagger.json"
             if package_data_path.is_file():
                 logger.info(f"Found Swagger file in package data: {package_data_path}")
-                with open(package_data_path, "r", encoding="utf-8") as f:
+                with open(package_data_path, encoding="utf-8") as f:
                     return json.load(f)
         except Exception as e:
             logger.debug(f"Could not load Swagger file from package data: {e}")
@@ -1787,7 +2294,7 @@ def _load_swagger_spec(swagger_path: Optional[str] = None) -> Dict[str, Any]:
         local_swagger_path = current_dir / "swagger.json"
         if local_swagger_path.is_file():
             logger.info(f"Found Swagger file at {local_swagger_path}")
-            with open(local_swagger_path, "r", encoding="utf-8") as f:
+            with open(local_swagger_path, encoding="utf-8") as f:
                 return json.load(f)
 
         # Check parent directories
@@ -1795,7 +2302,7 @@ def _load_swagger_spec(swagger_path: Optional[str] = None) -> Dict[str, Any]:
             parent_swagger_path = parent / "swagger.json"
             if parent_swagger_path.is_file():
                 logger.info(f"Found Swagger file at {parent_swagger_path}")
-                with open(parent_swagger_path, "r", encoding="utf-8") as f:
+                with open(parent_swagger_path, encoding="utf-8") as f:
                     return json.load(f)
 
         # If the file wasn't found, fetch it from the URL and save it
@@ -1815,7 +2322,7 @@ def _load_swagger_spec(swagger_path: Optional[str] = None) -> Dict[str, Any]:
         return swagger_spec
 
 
-def _fetch_swagger_from_url(url: str = SWAGGER_URL) -> Dict[str, Any]:
+def _fetch_swagger_from_url(url: str = SWAGGER_URL) -> dict[str, Any]:
     """
     Fetch the Swagger specification from the specified URL.
 
@@ -1827,7 +2334,7 @@ def _fetch_swagger_from_url(url: str = SWAGGER_URL) -> Dict[str, Any]:
     """
     logger.info(f"Fetching Swagger specification from {url}")
     try:
-        response = requests.get(url)
+        response = requests.get(url, timeout=30)
         response.raise_for_status()
         return response.json()
     except requests.RequestException as e:
@@ -1838,7 +2345,7 @@ def _fetch_swagger_from_url(url: str = SWAGGER_URL) -> Dict[str, Any]:
         raise Exception(f"Failed to parse Swagger specification: {e}")
 
 
-def _filter_openapi_spec(spec: Dict[str, Any], allowed_paths: List[str]) -> Dict[str, Any]:
+def _filter_openapi_spec(spec: dict[str, Any], allowed_paths: list[str]) -> dict[str, Any]:
     """
     Filter an OpenAPI specification to only include specified paths and clean up schema references.
 
@@ -1855,9 +2362,7 @@ def _filter_openapi_spec(spec: Dict[str, Any], allowed_paths: List[str]) -> Dict
     # Filter 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
+        path: path_item for path, path_item in original_paths.items() if path in allowed_paths
     }
 
     filtered_spec["paths"] = filtered_paths
@@ -1873,7 +2378,7 @@ def _filter_openapi_spec(spec: Dict[str, Any], allowed_paths: List[str]) -> Dict
             if "requestBody" in operation:
                 request_body = operation["requestBody"]
                 if "content" in request_body:
-                    for content_type, content_info in request_body["content"].items():
+                    for _content_type, content_info in request_body["content"].items():
                         if "schema" in content_info:
                             schema = content_info["schema"]
                             # Remove problematic $ref references
@@ -1882,20 +2387,20 @@ def _filter_openapi_spec(spec: Dict[str, Any], allowed_paths: List[str]) -> Dict
                                 content_info["schema"] = {
                                     "type": "object",
                                     "description": "Request parameters for this endpoint",
-                                    "additionalProperties": True
+                                    "additionalProperties": True,
                                 }
 
             # 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():
+                for _status_code, response in operation["responses"].items():
                     if "content" in response:
-                        for content_type, content_info in response["content"].items():
+                        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
+                                    "additionalProperties": True,
                                 }
 
             # Clean parameter schemas (parameter names are already sanitized)
@@ -1907,135 +2412,155 @@ def _filter_openapi_spec(spec: Dict[str, Any], allowed_paths: List[str]) -> Dict
                             # Replace with a simple string schema
                             param["schema"] = {
                                 "type": "string",
-                                "description": param.get("description", "Parameter value")
+                                "description": param.get("description", "Parameter value"),
                             }
 
             # Add/modify pagination limits to alerts and incident-related endpoints to prevent infinite loops
             if method.lower() == "get" and ("alerts" in path.lower() or "incident" in path.lower()):
                 if "parameters" not in operation:
                     operation["parameters"] = []
-                
+
                 # Find existing pagination parameters and update them with limits
                 page_size_param = None
                 page_number_param = None
-                
+
                 for param in operation["parameters"]:
                     if param.get("name") == "page[size]":
                         page_size_param = param
                     elif param.get("name") == "page[number]":
                         page_number_param = param
-                
+
                 # Update or add page[size] parameter with limits
                 if page_size_param:
                     # Update existing parameter with limits
                     if "schema" not in page_size_param:
                         page_size_param["schema"] = {}
-                    page_size_param["schema"].update({
-                        "type": "integer",
-                        "default": 10,
-                        "minimum": 1,
-                        "maximum": 20,
-                        "description": "Number of results per page (max: 20)"
-                    })
-                else:
-                    # Add new parameter
-                    operation["parameters"].append({
-                        "name": "page[size]",
-                        "in": "query",
-                        "required": False,
-                        "schema": {
+                    page_size_param["schema"].update(
+                        {
                             "type": "integer",
                             "default": 10,
                             "minimum": 1,
                             "maximum": 20,
-                            "description": "Number of results per page (max: 20)"
+                            "description": "Number of results per page (max: 20)",
                         }
-                    })
-                
+                    )
+                else:
+                    # Add new parameter
+                    operation["parameters"].append(
+                        {
+                            "name": "page[size]",
+                            "in": "query",
+                            "required": False,
+                            "schema": {
+                                "type": "integer",
+                                "default": 10,
+                                "minimum": 1,
+                                "maximum": 20,
+                                "description": "Number of results per page (max: 20)",
+                            },
+                        }
+                    )
+
                 # Update or add page[number] parameter with defaults
                 if page_number_param:
-                    # Update existing parameter 
+                    # Update existing parameter
                     if "schema" not in page_number_param:
                         page_number_param["schema"] = {}
-                    page_number_param["schema"].update({
-                        "type": "integer",
-                        "default": 1,
-                        "minimum": 1,
-                        "description": "Page number to retrieve"
-                    })
-                else:
-                    # Add new parameter
-                    operation["parameters"].append({
-                        "name": "page[number]",
-                        "in": "query", 
-                        "required": False,
-                        "schema": {
+                    page_number_param["schema"].update(
+                        {
                             "type": "integer",
                             "default": 1,
                             "minimum": 1,
-                            "description": "Page number to retrieve"
+                            "description": "Page number to retrieve",
+                        }
+                    )
+                else:
+                    # Add new parameter
+                    operation["parameters"].append(
+                        {
+                            "name": "page[number]",
+                            "in": "query",
+                            "required": False,
+                            "schema": {
+                                "type": "integer",
+                                "default": 1,
+                                "minimum": 1,
+                                "description": "Page number to retrieve",
+                            },
                         }
-                    })
-                
+                    )
+
                 # Add sparse fieldsets for alerts endpoints to reduce payload size
                 if "alert" in path.lower():
                     # Add fields[alerts] parameter with essential fields only - make it required with default
-                    operation["parameters"].append({
-                        "name": "fields[alerts]",
-                        "in": "query",
-                        "required": True,
-                        "schema": {
-                            "type": "string",
-                            "default": "id,summary,status,started_at,ended_at,short_id,alert_urgency_id,source,noise",
-                            "description": "Comma-separated list of alert fields to include (reduces payload size)"
+                    operation["parameters"].append(
+                        {
+                            "name": "fields[alerts]",
+                            "in": "query",
+                            "required": True,
+                            "schema": {
+                                "type": "string",
+                                "default": "id,summary,status,started_at,ended_at,short_id,alert_urgency_id,source,noise",
+                                "description": "Comma-separated list of alert fields to include (reduces payload size)",
+                            },
                         }
-                    })
-                
+                    )
+
                 # Add include parameter for alerts endpoints to minimize relationships
                 if "alert" in path.lower():
                     # Check if include parameter already exists
-                    include_param_exists = any(param.get("name") == "include" for param in operation["parameters"])
+                    include_param_exists = any(
+                        param.get("name") == "include" for param in operation["parameters"]
+                    )
                     if not include_param_exists:
-                        operation["parameters"].append({
-                            "name": "include",
-                            "in": "query",
-                            "required": True,
-                            "schema": {
-                                "type": "string",
-                                "default": "",
-                                "description": "Related resources to include (empty for minimal payload)"
+                        operation["parameters"].append(
+                            {
+                                "name": "include",
+                                "in": "query",
+                                "required": True,
+                                "schema": {
+                                    "type": "string",
+                                    "default": "",
+                                    "description": "Related resources to include (empty for minimal payload)",
+                                },
                             }
-                        })
-                
+                        )
+
                 # Add sparse fieldsets for incidents endpoints to reduce payload size
                 if "incident" in path.lower():
                     # Add fields[incidents] parameter with essential fields only - make it required with default
-                    operation["parameters"].append({
-                        "name": "fields[incidents]", 
-                        "in": "query",
-                        "required": True,
-                        "schema": {
-                            "type": "string",
-                            "default": "id,title,summary,status,severity,created_at,updated_at,url,started_at",
-                            "description": "Comma-separated list of incident fields to include (reduces payload size)"
+                    operation["parameters"].append(
+                        {
+                            "name": "fields[incidents]",
+                            "in": "query",
+                            "required": True,
+                            "schema": {
+                                "type": "string",
+                                "default": "id,title,summary,status,severity,created_at,updated_at,url,started_at",
+                                "description": "Comma-separated list of incident fields to include (reduces payload size)",
+                            },
                         }
-                    })
-                
+                    )
+
                 # Add include parameter for incidents endpoints to minimize relationships
                 if "incident" in path.lower():
                     # Check if include parameter already exists
-                    include_param_exists = any(param.get("name") == "include" for param in operation["parameters"])
+                    include_param_exists = any(
+                        param.get("name") == "include" for param in operation["parameters"]
+                    )
                     if not include_param_exists:
-                        operation["parameters"].append({
-                            "name": "include",
-                            "in": "query",
-                            "required": True,
-                            "schema": {
-                                "type": "string", 
-                                "default": "",
-                                "description": "Related resources to include (empty for minimal payload)"
+                        operation["parameters"].append(
+                            {
+                                "name": "include",
+                                "in": "query",
+                                "required": True,
+                                "schema": {
+                                    "type": "string",
+                                    "default": "",
+                                    "description": "Related resources to include (empty for minimal payload)",
+                                },
                             }
-                        })
+                        )
 
     # Also clean up any remaining broken references in components
     if "components" in filtered_spec and "schemas" in filtered_spec["components"]:
@@ -2053,20 +2578,29 @@ def _filter_openapi_spec(spec: Dict[str, Any], allowed_paths: List[str]) -> Dict
     # Clean up any operation-level references to removed schemas
     removed_schemas = set()
     if "components" in filtered_spec and "schemas" in filtered_spec["components"]:
-        removed_schemas = {"new_workflow", "update_workflow", "workflow", "workflow_task", 
-                          "workflow_response", "workflow_list", "new_workflow_task", 
-                          "update_workflow_task", "workflow_task_response", "workflow_task_list"}
-    
+        removed_schemas = {
+            "new_workflow",
+            "update_workflow",
+            "workflow",
+            "workflow_task",
+            "workflow_response",
+            "workflow_list",
+            "new_workflow_task",
+            "update_workflow_task",
+            "workflow_task_response",
+            "workflow_task_list",
+        }
+
     for path, path_item in filtered_spec.get("paths", {}).items():
         for method, operation in path_item.items():
             if method.lower() not in ["get", "post", "put", "delete", "patch"]:
                 continue
-                
+
             # Clean request body references
             if "requestBody" in operation:
                 request_body = operation["requestBody"]
                 if "content" in request_body:
-                    for content_type, content_info in request_body["content"].items():
+                    for _content_type, content_info in request_body["content"].items():
                         if "schema" in content_info and "$ref" in content_info["schema"]:
                             ref_path = content_info["schema"]["$ref"]
                             schema_name = ref_path.split("/")[-1]
@@ -2075,15 +2609,17 @@ def _filter_openapi_spec(spec: Dict[str, Any], allowed_paths: List[str]) -> Dict
                                 content_info["schema"] = {
                                     "type": "object",
                                     "description": "Request data for this endpoint",
-                                    "additionalProperties": True
+                                    "additionalProperties": True,
                                 }
-                                logger.debug(f"Cleaned broken reference in {method.upper()} {path} request body: {ref_path}")
-            
-            # Clean response references 
+                                logger.debug(
+                                    f"Cleaned broken reference in {method.upper()} {path} request body: {ref_path}"
+                                )
+
+            # Clean response references
             if "responses" in operation:
-                for status_code, response in operation["responses"].items():
+                for _status_code, response in operation["responses"].items():
                     if "content" in response:
-                        for content_type, content_info in response["content"].items():
+                        for _content_type, content_info in response["content"].items():
                             if "schema" in content_info and "$ref" in content_info["schema"]:
                                 ref_path = content_info["schema"]["$ref"]
                                 schema_name = ref_path.split("/")[-1]
@@ -2092,14 +2628,16 @@ def _filter_openapi_spec(spec: Dict[str, Any], allowed_paths: List[str]) -> Dict
                                     content_info["schema"] = {
                                         "type": "object",
                                         "description": "Response data from this endpoint",
-                                        "additionalProperties": True
+                                        "additionalProperties": True,
                                     }
-                                    logger.debug(f"Cleaned broken reference in {method.upper()} {path} response: {ref_path}")
+                                    logger.debug(
+                                        f"Cleaned broken reference in {method.upper()} {path} response: {ref_path}"
+                                    )
 
     return filtered_spec
 
 
-def _has_broken_references(schema_def: Dict[str, Any]) -> bool:
+def _has_broken_references(schema_def: dict[str, Any]) -> bool:
     """Check if a schema definition has broken references."""
     if "$ref" in schema_def:
         ref_path = schema_def["$ref"]
@@ -2107,7 +2645,7 @@ def _has_broken_references(schema_def: Dict[str, Any]) -> bool:
         broken_refs = [
             "incident_trigger_params",
             "new_workflow",
-            "update_workflow", 
+            "update_workflow",
             "workflow",
             "new_workflow_task",
             "update_workflow_task",
@@ -2118,18 +2656,18 @@ def _has_broken_references(schema_def: Dict[str, Any]) -> bool:
             "workflow_list",
             "workflow_custom_field_selection_response",
             "workflow_custom_field_selection_list",
-            "workflow_form_field_condition_response", 
+            "workflow_form_field_condition_response",
             "workflow_form_field_condition_list",
             "workflow_group_response",
             "workflow_group_list",
             "workflow_run_response",
-            "workflow_runs_list"
+            "workflow_runs_list",
         ]
         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():
+    for _key, value in schema_def.items():
         if isinstance(value, dict):
             if _has_broken_references(value):
                 return True
@@ -2151,10 +2689,10 @@ class RootlyMCPServer(FastMCP):
 
     def __init__(
         self,
-        swagger_path: Optional[str] = None,
+        swagger_path: str | None = None,
         name: str = "Rootly",
         default_page_size: int = 10,
-        allowed_paths: Optional[List[str]] = None,
+        allowed_paths: list[str] | None = None,
         hosted: bool = False,
         *args,
         **kwargs,
@@ -2165,10 +2703,7 @@ class RootlyMCPServer(FastMCP):
 
         # Create the server using the new function
         server = create_rootly_mcp_server(
-            swagger_path=swagger_path,
-            name=name,
-            allowed_paths=allowed_paths,
-            hosted=hosted
+            swagger_path=swagger_path, name=name, allowed_paths=allowed_paths, hosted=hosted
         )
 
         # Copy the server's state to this instance
@@ -2177,5 +2712,5 @@ class RootlyMCPServer(FastMCP):
         # Tools will be accessed via async methods when needed
         self._server = server
         self._tools = {}  # Placeholder - tools should be accessed via async methods
-        self._resources = getattr(server, '_resources', {})
-        self._prompts = getattr(server, '_prompts', {})
+        self._resources = getattr(server, "_resources", {})
+        self._prompts = getattr(server, "_prompts", {})