rootly-mcp-server 2.1.0__tar.gz → 2.1.1__tar.gz

{rootly_mcp_server-2.1.0 → rootly_mcp_server-2.1.1}/#Dockerfile#

@@ -1,5 +1,5 @@
 # Use Python 3.12 slim image as base
-FROM python:3.12-slim
+FROM python:3.14-slim
 
 # Set working directory
 WORKDIR /app

{rootly_mcp_server-2.1.0 → rootly_mcp_server-2.1.1}/.claude/settings.local.json

@@ -63,7 +63,14 @@
       "Bash(git rm:*)",
       "Bash(black:*)",
       "Bash(isort:*)",
-      "Bash(python -m isort:*)"
+      "Bash(python -m isort:*)",
+      "Bash(pip install:*)",
+      "Bash(gh pr close:*)",
+      "Bash(git fetch:*)",
+      "Bash(git cherry-pick:*)",
+      "Bash(git revert:*)",
+      "mcp__rootly__search_incidents",
+      "Bash(uv build:*)"
     ],
     "deny": []
   }

{rootly_mcp_server-2.1.0 → rootly_mcp_server-2.1.1}/.github/workflows/ci.yml

@@ -16,15 +16,15 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v4
+        uses: astral-sh/setup-uv@v7
 
       - name: Install dependencies
         run: |
@@ -36,7 +36,7 @@ jobs:
           uv run pytest tests/ -v --cov=src/rootly_mcp_server --cov-report=term --cov-report=xml
 
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v4
+        uses: codecov/codecov-action@v5
         with:
           file: ./coverage.xml
           flags: unittests
@@ -48,15 +48,15 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: "3.12"
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v4
+        uses: astral-sh/setup-uv@v7
 
       - name: Install dependencies
         run: |
@@ -85,10 +85,10 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: "3.12"
 
@@ -113,22 +113,22 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: "3.12"
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v4
+        uses: astral-sh/setup-uv@v7
 
       - name: Build package
         run: |
           uv build
 
       - name: Upload build artifacts
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v6
         with:
           name: dist
           path: dist/

{rootly_mcp_server-2.1.0 → rootly_mcp_server-2.1.1}/.github/workflows/lint.yml

@@ -11,10 +11,10 @@ jobs:
     runs-on: ubuntu-latest
     
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     
     - name: Set up Python
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v6
       with:
         python-version: '3.12'
     

{rootly_mcp_server-2.1.0 → rootly_mcp_server-2.1.1}/PKG-INFO

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

{rootly_mcp_server-2.1.0 → rootly_mcp_server-2.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rootly-mcp-server"
-version = "2.1.0"
+version = "2.1.1"
 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.10"

{rootly_mcp_server-2.1.0 → rootly_mcp_server-2.1.1}/src/rootly_mcp_server/server.py

@@ -163,131 +163,9 @@ def strip_heavy_nested_data(data: dict[str, Any]) -> dict[str, Any]:
                         # 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."""
 
@@ -468,7 +346,7 @@ class AuthenticatedHTTPXClient:
         if self._api_token:
             headers["Authorization"] = f"Bearer {self._api_token}"
 
-        self.client = ResponseProcessingClient(
+        self.client = httpx.AsyncClient(
             base_url=base_url,
             headers=headers,
             timeout=30.0,
@@ -500,16 +378,13 @@ class AuthenticatedHTTPXClient:
         return transformed
 
     async def request(self, method: str, url: str, **kwargs):
-        """Override request to transform parameters and wrap response for payload reduction."""
+        """Override request to transform parameters."""
         # Transform query parameters
         if "params" in kwargs:
             kwargs["params"] = self._transform_params(kwargs["params"])
 
-        # Call the underlying client's request method
-        response = await self.client.request(method, url, **kwargs)
-
-        # Wrap response to process JSON and reduce payload size
-        return ProcessedResponse(response)
+        # Call the underlying client's request method and let it handle everything
+        return await self.client.request(method, url, **kwargs)
 
     async def get(self, url: str, **kwargs):
         """Proxy to request with GET method."""
@@ -612,9 +487,12 @@ def create_rootly_mcp_server(
 
     # Create the MCP server using OpenAPI integration
     # By default, all routes become tools which is what we want
+    # NOTE: We pass http_client (the wrapper) instead of http_client.client (the inner httpx client)
+    # so that parameter transformation (e.g., filter_status -> filter[status]) is applied.
+    # The wrapper implements the same interface as httpx.AsyncClient (duck typing).
     mcp = FastMCP.from_openapi(
         openapi_spec=filtered_spec,
-        client=http_client.client,
+        client=http_client,  # type: ignore[arg-type]
         name=name,
         timeout=30.0,
         tags={"rootly", "incident-management"},

{rootly_mcp_server-2.1.0 → rootly_mcp_server-2.1.1}/tests/unit/test_authentication.py

@@ -238,3 +238,52 @@ class TestAuthenticationModeComparison:
 
         assert local_client.hosted is False
         assert hosted_client.hosted is True
+
+
+class TestParameterTransformation:
+    """Test suite for parameter transformation functionality."""
+
+    def test_transform_params_with_mapping(self):
+        """Test that parameters are transformed according to mapping."""
+        mapping = {
+            "filter_status": "filter[status]",
+            "filter_services": "filter[services]",
+        }
+        client = AuthenticatedHTTPXClient(parameter_mapping=mapping)
+
+        params = {"filter_status": "active", "filter_services": "api,web", "page": 1}
+        result = client._transform_params(params)
+
+        assert result is not None
+        assert result["filter[status]"] == "active"
+        assert result["filter[services]"] == "api,web"
+        assert result["page"] == 1
+        assert "filter_status" not in result
+        assert "filter_services" not in result
+
+    def test_transform_params_without_mapping(self):
+        """Test that params pass through unchanged when no mapping exists."""
+        client = AuthenticatedHTTPXClient(parameter_mapping={})
+
+        params = {"filter_status": "active", "page": 1}
+        result = client._transform_params(params)
+
+        assert result is not None
+        assert result["filter_status"] == "active"
+        assert result["page"] == 1
+
+    def test_transform_params_with_none(self):
+        """Test that None params return None."""
+        client = AuthenticatedHTTPXClient(parameter_mapping={"foo": "bar"})
+
+        result = client._transform_params(None)
+
+        assert result is None
+
+    def test_transform_params_with_empty_dict(self):
+        """Test that empty dict returns empty dict."""
+        client = AuthenticatedHTTPXClient(parameter_mapping={"foo": "bar"})
+
+        result = client._transform_params({})
+
+        assert result == {}