rootly-mcp-server 2.2.11__tar.gz → 2.2.12__tar.gz

{rootly_mcp_server-2.2.11 → rootly_mcp_server-2.2.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rootly-mcp-server
-Version: 2.2.11
+Version: 2.2.12
 Summary: Secure Model Context Protocol server for Rootly APIs with AI SRE capabilities, comprehensive error handling, and input validation
 Project-URL: Homepage, https://github.com/Rootly-AI-Labs/Rootly-MCP-server
 Project-URL: Issues, https://github.com/Rootly-AI-Labs/Rootly-MCP-server/issues
@@ -55,6 +55,8 @@ The fastest way to get started is to connect to our hosted MCP server — no ins
 
 ### Claude Code
 
+**Hosted Server (Recommended)**
+
 ```bash
 claude mcp add --transport http rootly https://mcp.rootly.com/mcp \
   --header "Authorization: Bearer YOUR_ROOTLY_API_TOKEN"
@@ -74,6 +76,26 @@ claude mcp add --transport sse rootly-sse https://mcp.rootly.com/sse \
   --header "Authorization: Bearer YOUR_ROOTLY_API_TOKEN"
 ```
 
+**Manual Configuration**
+
+Alternatively, create `.mcp.json` in your project root:
+
+```json
+{
+  "mcpServers": {
+    "rootly": {
+      "type": "sse",
+      "url": "https://mcp.rootly.com/sse",
+      "headers": {
+        "Authorization": "Bearer YOUR_ROOTLY_API_TOKEN"
+      }
+    }
+  }
+}
+```
+
+Then restart Claude Code so it reloads the updated configuration.
+
 ### Gemini CLI
 
 Install the extension:

{rootly_mcp_server-2.2.11 → rootly_mcp_server-2.2.12}/README.md

@@ -16,6 +16,8 @@ The fastest way to get started is to connect to our hosted MCP server — no ins
 
 ### Claude Code
 
+**Hosted Server (Recommended)**
+
 ```bash
 claude mcp add --transport http rootly https://mcp.rootly.com/mcp \
   --header "Authorization: Bearer YOUR_ROOTLY_API_TOKEN"
@@ -35,6 +37,26 @@ claude mcp add --transport sse rootly-sse https://mcp.rootly.com/sse \
   --header "Authorization: Bearer YOUR_ROOTLY_API_TOKEN"
 ```
 
+**Manual Configuration**
+
+Alternatively, create `.mcp.json` in your project root:
+
+```json
+{
+  "mcpServers": {
+    "rootly": {
+      "type": "sse",
+      "url": "https://mcp.rootly.com/sse",
+      "headers": {
+        "Authorization": "Bearer YOUR_ROOTLY_API_TOKEN"
+      }
+    }
+  }
+}
+```
+
+Then restart Claude Code so it reloads the updated configuration.
+
 ### Gemini CLI
 
 Install the extension:

{rootly_mcp_server-2.2.11 → rootly_mcp_server-2.2.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rootly-mcp-server"
-version = "2.2.11"
+version = "2.2.12"
 description = "Secure Model Context Protocol server for Rootly APIs with AI SRE capabilities, comprehensive error handling, and input validation"
 readme = "README.md"
 requires-python = ">=3.12"

{rootly_mcp_server-2.2.11 → rootly_mcp_server-2.2.12}/src/rootly_mcp_server/code_mode.py

@@ -127,15 +127,20 @@ def build_code_mode_transform() -> CodeMode:
         sandbox_provider=CompatibleMontySandboxProvider(),
         discovery_tools=[
             ListTools(default_detail="brief"),
-            Search(default_detail="detailed", default_limit=12),
+            Search(name="tool_search", default_detail="detailed", default_limit=12),
             GetSchemas(default_detail="detailed"),
             GetTags(default_detail="brief"),
         ],
         execute_description=(
             "Write a short async Python block and chain await call_tool(name, params) calls "
-            "to complete a Rootly workflow. Prefer Rootly's higher-level custom tools when "
-            "they fit the task, then fall back to lower-level API tools as needed. Use return "
-            "to emit the final result."
+            "to complete a Rootly workflow. Use tool_search only to discover tools and their "
+            "schemas, then call the actual Rootly tool with the exact parameter names shown in "
+            "the schema. For paginated data tools, pass pagination arguments like page_size, "
+            "page_number, and max_results exactly as documented by that tool instead of inventing "
+            "alternatives like per_page. Prefer Rootly's higher-level custom tools when they fit "
+            "the task, then fall back to lower-level API tools as needed. Example: "
+            "await call_tool('search_incidents', {'query': '', 'page_size': 1, 'page_number': 1, "
+            "'max_results': 1}). Use return to emit the final result."
         ),
     )
 

{rootly_mcp_server-2.2.11 → rootly_mcp_server-2.2.12}/src/rootly_mcp_server/tools/oncall.py

@@ -12,9 +12,33 @@ import httpx
 from pydantic import Field
 
 from ..och_client import OnCallHealthClient
+from ..validators import validate_page_params
 
 JsonDict = dict[str, Any]
 MakeAuthenticatedRequest = Callable[..., Awaitable[Any]]
+SHIFT_INCIDENT_QUERY_FIELDS = (
+    "title,status,started_at,resolved_at,created_at,summary,"
+    "customer_impact_summary,mitigation,severity,url"
+)
+DEFAULT_MAX_SHIFT_INCIDENT_RESULTS = 100
+
+
+def _truncate_text(value: Any, max_length: int = 280) -> str | None:
+    """Keep large narrative fields compact enough for MCP clients."""
+    if not value:
+        return None
+
+    if not isinstance(value, str):
+        value = str(value)
+
+    value = value.strip()
+    if not value:
+        return None
+
+    if len(value) <= max_length:
+        return value
+
+    return f"{value[: max_length - 1].rstrip()}…"
 
 
 def _normalize_incident_severity(severity: Any) -> str:
@@ -820,6 +844,8 @@ def register_oncall_tools(
                             severity="",
                             status="",
                             tags="",
+                            include_preexisting_active=True,
+                            max_incidents=25,
                         )
 
                         schedule_info["shift_incidents"] = (
@@ -872,6 +898,9 @@ def register_oncall_tools(
         severity: str = "",
         status: str = "",
         tags: str = "",
+        *,
+        include_preexisting_active: bool = False,
+        max_incidents: int | None = None,
     ) -> dict:
         """Internal helper to fetch incidents - used by both get_shift_incidents and get_oncall_handoff_summary."""
         try:
@@ -881,10 +910,17 @@ def register_oncall_tools(
             # 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",
+                "fields[incidents]": SHIFT_INCIDENT_QUERY_FIELDS,
+            }
 
-            # Get incidents created during shift OR still active
-            # We'll fetch all incidents and filter in-memory for active ones
+            # Fetch incidents that started before the shift ended, then use
+            # in-memory filtering to keep incidents that were created, started,
+            # or resolved during the shift. We cannot safely apply a lower
+            # started_at bound here without dropping incidents that began
+            # before the shift and resolved during it.
             params["filter[started_at][lte]"] = end_time  # Started before shift ended
 
             # Add severity filter if provided
@@ -998,7 +1034,12 @@ def register_oncall_tools(
                 if resolved_dt and shift_start_dt <= resolved_dt <= shift_end_dt:
                     include_incident = True  # Resolved during shift
 
-                if not resolved_dt and started_dt and started_dt <= now_dt:
+                if (
+                    include_preexisting_active
+                    and not resolved_dt
+                    and started_dt
+                    and started_dt <= now_dt
+                ):
                     include_incident = True  # Currently active
 
                 if not include_incident:
@@ -1015,6 +1056,9 @@ def register_oncall_tools(
                 # What happened
                 title = attrs.get("title", "Untitled Incident")
                 severity = _normalize_incident_severity(attrs.get("severity"))
+                summary_text = _truncate_text(attrs.get("summary"))
+                impact_text = _truncate_text(attrs.get("customer_impact_summary"))
+                mitigation_text = _truncate_text(attrs.get("mitigation"))
                 narrative_parts.append(f"[{severity.upper()}] {title}")
 
                 # When and duration
@@ -1028,22 +1072,22 @@ def register_oncall_tools(
                     narrative_parts.append(f"Status: {attrs.get('status')}")
 
                 # What was the issue
-                if attrs.get("summary"):
-                    narrative_parts.append(f"Details: {attrs.get('summary')}")
+                if summary_text:
+                    narrative_parts.append(f"Details: {summary_text}")
 
                 # Impact
-                if attrs.get("customer_impact_summary"):
-                    narrative_parts.append(f"Impact: {attrs.get('customer_impact_summary')}")
+                if impact_text:
+                    narrative_parts.append(f"Impact: {impact_text}")
 
                 # Resolution (if available)
-                if attrs.get("mitigation"):
-                    narrative_parts.append(f"Resolution: {attrs.get('mitigation')}")
+                if mitigation_text:
+                    narrative_parts.append(f"Resolution: {mitigation_text}")
                 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 = " | ".join(narrative_parts)
+                narrative = _truncate_text(" | ".join(narrative_parts), max_length=400)
 
                 incidents_summary.append(
                     {
@@ -1054,11 +1098,11 @@ def register_oncall_tools(
                         "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"),
+                        "summary": summary_text,
+                        "impact": impact_text,
+                        "mitigation": mitigation_text,
                         "narrative": narrative,
-                        "incident_url": attrs.get("incident_url"),
+                        "incident_url": attrs.get("incident_url") or attrs.get("url"),
                     }
                 )
 
@@ -1082,6 +1126,12 @@ def register_oncall_tools(
             if durations:
                 avg_resolution_time = int(sum(durations) / len(durations))
 
+            returned_incidents = incidents_summary
+            truncated_count = 0
+            if max_incidents is not None and total_incidents > max_incidents:
+                returned_incidents = incidents_summary[:max_incidents]
+                truncated_count = total_incidents - max_incidents
+
             return {
                 "success": True,
                 "period": {"start_time": start_time, "end_time": end_time},
@@ -1092,7 +1142,10 @@ def register_oncall_tools(
                     "average_resolution_minutes": avg_resolution_time,
                     "by_severity": {k: len(v) for k, v in by_severity.items()},
                 },
-                "incidents": incidents_summary,
+                "incidents": returned_incidents,
+                "returned_incidents": len(returned_incidents),
+                "truncated_incidents": truncated_count,
+                "results_truncated": truncated_count > 0,
             }
 
         except Exception as e:
@@ -1157,7 +1210,14 @@ def register_oncall_tools(
         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
+            start_time,
+            end_time,
+            schedule_ids,
+            severity,
+            status,
+            tags,
+            include_preexisting_active=False,
+            max_incidents=DEFAULT_MAX_SHIFT_INCIDENT_RESULTS,
         )
 
     # Cache for lookup maps (TTL: 5 minutes)
@@ -1287,20 +1347,41 @@ def register_oncall_tools(
             bool,
             Field(description="Include user name and email in response (default: True)"),
         ] = True,
+        page_size: Annotated[
+            int,
+            Field(
+                description="Number of enriched shifts to return per page (max: 100). This paginates the MCP response even when the upstream shifts API does not."
+            ),
+        ] = 25,
+        page_number: Annotated[
+            int,
+            Field(
+                description="Page number of enriched shifts to return (1-indexed). Use this instead of relying on the generated listShifts pagination."
+            ),
+        ] = 1,
     ) -> dict:
         """
-        List on-call shifts with proper user filtering and enriched data.
+        List on-call shifts with reliable filtering, enrichment, and MCP-level pagination.
 
         Unlike the raw API, this tool:
         - Actually filters by user_ids (client-side filtering)
         - Includes user_name, user_email, schedule_name, team_name
         - Calculates total_hours for each shift
+        - Returns a predictable paginated result for MCP clients
 
-        Use this instead of the auto-generated listShifts when you need user filtering.
+        Use this instead of the auto-generated listShifts when you need user filtering
+        or dependable pagination on large tenants.
         """
         try:
             from datetime import datetime
 
+            page_size, page_number = validate_page_params(page_size, page_number)
+            if page_number == 0:
+                return mcp_error.tool_error(
+                    "page_number must be >= 1 for list_shifts",
+                    "validation_error",
+                    details={"page_number": page_number},
+                )
             # Build query parameters
             params: dict[str, Any] = {
                 "from": from_date,
@@ -1429,14 +1510,29 @@ def register_oncall_tools(
 
                 enriched_shifts.append(enriched_shift)
 
+            total_matching_shifts = len(enriched_shifts)
+            start_index = (page_number - 1) * page_size
+            end_index = start_index + page_size
+            paginated_shifts = enriched_shifts[start_index:end_index]
+            has_more = end_index < total_matching_shifts
+
             return {
                 "period": {"from": from_date, "to": to_date},
-                "total_shifts": len(enriched_shifts),
+                "total_shifts": total_matching_shifts,
+                "returned_shifts": len(paginated_shifts),
                 "filters_applied": {
                     "user_ids": list(user_id_filter) if user_id_filter else None,
                     "schedule_ids": schedule_ids if schedule_ids else None,
                 },
-                "shifts": enriched_shifts,
+                "meta": {
+                    "page_size": page_size,
+                    "page_number": page_number,
+                    "total_matching_shifts": total_matching_shifts,
+                    "returned_shifts": len(paginated_shifts),
+                    "has_more": has_more,
+                    "next_page": page_number + 1 if has_more else None,
+                },
+                "shifts": paginated_shifts,
             }
 
         except Exception as e:

{rootly_mcp_server-2.2.11 → rootly_mcp_server-2.2.12}/src/rootly_mcp_server/transport.py

@@ -333,6 +333,197 @@ ALERT_ESSENTIAL_ATTRIBUTES = {
     "started_at",
     "ended_at",
 }
+USER_ESSENTIAL_ATTRIBUTES = {
+    "name",
+    "email",
+    "phone",
+    "phone_2",
+    "first_name",
+    "last_name",
+    "full_name",
+    "full_name_with_team",
+    "slack_id",
+    "time_zone",
+    "created_at",
+    "updated_at",
+}
+SERVICE_ESSENTIAL_ATTRIBUTES = {
+    "name",
+    "slug",
+    "description",
+    "public_description",
+    "color",
+    "status",
+    "show_uptime",
+    "show_uptime_last_days",
+    "environment_ids",
+    "service_ids",
+    "owner_group_ids",
+    "owners_group_ids",
+    "owner_user_ids",
+    "owners_user_ids",
+    "incidents_count",
+    "alert_urgency_id",
+    "created_at",
+    "updated_at",
+    "external_id",
+    "backstage_id",
+    "cortex_id",
+    "opslevel_id",
+}
+SHIFT_ESSENTIAL_ATTRIBUTES = {
+    "schedule_id",
+    "rotation_id",
+    "starts_at",
+    "ends_at",
+    "is_override",
+}
+MINIMAL_USER_INCLUDED_ATTRIBUTES = {
+    "name",
+    "email",
+    "full_name",
+    "time_zone",
+}
+MINIMAL_ROLE_INCLUDED_ATTRIBUTES = {"name", "slug"}
+MINIMAL_SHIFT_OVERRIDE_INCLUDED_ATTRIBUTES = {
+    "starts_at",
+    "ends_at",
+    "created_at",
+    "updated_at",
+}
+
+
+def _collapse_relationship_data(relationship: Any) -> Any:
+    """Reduce relationship payloads to ids/counts while keeping structure predictable."""
+    if not isinstance(relationship, dict) or "data" not in relationship:
+        return relationship
+
+    data = relationship.get("data")
+    if isinstance(data, list):
+        return {"count": len(data)}
+    if isinstance(data, dict):
+        return {"data": {"id": data.get("id"), "type": data.get("type")}}
+    return {"data": data}
+
+
+def _strip_resource_attributes(resource: Any, allowed_attributes: set[str]) -> None:
+    """Trim a resource's attributes to the allowed subset."""
+    if not isinstance(resource, dict):
+        return
+    attrs = resource.get("attributes")
+    if not isinstance(attrs, dict):
+        return
+    for key in [attr_key for attr_key in attrs if attr_key not in allowed_attributes]:
+        del attrs[key]
+
+
+def _strip_minimal_included_resource(resource: Any) -> None:
+    """Trim sideloaded resources for user/shift/service list endpoints."""
+    if not isinstance(resource, dict):
+        return
+
+    resource_type = resource.get("type")
+    if resource_type == "users":
+        _strip_resource_attributes(resource, MINIMAL_USER_INCLUDED_ATTRIBUTES)
+    elif resource_type in {"roles", "on_call_roles"}:
+        _strip_resource_attributes(resource, MINIMAL_ROLE_INCLUDED_ATTRIBUTES)
+    elif resource_type == "shift_overrides":
+        _strip_resource_attributes(resource, MINIMAL_SHIFT_OVERRIDE_INCLUDED_ATTRIBUTES)
+    else:
+        resource.pop("attributes", None)
+        resource.pop("relationships", None)
+        return
+
+    resource.pop("relationships", None)
+
+
+def strip_heavy_user_data(data: dict[str, Any]) -> dict[str, Any]:
+    """Trim user list responses to profile essentials and compact relationship data."""
+    if not isinstance(data, dict) or "data" not in data:
+        return data
+
+    def _strip_single_user(user: Any) -> None:
+        if not isinstance(user, dict):
+            return
+        _strip_resource_attributes(user, USER_ESSENTIAL_ATTRIBUTES)
+        if "relationships" in user and isinstance(user["relationships"], dict):
+            user["relationships"] = {
+                rel_key: _collapse_relationship_data(rel_value)
+                for rel_key, rel_value in user["relationships"].items()
+            }
+
+    if isinstance(data["data"], list):
+        for user in data["data"]:
+            _strip_single_user(user)
+    elif isinstance(data["data"], dict):
+        _strip_single_user(data["data"])
+
+    included = data.get("included")
+    if isinstance(included, list):
+        for resource in included:
+            _strip_minimal_included_resource(resource)
+
+    return data
+
+
+def strip_heavy_service_data(data: dict[str, Any]) -> dict[str, Any]:
+    """Trim service list responses to operational essentials."""
+    if not isinstance(data, dict) or "data" not in data:
+        return data
+
+    def _strip_single_service(service: Any) -> None:
+        if not isinstance(service, dict):
+            return
+        _strip_resource_attributes(service, SERVICE_ESSENTIAL_ATTRIBUTES)
+        if "relationships" in service and isinstance(service["relationships"], dict):
+            service["relationships"] = {
+                rel_key: _collapse_relationship_data(rel_value)
+                for rel_key, rel_value in service["relationships"].items()
+            }
+
+    if isinstance(data["data"], list):
+        for service in data["data"]:
+            _strip_single_service(service)
+    elif isinstance(data["data"], dict):
+        _strip_single_service(data["data"])
+
+    included = data.get("included")
+    if isinstance(included, list):
+        for resource in included:
+            _strip_minimal_included_resource(resource)
+
+    return data
+
+
+def strip_heavy_shift_data(data: dict[str, Any]) -> dict[str, Any]:
+    """Trim shift list responses to schedule/timing essentials plus minimal user refs."""
+    if not isinstance(data, dict) or "data" not in data:
+        return data
+
+    def _strip_single_shift(shift: Any) -> None:
+        if not isinstance(shift, dict):
+            return
+        _strip_resource_attributes(shift, SHIFT_ESSENTIAL_ATTRIBUTES)
+        relationships = shift.get("relationships")
+        if isinstance(relationships, dict):
+            kept_relationships = {}
+            for rel_key in ("user", "shift_override"):
+                if rel_key in relationships:
+                    kept_relationships[rel_key] = _collapse_relationship_data(relationships[rel_key])
+            shift["relationships"] = kept_relationships
+
+    if isinstance(data["data"], list):
+        for shift in data["data"]:
+            _strip_single_shift(shift)
+    elif isinstance(data["data"], dict):
+        _strip_single_shift(data["data"])
+
+    included = data.get("included")
+    if isinstance(included, list):
+        for resource in included:
+            _strip_minimal_included_resource(resource)
+
+    return data
 
 
 def strip_heavy_alert_data(data: dict[str, Any]) -> dict[str, Any]:
@@ -525,6 +716,7 @@ class AuthenticatedHTTPXClient:
         # OpenAPITool.run() calls response.json() after this returns, and
         # there is no other interception point for auto-generated tools.
         response = self._maybe_strip_alert_response(method, url, response)
+        response = self._maybe_strip_collection_response(method, url, response)
 
         return response
 
@@ -539,6 +731,14 @@ class AuthenticatedHTTPXClient:
             for sub in ["/alert_urgencies", "/alert_events", "/alert_sources", "/alert_routing"]
         )
 
+    @staticmethod
+    def _path_for_url(url: str) -> str:
+        """Return the path portion of a URL or path-like string."""
+        try:
+            return httpx.URL(str(url)).path
+        except Exception:
+            return str(url).split("?", 1)[0]
+
     @staticmethod
     def _maybe_strip_alert_response(
         method: str, url: str, response: httpx.Response
@@ -558,6 +758,31 @@ class AuthenticatedHTTPXClient:
             logger.debug(f"Could not strip alert response for {url}", exc_info=True)
         return response
 
+    @classmethod
+    def _maybe_strip_collection_response(
+        cls, method: str, url: str, response: httpx.Response
+    ) -> httpx.Response:
+        """Trim known high-volume collection endpoints while keeping essential fields."""
+        if method.upper() != "GET" or not response.is_success:
+            return response
+
+        path = cls._path_for_url(url)
+        if path not in {"/v1/users", "/v1/services", "/v1/shifts"}:
+            return response
+
+        try:
+            data = response.json()
+            if path == "/v1/users":
+                stripped = strip_heavy_user_data(data)
+            elif path == "/v1/services":
+                stripped = strip_heavy_service_data(data)
+            else:
+                stripped = strip_heavy_shift_data(data)
+            response._content = json.dumps(stripped).encode()  # noqa: SLF001
+        except Exception:
+            logger.debug(f"Could not strip collection response for {url}", exc_info=True)
+        return response
+
     async def get(self, url: str, **kwargs):
         """Proxy to request with GET method."""
         return await self.request("GET", url, **kwargs)
@@ -632,6 +857,9 @@ class AuthenticatedHTTPXClient:
             _record_upstream_response_context(request.method, response)
 
         response = self._maybe_strip_alert_response(request.method, str(request.url), response)
+        response = self._maybe_strip_collection_response(
+            request.method, str(request.url), response
+        )
         return response
 
     async def __aenter__(self):

{rootly_mcp_server-2.2.11 → rootly_mcp_server-2.2.12}/tests/unit/test_code_mode_module.py

@@ -46,7 +46,17 @@ def test_build_code_mode_transform_uses_expected_discovery_tools():
     assert isinstance(transform, CodeMode)
     assert isinstance(transform.sandbox_provider, CompatibleMontySandboxProvider)
     discovery_names = [tool.name for tool in transform._build_discovery_tools()]  # noqa: SLF001
-    assert discovery_names == ["list_tools", "search", "get_schema", "tags"]
+    assert discovery_names == ["list_tools", "tool_search", "get_schema", "tags"]
+
+
+def test_build_code_mode_transform_includes_pagination_guidance():
+    transform = build_code_mode_transform()
+    assert transform.execute_description is not None
+
+    assert "tool_search only to discover tools" in transform.execute_description
+    assert "page_size, page_number, and max_results" in transform.execute_description
+    assert "per_page" in transform.execute_description
+    assert "await call_tool('search_incidents'" in transform.execute_description
 
 
 def test_create_rootly_codemode_server_adds_code_mode_transform():