rootly-mcp-server 2.1.3__tar.gz → 2.2.0__tar.gz

{rootly_mcp_server-2.1.3 → rootly_mcp_server-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rootly-mcp-server
-Version: 2.1.3
+Version: 2.2.0
 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
@@ -147,11 +147,11 @@ Alternatively, connect directly to our hosted MCP server:
   - **`suggest_solutions`**: Mines past incident resolutions to recommend actionable solutions
 - **MCP Resources**: Exposes incident and team data as structured resources for easy AI reference
 - **Intelligent Pattern Recognition**: Automatically identifies services, error types, and resolution patterns
-- **On-Call Health Integration**: Detects burnout risk in scheduled responders
+- **On-Call Health Integration**: Detects workload health risk in scheduled responders
 
 ## On-Call Health Integration
 
-Rootly MCP integrates with [On-Call Health](https://oncallhealth.ai) to detect burnout risk in scheduled responders.
+Rootly MCP integrates with [On-Call Health](https://oncallhealth.ai) to detect workload health risk in scheduled responders.
 
 ### Setup
 
@@ -175,7 +175,7 @@ Set the `ONCALLHEALTH_API_KEY` environment variable:
 ### Usage
 
 ```
-check_oncall_burnout_risk(
+check_oncall_health_risk(
     start_date="2026-02-09",
     end_date="2026-02-15"
 )

{rootly_mcp_server-2.1.3 → rootly_mcp_server-2.2.0}/README.md

@@ -108,11 +108,11 @@ Alternatively, connect directly to our hosted MCP server:
   - **`suggest_solutions`**: Mines past incident resolutions to recommend actionable solutions
 - **MCP Resources**: Exposes incident and team data as structured resources for easy AI reference
 - **Intelligent Pattern Recognition**: Automatically identifies services, error types, and resolution patterns
-- **On-Call Health Integration**: Detects burnout risk in scheduled responders
+- **On-Call Health Integration**: Detects workload health risk in scheduled responders
 
 ## On-Call Health Integration
 
-Rootly MCP integrates with [On-Call Health](https://oncallhealth.ai) to detect burnout risk in scheduled responders.
+Rootly MCP integrates with [On-Call Health](https://oncallhealth.ai) to detect workload health risk in scheduled responders.
 
 ### Setup
 
@@ -136,7 +136,7 @@ Set the `ONCALLHEALTH_API_KEY` environment variable:
 ### Usage
 
 ```
-check_oncall_burnout_risk(
+check_oncall_health_risk(
     start_date="2026-02-09",
     end_date="2026-02-15"
 )

{rootly_mcp_server-2.1.3 → rootly_mcp_server-2.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rootly-mcp-server"
-version = "2.1.3"
+version = "2.2.0"
 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.3 → rootly_mcp_server-2.2.0}/src/rootly_mcp_server/och_client.py

@@ -1,10 +1,13 @@
-"""On-Call Health API client for burnout risk analysis."""
+"""On-Call Health API client for workload health risk analysis."""
 
 import os
 from typing import Any
 
 import httpx
 
+# External API field mapping (On-Call Health API response field)
+_OCH_RISK_SCORE_FIELD = "burnout_score"
+
 
 class OnCallHealthClient:
     def __init__(self, api_key: str | None = None, base_url: str | None = None):
@@ -55,7 +58,7 @@ class OnCallHealthClient:
                 "rootly_user_id": member.get("rootly_user_id"),
                 "och_score": member.get("och_score", 0),
                 "risk_level": member.get("risk_level", "unknown"),
-                "burnout_score": member.get("burnout_score", 0),
+                "health_risk_score": member.get(_OCH_RISK_SCORE_FIELD, 0),
                 "incident_count": member.get("incident_count", 0),
             }
 

{rootly_mcp_server-2.1.3 → rootly_mcp_server-2.2.0}/src/rootly_mcp_server/server.py

@@ -381,11 +381,21 @@ class AuthenticatedHTTPXClient:
         return transformed
 
     async def request(self, method: str, url: str, **kwargs):
-        """Override request to transform parameters."""
+        """Override request to transform parameters and ensure correct headers."""
         # Transform query parameters
         if "params" in kwargs:
             kwargs["params"] = self._transform_params(kwargs["params"])
 
+        # Ensure Content-Type and Accept headers are always set correctly for Rootly API
+        # This is critical because FastMCP may pass headers from the MCP client request
+        # (e.g., Content-Type: application/json from SSE) which would override our defaults
+        if "headers" in kwargs:
+            headers = dict(kwargs["headers"]) if kwargs["headers"] else {}
+            # Always use JSON-API content type for Rootly API
+            headers["Content-Type"] = "application/vnd.api+json"
+            headers["Accept"] = "application/vnd.api+json"
+            kwargs["headers"] = headers
+
         # Call the underlying client's request method and let it handle everything
         return await self.client.request(method, url, **kwargs)
 
@@ -3158,7 +3168,7 @@ Updated: {attributes.get("updated_at", "N/A")}"""
             }
 
     @mcp.tool()
-    async def check_oncall_burnout_risk(
+    async def check_oncall_health_risk(
         start_date: Annotated[
             str,
             Field(description="Start date for the on-call period (ISO 8601, e.g., '2026-02-09')"),
@@ -3182,11 +3192,11 @@ Updated: {attributes.get("updated_at", "N/A")}"""
             Field(description="Include recommended replacement responders (default: true)"),
         ] = True,
     ) -> dict:
-        """Check if any at-risk responders (based on On-Call Health burnout analysis) are scheduled for on-call.
+        """Check if any at-risk responders (based on On-Call Health analysis) are scheduled for on-call.
 
-        Integrates with On-Call Health (oncallhealth.ai) to identify responders at risk of burnout
-        and checks if they are scheduled during the specified period. Optionally recommends
-        safe replacement responders.
+        Integrates with On-Call Health (oncallhealth.ai) to identify responders with elevated
+        workload health risk and checks if they are scheduled during the specified period.
+        Optionally recommends safe replacement responders.
 
         Requires ONCALLHEALTH_API_KEY environment variable.
         """
@@ -3229,7 +3239,7 @@ Updated: {attributes.get("updated_at", "N/A")}"""
                         "total_at_risk": 0,
                         "at_risk_scheduled": 0,
                         "action_required": False,
-                        "message": "No users above burnout threshold.",
+                        "message": "No users above health risk threshold.",
                     },
                 }
 
@@ -3340,7 +3350,7 @@ Updated: {attributes.get("updated_at", "N/A")}"""
                             "user_id": int(rootly_id),
                             "och_score": user["och_score"],
                             "risk_level": user["risk_level"],
-                            "burnout_score": user["burnout_score"],
+                            "health_risk_score": user["health_risk_score"],
                             "total_hours": round(total_hours, 1),
                             "shifts": user_shifts,
                         }
@@ -3441,7 +3451,7 @@ Updated: {attributes.get("updated_at", "N/A")}"""
 
             error_type, error_message = MCPError.categorize_error(e)
             return MCPError.tool_error(
-                f"Failed to check burnout risk: {error_message}",
+                f"Failed to check health risk: {error_message}",
                 error_type,
                 details={
                     "params": {

rootly_mcp_server-2.2.0/tests/unit/test_http_headers.py

@@ -0,0 +1,277 @@
+"""
+Unit tests for HTTP header handling in AuthenticatedHTTPXClient.
+
+Tests cover:
+- Content-Type header override for Rootly JSON-API format
+- Header handling when FastMCP passes MCP client headers
+- Ensuring correct headers reach the Rootly API
+"""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+
+class TestAuthenticatedHTTPXClientHeaders:
+    """Tests for header handling in AuthenticatedHTTPXClient."""
+
+    @pytest.fixture
+    def mock_httpx_client(self):
+        """Create a mock httpx.AsyncClient."""
+        mock_client = AsyncMock()
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"data": []}
+        mock_client.request.return_value = mock_response
+        return mock_client
+
+    @pytest.mark.asyncio
+    async def test_overrides_content_type_from_mcp_client(self, mock_httpx_client):
+        """Test that Content-Type is overridden when MCP client sends application/json."""
+        from rootly_mcp_server.server import AuthenticatedHTTPXClient
+
+        with patch.object(AuthenticatedHTTPXClient, "_get_api_token", return_value="test-token"):
+            client = AuthenticatedHTTPXClient()
+            client.client = mock_httpx_client
+
+            # Simulate FastMCP passing headers from MCP client request
+            # This is what causes the 415 error - MCP client sends application/json
+            mcp_headers = {
+                "Content-Type": "application/json",
+                "Accept": "application/json",
+                "Authorization": "Bearer user-token",
+            }
+
+            await client.request("GET", "/v1/teams", headers=mcp_headers)
+
+            # Verify the request was made with correct JSON-API headers
+            call_kwargs = mock_httpx_client.request.call_args[1]
+            assert call_kwargs["headers"]["Content-Type"] == "application/vnd.api+json"
+            assert call_kwargs["headers"]["Accept"] == "application/vnd.api+json"
+            # Authorization should be preserved
+            assert call_kwargs["headers"]["Authorization"] == "Bearer user-token"
+
+    @pytest.mark.asyncio
+    async def test_sets_headers_when_empty_headers_passed(self, mock_httpx_client):
+        """Test that headers are set correctly when empty headers dict is passed."""
+        from rootly_mcp_server.server import AuthenticatedHTTPXClient
+
+        with patch.object(AuthenticatedHTTPXClient, "_get_api_token", return_value="test-token"):
+            client = AuthenticatedHTTPXClient()
+            client.client = mock_httpx_client
+
+            # FastMCP might pass empty headers
+            await client.request("GET", "/v1/incidents", headers={})
+
+            call_kwargs = mock_httpx_client.request.call_args[1]
+            assert call_kwargs["headers"]["Content-Type"] == "application/vnd.api+json"
+            assert call_kwargs["headers"]["Accept"] == "application/vnd.api+json"
+
+    @pytest.mark.asyncio
+    async def test_preserves_other_headers(self, mock_httpx_client):
+        """Test that non-content-type headers are preserved."""
+        from rootly_mcp_server.server import AuthenticatedHTTPXClient
+
+        with patch.object(AuthenticatedHTTPXClient, "_get_api_token", return_value="test-token"):
+            client = AuthenticatedHTTPXClient()
+            client.client = mock_httpx_client
+
+            custom_headers = {
+                "Content-Type": "application/json",  # Should be overridden
+                "X-Custom-Header": "custom-value",  # Should be preserved
+                "X-Request-ID": "12345",  # Should be preserved
+            }
+
+            await client.request("POST", "/v1/incidents", headers=custom_headers)
+
+            call_kwargs = mock_httpx_client.request.call_args[1]
+            assert call_kwargs["headers"]["Content-Type"] == "application/vnd.api+json"
+            assert call_kwargs["headers"]["X-Custom-Header"] == "custom-value"
+            assert call_kwargs["headers"]["X-Request-ID"] == "12345"
+
+    @pytest.mark.asyncio
+    async def test_no_headers_kwarg_works(self, mock_httpx_client):
+        """Test that requests without headers kwarg still work."""
+        from rootly_mcp_server.server import AuthenticatedHTTPXClient
+
+        with patch.object(AuthenticatedHTTPXClient, "_get_api_token", return_value="test-token"):
+            client = AuthenticatedHTTPXClient()
+            client.client = mock_httpx_client
+
+            # Request without headers kwarg (relies on client defaults)
+            await client.request("GET", "/v1/users")
+
+            # Should still make the request successfully
+            mock_httpx_client.request.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_none_headers_handled(self, mock_httpx_client):
+        """Test that None headers are handled gracefully."""
+        from rootly_mcp_server.server import AuthenticatedHTTPXClient
+
+        with patch.object(AuthenticatedHTTPXClient, "_get_api_token", return_value="test-token"):
+            client = AuthenticatedHTTPXClient()
+            client.client = mock_httpx_client
+
+            # FastMCP might pass headers=None
+            await client.request("GET", "/v1/schedules", headers=None)
+
+            call_kwargs = mock_httpx_client.request.call_args[1]
+            assert call_kwargs["headers"]["Content-Type"] == "application/vnd.api+json"
+            assert call_kwargs["headers"]["Accept"] == "application/vnd.api+json"
+
+
+class TestHTTPMethodsWithHeaders:
+    """Test all HTTP methods correctly handle headers."""
+
+    @pytest.fixture
+    def mock_httpx_client(self):
+        """Create a mock httpx.AsyncClient."""
+        mock_client = AsyncMock()
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"data": []}
+        mock_client.request.return_value = mock_response
+        return mock_client
+
+    @pytest.mark.asyncio
+    async def test_get_method_headers(self, mock_httpx_client):
+        """Test GET method correctly overrides headers."""
+        from rootly_mcp_server.server import AuthenticatedHTTPXClient
+
+        with patch.object(AuthenticatedHTTPXClient, "_get_api_token", return_value="test-token"):
+            client = AuthenticatedHTTPXClient()
+            client.client = mock_httpx_client
+
+            await client.get("/v1/teams", headers={"Content-Type": "application/json"})
+
+            call_kwargs = mock_httpx_client.request.call_args[1]
+            assert call_kwargs["headers"]["Content-Type"] == "application/vnd.api+json"
+
+    @pytest.mark.asyncio
+    async def test_post_method_headers(self, mock_httpx_client):
+        """Test POST method correctly overrides headers."""
+        from rootly_mcp_server.server import AuthenticatedHTTPXClient
+
+        with patch.object(AuthenticatedHTTPXClient, "_get_api_token", return_value="test-token"):
+            client = AuthenticatedHTTPXClient()
+            client.client = mock_httpx_client
+
+            await client.post(
+                "/v1/incidents",
+                headers={"Content-Type": "application/json"},
+                json={"title": "Test"},
+            )
+
+            call_kwargs = mock_httpx_client.request.call_args[1]
+            assert call_kwargs["headers"]["Content-Type"] == "application/vnd.api+json"
+
+    @pytest.mark.asyncio
+    async def test_patch_method_headers(self, mock_httpx_client):
+        """Test PATCH method correctly overrides headers."""
+        from rootly_mcp_server.server import AuthenticatedHTTPXClient
+
+        with patch.object(AuthenticatedHTTPXClient, "_get_api_token", return_value="test-token"):
+            client = AuthenticatedHTTPXClient()
+            client.client = mock_httpx_client
+
+            await client.patch(
+                "/v1/incidents/123",
+                headers={"Content-Type": "application/json"},
+                json={"status": "resolved"},
+            )
+
+            call_kwargs = mock_httpx_client.request.call_args[1]
+            assert call_kwargs["headers"]["Content-Type"] == "application/vnd.api+json"
+
+    @pytest.mark.asyncio
+    async def test_delete_method_headers(self, mock_httpx_client):
+        """Test DELETE method correctly overrides headers."""
+        from rootly_mcp_server.server import AuthenticatedHTTPXClient
+
+        with patch.object(AuthenticatedHTTPXClient, "_get_api_token", return_value="test-token"):
+            client = AuthenticatedHTTPXClient()
+            client.client = mock_httpx_client
+
+            await client.delete("/v1/incidents/123", headers={"Content-Type": "application/json"})
+
+            call_kwargs = mock_httpx_client.request.call_args[1]
+            assert call_kwargs["headers"]["Content-Type"] == "application/vnd.api+json"
+
+
+class TestFastMCPIntegrationScenario:
+    """Test scenarios that simulate FastMCP's behavior."""
+
+    @pytest.fixture
+    def mock_httpx_client(self):
+        """Create a mock httpx.AsyncClient."""
+        mock_client = AsyncMock()
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"data": [{"id": "1", "type": "teams"}]}
+        mock_client.request.return_value = mock_response
+        return mock_client
+
+    @pytest.mark.asyncio
+    async def test_simulated_fastmcp_listteams_call(self, mock_httpx_client):
+        """Simulate the exact scenario that causes 415 error with listTeams."""
+        from rootly_mcp_server.server import AuthenticatedHTTPXClient
+
+        with patch.object(AuthenticatedHTTPXClient, "_get_api_token", return_value="test-token"):
+            client = AuthenticatedHTTPXClient()
+            client.client = mock_httpx_client
+
+            # This simulates what FastMCP does:
+            # 1. Gets headers from MCP client HTTP request (SSE connection)
+            # 2. These headers include Content-Type: application/json
+            # 3. Passes them to our client
+            mcp_client_headers = {
+                "host": "mcp.rootly.com",
+                "content-type": "application/json",  # From MCP client
+                "accept": "text/event-stream",
+                "authorization": "Bearer user-api-token",
+            }
+
+            # Make request like FastMCP would
+            await client.request(
+                method="GET",
+                url="/v1/teams",
+                params={"page[size]": 10},
+                headers=mcp_client_headers,
+            )
+
+            # Verify correct headers were sent to Rootly API
+            call_kwargs = mock_httpx_client.request.call_args[1]
+            assert call_kwargs["headers"]["Content-Type"] == "application/vnd.api+json"
+            assert call_kwargs["headers"]["Accept"] == "application/vnd.api+json"
+            # Auth header should be preserved for hosted mode
+            assert call_kwargs["headers"]["authorization"] == "Bearer user-api-token"
+
+    @pytest.mark.asyncio
+    async def test_simulated_fastmcp_getcurrentuser_call(self, mock_httpx_client):
+        """Simulate the exact scenario that causes 415 error with getCurrentUser."""
+        from rootly_mcp_server.server import AuthenticatedHTTPXClient
+
+        mock_httpx_client.request.return_value.json.return_value = {
+            "data": {"id": "123", "type": "users", "attributes": {"name": "Test User"}}
+        }
+
+        with patch.object(AuthenticatedHTTPXClient, "_get_api_token", return_value="test-token"):
+            client = AuthenticatedHTTPXClient()
+            client.client = mock_httpx_client
+
+            # Simulate FastMCP headers for getCurrentUser
+            mcp_client_headers = {
+                "content-type": "application/json",
+                "accept": "application/json",
+            }
+
+            await client.request(
+                method="GET",
+                url="/v1/users/me",
+                headers=mcp_client_headers,
+            )
+
+            call_kwargs = mock_httpx_client.request.call_args[1]
+            assert call_kwargs["headers"]["Content-Type"] == "application/vnd.api+json"
+            assert call_kwargs["headers"]["Accept"] == "application/vnd.api+json"

{rootly_mcp_server-2.1.3 → rootly_mcp_server-2.2.0}/tests/unit/test_och_client.py

@@ -1,12 +1,16 @@
 """
-Unit tests for On-Call Health client and burnout risk tool.
+Unit tests for On-Call Health client and health risk tool.
 
 Tests cover:
 - OnCallHealthClient initialization
 - extract_at_risk_users logic
-- check_oncall_burnout_risk tool behavior
+- check_oncall_health_risk tool behavior
+- Field mapping from external API to internal names
+- Tool registration verification
 """
 
+from unittest.mock import patch
+
 import pytest
 
 
@@ -40,7 +44,7 @@ class TestExtractAtRiskUsers:
 
     @pytest.fixture
     def mock_analysis(self):
-        """Mock OCH analysis response."""
+        """Mock OCH analysis response (uses external API field names)."""
         return {
             "id": 1226,
             "analysis_data": {
@@ -51,7 +55,7 @@ class TestExtractAtRiskUsers:
                             "rootly_user_id": "2381",
                             "och_score": 86.5,
                             "risk_level": "high",
-                            "burnout_score": 3.5,
+                            "burnout_score": 3.5,  # External API field name
                             "incident_count": 15,
                         },
                         {
@@ -59,7 +63,7 @@ class TestExtractAtRiskUsers:
                             "rootly_user_id": "94178",
                             "och_score": 55.0,
                             "risk_level": "medium",
-                            "burnout_score": 2.0,
+                            "burnout_score": 2.0,  # External API field name
                             "incident_count": 8,
                         },
                         {
@@ -67,7 +71,7 @@ class TestExtractAtRiskUsers:
                             "rootly_user_id": "62208",
                             "och_score": 15.0,
                             "risk_level": "low",
-                            "burnout_score": 0.5,
+                            "burnout_score": 0.5,  # External API field name
                             "incident_count": 2,
                         },
                         {
@@ -75,7 +79,7 @@ class TestExtractAtRiskUsers:
                             "rootly_user_id": "12345",
                             "och_score": 35.0,
                             "risk_level": "moderate",
-                            "burnout_score": 1.0,
+                            "burnout_score": 1.0,  # External API field name
                             "incident_count": 5,
                         },
                     ]
@@ -134,7 +138,7 @@ class TestExtractAtRiskUsers:
                     "rootly_user_id": "99999",
                     "och_score": 5.0,
                     "risk_level": "low",
-                    "burnout_score": 0.1,
+                    "burnout_score": 0.1,  # External API field name
                     "incident_count": 0,
                 },
             ]
@@ -158,7 +162,7 @@ class TestExtractAtRiskUsers:
         assert "rootly_user_id" in user
         assert "och_score" in user
         assert "risk_level" in user
-        assert "burnout_score" in user
+        assert "health_risk_score" in user
         assert "incident_count" in user
 
     def test_empty_members_list(self):
@@ -186,8 +190,8 @@ class TestExtractAtRiskUsers:
         assert safe == []
 
 
-class TestCheckOncallBurnoutRiskLogic:
-    """Tests for check_oncall_burnout_risk tool logic."""
+class TestCheckOncallHealthRiskLogic:
+    """Tests for check_oncall_health_risk tool logic."""
 
     def test_no_at_risk_users_returns_empty(self):
         """Test response when no users are above threshold."""
@@ -204,7 +208,7 @@ class TestCheckOncallBurnoutRiskLogic:
                             "rootly_user_id": "123",
                             "och_score": 10.0,
                             "risk_level": "low",
-                            "burnout_score": 0.1,
+                            "burnout_score": 0.1,  # External API field name
                             "incident_count": 1,
                         }
                     ]
@@ -231,7 +235,7 @@ class TestCheckOncallBurnoutRiskLogic:
                             "rootly_user_id": None,
                             "och_score": 80.0,
                             "risk_level": "high",
-                            "burnout_score": 3.0,
+                            "burnout_score": 3.0,  # External API field name
                             "incident_count": 10,
                         }
                     ]
@@ -246,8 +250,8 @@ class TestCheckOncallBurnoutRiskLogic:
         assert at_risk[0]["rootly_user_id"] is None
 
 
-class TestBurnoutRiskSummaryLogic:
-    """Tests for burnout risk summary generation logic."""
+class TestHealthRiskSummaryLogic:
+    """Tests for health risk summary generation logic."""
 
     def test_action_required_when_at_risk_scheduled(self):
         """Test that action_required is True when at-risk users are scheduled."""
@@ -280,3 +284,156 @@ class TestBurnoutRiskSummaryLogic:
         assert "2 at-risk user(s)" in message
         assert "64 hours" in message
         assert "Consider reassignment" in message
+
+
+class TestToolRegistration:
+    """Tests for tool registration with correct naming."""
+
+    def test_health_risk_tool_is_registered(self):
+        """Verify check_oncall_health_risk tool is registered."""
+        with patch("rootly_mcp_server.server._load_swagger_spec") as mock_load_spec:
+            mock_spec = {
+                "openapi": "3.0.0",
+                "info": {"title": "Test API", "version": "1.0.0"},
+                "paths": {},
+                "components": {"schemas": {}},
+            }
+            mock_load_spec.return_value = mock_spec
+
+            from rootly_mcp_server.server import create_rootly_mcp_server
+
+            server = create_rootly_mcp_server()
+            assert server is not None
+
+            # Get all registered tools
+            tools = server._tool_manager._tools
+            tool_names = list(tools.keys())
+
+            # Verify new tool name exists
+            assert "check_oncall_health_risk" in tool_names
+
+    def test_old_burnout_tool_name_not_registered(self):
+        """Verify old check_oncall_burnout_risk tool name does NOT exist."""
+        with patch("rootly_mcp_server.server._load_swagger_spec") as mock_load_spec:
+            mock_spec = {
+                "openapi": "3.0.0",
+                "info": {"title": "Test API", "version": "1.0.0"},
+                "paths": {},
+                "components": {"schemas": {}},
+            }
+            mock_load_spec.return_value = mock_spec
+
+            from rootly_mcp_server.server import create_rootly_mcp_server
+
+            server = create_rootly_mcp_server()
+            tools = server._tool_manager._tools
+            tool_names = list(tools.keys())
+
+            # Verify old tool name does NOT exist
+            assert "check_oncall_burnout_risk" not in tool_names
+
+
+class TestFieldMapping:
+    """Tests for field name mapping from external API to internal names."""
+
+    def test_external_api_field_mapped_to_health_risk_score(self):
+        """Verify external API's field is mapped to health_risk_score."""
+        from rootly_mcp_server.och_client import OnCallHealthClient
+
+        # Simulate external API response with their field name
+        api_response = {
+            "analysis_data": {
+                "team_analysis": {
+                    "members": [
+                        {
+                            "user_name": "Test User",
+                            "rootly_user_id": "123",
+                            "och_score": 75.0,
+                            "risk_level": "high",
+                            "burnout_score": 3.2,  # External API field
+                            "incident_count": 10,
+                        }
+                    ]
+                }
+            }
+        }
+
+        client = OnCallHealthClient(api_key="test")
+        at_risk, _ = client.extract_at_risk_users(api_response)
+
+        # Verify the extracted data uses our field name
+        assert len(at_risk) == 1
+        assert "health_risk_score" in at_risk[0]
+        assert at_risk[0]["health_risk_score"] == 3.2
+
+        # Verify old field name is NOT in output
+        assert "burnout_score" not in at_risk[0]
+
+    def test_response_schema_uses_health_risk_score(self):
+        """Verify all extracted users have health_risk_score field."""
+        from rootly_mcp_server.och_client import OnCallHealthClient
+
+        api_response = {
+            "analysis_data": {
+                "team_analysis": {
+                    "members": [
+                        {
+                            "user_name": "User 1",
+                            "rootly_user_id": "1",
+                            "och_score": 80.0,
+                            "risk_level": "high",
+                            "burnout_score": 3.5,
+                            "incident_count": 15,
+                        },
+                        {
+                            "user_name": "User 2",
+                            "rootly_user_id": "2",
+                            "och_score": 10.0,
+                            "risk_level": "low",
+                            "burnout_score": 0.5,
+                            "incident_count": 2,
+                        },
+                    ]
+                }
+            }
+        }
+
+        client = OnCallHealthClient(api_key="test")
+        at_risk, safe = client.extract_at_risk_users(api_response)
+
+        # Check at-risk users
+        for user in at_risk:
+            assert "health_risk_score" in user
+            assert "burnout_score" not in user
+
+        # Check safe users
+        for user in safe:
+            assert "health_risk_score" in user
+            assert "burnout_score" not in user
+
+    def test_missing_external_field_defaults_to_zero(self):
+        """Verify missing external API field defaults to 0."""
+        from rootly_mcp_server.och_client import OnCallHealthClient
+
+        api_response = {
+            "analysis_data": {
+                "team_analysis": {
+                    "members": [
+                        {
+                            "user_name": "User Without Score",
+                            "rootly_user_id": "999",
+                            "och_score": 60.0,
+                            "risk_level": "medium",
+                            # No burnout_score field
+                            "incident_count": 5,
+                        }
+                    ]
+                }
+            }
+        }
+
+        client = OnCallHealthClient(api_key="test")
+        at_risk, _ = client.extract_at_risk_users(api_response)
+
+        assert len(at_risk) == 1
+        assert at_risk[0]["health_risk_score"] == 0

{rootly_mcp_server-2.1.3 → rootly_mcp_server-2.2.0}/uv.lock

@@ -1658,7 +1658,7 @@ wheels = [
 
 [[package]]
 name = "rootly-mcp-server"
-version = "2.1.0"
+version = "2.2.0"
 source = { editable = "." }
 dependencies = [
     { name = "brotli" },