rootly-mcp-server 2.2.18__tar.gz → 2.2.19__tar.gz

{rootly_mcp_server-2.2.18 → rootly_mcp_server-2.2.19}/CHANGELOG.md

@@ -5,6 +5,16 @@ All notable changes to the Rootly MCP Server will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.2.19] - Released 2026-04-17
+
+### Features
+
+- **Scoped Incident Creation Tool**: Added a custom `createIncident` tool so agents can create incidents directly from MCP without exposing the full raw `/incidents` OpenAPI surface
+
+### Documentation
+
+- **Custom Tool List Updated**: Added `createIncident` to the README custom tool section with its scoped workflow-oriented behavior
+
 ## [2.2.18] - Released 2026-04-15
 
 ### Features

{rootly_mcp_server-2.2.18 → rootly_mcp_server-2.2.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rootly-mcp-server
-Version: 2.2.18
+Version: 2.2.19
 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
@@ -276,36 +276,6 @@ Add to `claude_desktop_config.json`:
 
 </details>
 
-## ChatGPT App Starter
-
-The server now includes a built-in ChatGPT app surface for incident exploration.
-
-- **Model-visible app tool:** `open_rootly_incident_workbench`
-- **App-only detail tool:** `get_rootly_incident_detail`
-- **UI resource:** `ui://rootly/incident-workbench.html`
-
-This gives ChatGPT a visual Rootly incident workbench without needing a separate backend.
-
-### What it does
-
-- Applies structured incident filters such as team, time range, severity, and status
-- Collects a bounded set of incident summaries for the widget
-- Lets the widget open a detailed incident pane without exposing the detail tool to the model
-
-### Try it in ChatGPT Developer Mode
-
-Once the MCP server is connected in ChatGPT Developer Mode, try prompts like:
-
-- `Open the Rootly incident workbench for Infrastructure incidents from the last 7 days`
-- `Show me resolved critical incidents for Infrastructure from April 1 through April 13`
-- `Open the Rootly incident workbench for database timeout incidents`
-
-### Production auth note
-
-For internal testing and developer-mode setups, the existing bearer-token flow is enough.
-
-For a public ChatGPT app that exposes customer-specific data or write actions, plan to add OAuth 2.1 support on the MCP side before submission. The current Rootly MCP server forwards bearer tokens, but public Apps SDK submissions expect OAuth 2.1-compatible MCP authorization metadata and token verification.
-
 ## Rootly CLI
 
 Standalone CLI for incidents, alerts, services, and on-call operations.
@@ -445,6 +415,7 @@ The default server configuration exposes **110 tools**.
 - `check_oncall_health_risk`
 - `check_responder_availability`
 - `collect_incidents`
+- `createIncident` - create a new incident with a scoped set of fields for agent workflows
 - `create_override_recommendation`
 - `find_related_incidents`
 - `getIncident` - retrieve a single incident for direct verification, including PIR-related fields
@@ -457,7 +428,6 @@ The default server configuration exposes **110 tools**.
 - `list_endpoints`
 - `list_incidents`
 - `list_shifts`
-- `open_rootly_incident_workbench`
 - `search_incidents`
 - `suggest_solutions`
 - `updateIncident` - scoped incident update tool for `summary` and `retrospective_progress_status`

{rootly_mcp_server-2.2.18 → rootly_mcp_server-2.2.19}/README.md

@@ -234,36 +234,6 @@ Add to `claude_desktop_config.json`:
 
 </details>
 
-## ChatGPT App Starter
-
-The server now includes a built-in ChatGPT app surface for incident exploration.
-
-- **Model-visible app tool:** `open_rootly_incident_workbench`
-- **App-only detail tool:** `get_rootly_incident_detail`
-- **UI resource:** `ui://rootly/incident-workbench.html`
-
-This gives ChatGPT a visual Rootly incident workbench without needing a separate backend.
-
-### What it does
-
-- Applies structured incident filters such as team, time range, severity, and status
-- Collects a bounded set of incident summaries for the widget
-- Lets the widget open a detailed incident pane without exposing the detail tool to the model
-
-### Try it in ChatGPT Developer Mode
-
-Once the MCP server is connected in ChatGPT Developer Mode, try prompts like:
-
-- `Open the Rootly incident workbench for Infrastructure incidents from the last 7 days`
-- `Show me resolved critical incidents for Infrastructure from April 1 through April 13`
-- `Open the Rootly incident workbench for database timeout incidents`
-
-### Production auth note
-
-For internal testing and developer-mode setups, the existing bearer-token flow is enough.
-
-For a public ChatGPT app that exposes customer-specific data or write actions, plan to add OAuth 2.1 support on the MCP side before submission. The current Rootly MCP server forwards bearer tokens, but public Apps SDK submissions expect OAuth 2.1-compatible MCP authorization metadata and token verification.
-
 ## Rootly CLI
 
 Standalone CLI for incidents, alerts, services, and on-call operations.
@@ -403,6 +373,7 @@ The default server configuration exposes **110 tools**.
 - `check_oncall_health_risk`
 - `check_responder_availability`
 - `collect_incidents`
+- `createIncident` - create a new incident with a scoped set of fields for agent workflows
 - `create_override_recommendation`
 - `find_related_incidents`
 - `getIncident` - retrieve a single incident for direct verification, including PIR-related fields
@@ -415,7 +386,6 @@ The default server configuration exposes **110 tools**.
 - `list_endpoints`
 - `list_incidents`
 - `list_shifts`
-- `open_rootly_incident_workbench`
 - `search_incidents`
 - `suggest_solutions`
 - `updateIncident` - scoped incident update tool for `summary` and `retrospective_progress_status`

{rootly_mcp_server-2.2.18 → rootly_mcp_server-2.2.19}/pyproject.toml

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

@@ -22,7 +22,6 @@ from .exceptions import RootlyAuthenticationError
 from .mcp_error import MCPError
 from .security import mask_sensitive_data, sanitize_error_message
 from .tools.alerts import register_alert_tools
-from .tools.chatgpt_app import register_chatgpt_app_tools
 from .tools.incidents import register_incident_tools
 from .tools.oncall import register_oncall_tools
 from .tools.resources import register_resource_handlers
@@ -576,13 +575,6 @@ def create_rootly_mcp_server(
         mcp_error=MCPError,
     )
 
-    register_chatgpt_app_tools(
-        mcp=mcp,
-        make_authenticated_request=make_authenticated_request,
-        strip_heavy_nested_data=strip_heavy_nested_data,
-        mcp_error=MCPError,
-    )
-
     register_alert_tools(
         mcp=mcp,
         make_authenticated_request=make_authenticated_request,

{rootly_mcp_server-2.2.18 → rootly_mcp_server-2.2.19}/src/rootly_mcp_server/tools/__init__.py

@@ -1,14 +1,12 @@
 """Tool registration modules for Rootly MCP server."""
 
 from .alerts import register_alert_tools
-from .chatgpt_app import register_chatgpt_app_tools
 from .incidents import register_incident_tools
 from .oncall import register_oncall_tools
 from .resources import register_resource_handlers
 
 __all__ = [
     "register_alert_tools",
-    "register_chatgpt_app_tools",
     "register_incident_tools",
     "register_oncall_tools",
     "register_resource_handlers",

{rootly_mcp_server-2.2.18 → rootly_mcp_server-2.2.19}/src/rootly_mcp_server/tools/incidents.py

@@ -29,6 +29,14 @@ def _split_csv_values(value: str) -> list[str]:
     return [part.strip() for part in value.split(",") if part.strip()]
 
 
+def _normalize_optional_text(value: str | None) -> str | None:
+    """Normalize optional text inputs by trimming whitespace and empty values."""
+    if value is None:
+        return None
+    normalized = value.strip()
+    return normalized or None
+
+
 def _extract_incident_severity(severity_value: Any) -> str | None:
     """Normalize severity values from Rootly API responses into a compact string."""
     if severity_value is None:
@@ -68,141 +76,6 @@ def _summarize_incident_record(incident: dict[str, Any]) -> dict[str, Any]:
     }
 
 
-async def resolve_team_names_to_ids(
-    *,
-    teams: str,
-    make_authenticated_request: MakeAuthenticatedRequest,
-) -> tuple[str, dict[str, str]]:
-    """Resolve comma-separated team names/slugs to Rootly team IDs."""
-    requested_teams = _split_csv_values(teams)
-    if not requested_teams:
-        return "", {}
-
-    resolved_team_ids: list[str] = []
-    resolved_team_lookup: dict[str, str] = {}
-    unresolved_teams: list[str] = []
-
-    for team in requested_teams:
-        matched_id = None
-
-        for filter_key, expected_value in (
-            ("filter[slug]", team),
-            ("filter[name]", team),
-        ):
-            response = await make_authenticated_request(
-                "GET",
-                "/v1/teams",
-                params={
-                    "page[size]": 100,
-                    "page[number]": 1,
-                    filter_key: team,
-                },
-            )
-            response.raise_for_status()
-
-            for candidate in response.json().get("data", []):
-                attrs = candidate.get("attributes", {})
-                candidate_value = (
-                    attrs.get("slug")
-                    if filter_key == "filter[slug]"
-                    else attrs.get("name")
-                )
-                if (
-                    isinstance(candidate_value, str)
-                    and candidate_value.lower() == expected_value.lower()
-                ):
-                    matched_id = str(candidate.get("id"))
-                    break
-
-            if matched_id:
-                break
-
-        if matched_id:
-            resolved_team_ids.append(matched_id)
-            resolved_team_lookup[team] = matched_id
-        else:
-            unresolved_teams.append(team)
-
-    if unresolved_teams:
-        raise ValueError(
-            "Could not resolve team names/slugs to team IDs: " + ", ".join(unresolved_teams)
-        )
-
-    return ",".join(dict.fromkeys(resolved_team_ids)), resolved_team_lookup
-
-
-async def prepare_incident_query_context(
-    *,
-    make_authenticated_request: MakeAuthenticatedRequest,
-    query: str,
-    teams: str,
-    team_ids: str,
-    service_ids: str,
-    severity: str,
-    status: str,
-    started_after: str,
-    started_before: str,
-    custom_field_selected_option_ids: str,
-    sort: Literal["created_at", "-created_at", "updated_at", "-updated_at"],
-) -> tuple[dict[str, Any], dict[str, Any]]:
-    """Build shared incident query params and filter metadata for list/collect tools."""
-    resolved_team_lookup: dict[str, str] = {}
-    resolved_team_ids = team_ids
-
-    if teams:
-        resolved_teams_value, resolved_team_lookup = await resolve_team_names_to_ids(
-            teams=teams,
-            make_authenticated_request=make_authenticated_request,
-        )
-        if resolved_team_ids and resolved_teams_value:
-            combined_team_ids = _split_csv_values(resolved_team_ids) + _split_csv_values(
-                resolved_teams_value
-            )
-            resolved_team_ids = ",".join(dict.fromkeys(combined_team_ids))
-        elif resolved_teams_value:
-            resolved_team_ids = resolved_teams_value
-
-    params: dict[str, Any] = {
-        "fields[incidents]": INCIDENT_LIST_FIELDS,
-        "include": "",
-        "sort": sort,
-    }
-
-    if query:
-        params["filter[search]"] = query
-    if resolved_team_ids:
-        params["filter[team_ids]"] = resolved_team_ids
-    if service_ids:
-        params["filter[service_ids]"] = service_ids
-    if severity:
-        params["filter[severity]"] = severity
-    if status:
-        params["filter[status]"] = status
-    if started_after:
-        params["filter[started_at][gte]"] = started_after
-    if started_before:
-        params["filter[started_at][lte]"] = started_before
-    if custom_field_selected_option_ids:
-        params["filter[custom_field_selected_option_ids]"] = custom_field_selected_option_ids
-
-    filters = {
-        "query": query,
-        "teams": teams,
-        "team_ids": team_ids,
-        "resolved_team_ids": resolved_team_ids,
-        "resolved_team_lookup": resolved_team_lookup,
-        "service_ids": service_ids,
-        "severity": severity,
-        "status": status,
-        "started_after": started_after,
-        "started_before": started_before,
-        "custom_field_selected_option_ids": custom_field_selected_option_ids,
-        "sort": sort,
-    }
-
-    return params, filters
-
-
 def register_incident_tools(
     mcp: Any,
     make_authenticated_request: MakeAuthenticatedRequest,
@@ -216,6 +89,127 @@ def register_incident_tools(
     similarity_analyzer = TextSimilarityAnalyzer()
     solution_extractor = SolutionExtractor()
 
+    async def _resolve_team_names_to_ids(teams: str) -> tuple[str, dict[str, str]]:
+        """Resolve comma-separated team names/slugs to Rootly team IDs."""
+        requested_teams = _split_csv_values(teams)
+        if not requested_teams:
+            return "", {}
+
+        resolved_team_ids: list[str] = []
+        resolved_team_lookup: dict[str, str] = {}
+        unresolved_teams: list[str] = []
+
+        for team in requested_teams:
+            matched_id = None
+
+            for filter_key, expected_value in (
+                ("filter[slug]", team),
+                ("filter[name]", team),
+            ):
+                response = await make_authenticated_request(
+                    "GET",
+                    "/v1/teams",
+                    params={
+                        "page[size]": 100,
+                        "page[number]": 1,
+                        filter_key: team,
+                    },
+                )
+                response.raise_for_status()
+
+                for candidate in response.json().get("data", []):
+                    attrs = candidate.get("attributes", {})
+                    candidate_value = attrs.get("slug") if filter_key == "filter[slug]" else attrs.get(
+                        "name"
+                    )
+                    if isinstance(candidate_value, str) and candidate_value.lower() == expected_value.lower():
+                        matched_id = str(candidate.get("id"))
+                        break
+
+                if matched_id:
+                    break
+
+            if matched_id:
+                resolved_team_ids.append(matched_id)
+                resolved_team_lookup[team] = matched_id
+            else:
+                unresolved_teams.append(team)
+
+        if unresolved_teams:
+            raise ValueError(
+                "Could not resolve team names/slugs to team IDs: "
+                + ", ".join(unresolved_teams)
+            )
+
+        return ",".join(dict.fromkeys(resolved_team_ids)), resolved_team_lookup
+
+    async def _prepare_incident_query_context(
+        *,
+        query: str,
+        teams: str,
+        team_ids: str,
+        service_ids: str,
+        severity: str,
+        status: str,
+        started_after: str,
+        started_before: str,
+        custom_field_selected_option_ids: str,
+        sort: Literal["created_at", "-created_at", "updated_at", "-updated_at"],
+    ) -> tuple[dict[str, Any], dict[str, Any]]:
+        """Build shared incident query params and filter metadata for list/collect tools."""
+        resolved_team_lookup: dict[str, str] = {}
+        resolved_team_ids = team_ids
+
+        if teams:
+            resolved_teams_value, resolved_team_lookup = await _resolve_team_names_to_ids(teams)
+            if resolved_team_ids and resolved_teams_value:
+                combined_team_ids = _split_csv_values(resolved_team_ids) + _split_csv_values(
+                    resolved_teams_value
+                )
+                resolved_team_ids = ",".join(dict.fromkeys(combined_team_ids))
+            elif resolved_teams_value:
+                resolved_team_ids = resolved_teams_value
+
+        params: dict[str, Any] = {
+            "fields[incidents]": INCIDENT_LIST_FIELDS,
+            "include": "",
+            "sort": sort,
+        }
+
+        if query:
+            params["filter[search]"] = query
+        if resolved_team_ids:
+            params["filter[team_ids]"] = resolved_team_ids
+        if service_ids:
+            params["filter[service_ids]"] = service_ids
+        if severity:
+            params["filter[severity]"] = severity
+        if status:
+            params["filter[status]"] = status
+        if started_after:
+            params["filter[started_at][gte]"] = started_after
+        if started_before:
+            params["filter[started_at][lte]"] = started_before
+        if custom_field_selected_option_ids:
+            params["filter[custom_field_selected_option_ids]"] = custom_field_selected_option_ids
+
+        filters = {
+            "query": query,
+            "teams": teams,
+            "team_ids": team_ids,
+            "resolved_team_ids": resolved_team_ids,
+            "resolved_team_lookup": resolved_team_lookup,
+            "service_ids": service_ids,
+            "severity": severity,
+            "status": status,
+            "started_after": started_after,
+            "started_before": started_before,
+            "custom_field_selected_option_ids": custom_field_selected_option_ids,
+            "sort": sort,
+        }
+
+        return params, filters
+
     @mcp.tool()
     async def list_incidents(
         query: Annotated[
@@ -294,8 +288,7 @@ def register_incident_tools(
         Prefer search_incidents only for lightweight free-text lookups.
         """
         try:
-            params, filters = await prepare_incident_query_context(
-                make_authenticated_request=make_authenticated_request,
+            params, filters = await _prepare_incident_query_context(
                 query=query,
                 teams=teams,
                 team_ids=team_ids,
@@ -429,8 +422,7 @@ def register_incident_tools(
         tool call, while keeping payload size under control.
         """
         try:
-            params, filters = await prepare_incident_query_context(
-                make_authenticated_request=make_authenticated_request,
+            params, filters = await _prepare_incident_query_context(
                 query=query,
                 teams=teams,
                 team_ids=team_ids,
@@ -657,6 +649,100 @@ def register_incident_tools(
                 ),
             )
 
+    @mcp.tool(name="createIncident")
+    async def create_incident(
+        title: Annotated[
+            str | None,
+            Field(description="Incident title. If omitted, Rootly may autogenerate one."),
+        ] = None,
+        summary: Annotated[
+            str | None,
+            Field(description="Incident summary or short description."),
+        ] = None,
+        severity_id: Annotated[
+            str | None,
+            Field(description="Optional severity ID to attach to the incident."),
+        ] = None,
+        service_ids: Annotated[
+            str | None,
+            Field(description="Comma-separated service IDs to attach to the incident."),
+        ] = None,
+        team_ids: Annotated[
+            str | None,
+            Field(description="Comma-separated team IDs to attach to the incident."),
+        ] = None,
+        environment_ids: Annotated[
+            str | None,
+            Field(description="Comma-separated environment IDs to attach to the incident."),
+        ] = None,
+        incident_type_ids: Annotated[
+            str | None,
+            Field(description="Comma-separated incident type IDs to attach to the incident."),
+        ] = None,
+    ) -> JsonDict:
+        """Create an incident with a scoped set of fields for agent-driven workflows."""
+        normalized_title = _normalize_optional_text(title)
+        normalized_summary = _normalize_optional_text(summary)
+
+        if normalized_title is None and normalized_summary is None:
+            return cast(
+                JsonDict,
+                mcp_error.tool_error(
+                    "Must provide at least one of title or summary",
+                    "validation_error",
+                ),
+            )
+
+        attributes: dict[str, Any] = {}
+
+        if normalized_title is not None:
+            attributes["title"] = normalized_title
+        if normalized_summary is not None:
+            attributes["summary"] = normalized_summary
+
+        normalized_severity_id = _normalize_optional_text(severity_id)
+        if normalized_severity_id is not None:
+            attributes["severity_id"] = normalized_severity_id
+
+        csv_attribute_map = (
+            ("service_ids", service_ids),
+            ("group_ids", team_ids),
+            ("environment_ids", environment_ids),
+            ("incident_type_ids", incident_type_ids),
+        )
+        for attribute_name, raw_value in csv_attribute_map:
+            if raw_value is None:
+                continue
+            values = _split_csv_values(raw_value)
+            if values:
+                attributes[attribute_name] = values
+
+        payload = {
+            "data": {
+                "type": "incidents",
+                "attributes": attributes,
+            }
+        }
+
+        try:
+            response = await make_authenticated_request("POST", "/v1/incidents", json=payload)
+            response.raise_for_status()
+
+            response_data = response.json()
+            if isinstance(response_data.get("data"), dict):
+                stripped = strip_heavy_nested_data({"data": [response_data["data"]]})
+                response_data["data"] = stripped["data"][0]
+            return cast(JsonDict, response_data)
+        except Exception as e:
+            error_type, error_message = mcp_error.categorize_error(e)
+            return cast(
+                JsonDict,
+                mcp_error.tool_error(
+                    f"Failed to create incident: {error_message}",
+                    error_type,
+                ),
+            )
+
     @mcp.tool(name="updateIncident")
     async def update_incident(
         incident_id: Annotated[str, Field(description="Incident ID to update")],

{rootly_mcp_server-2.2.18 → rootly_mcp_server-2.2.19}/tests/unit/test_tools.py

@@ -143,9 +143,74 @@ class TestScopedIncidentUpdateTool:
     async def test_update_incident_tool_is_registered_with_customer_facing_name(self):
         tools, _ = self._register_tools()
 
+        assert "createIncident" in tools
         assert "updateIncident" in tools
         assert "getIncident" in tools
 
+    @pytest.mark.asyncio
+    async def test_create_incident_sends_only_allowed_fields(self):
+        tools, request = self._register_tools()
+        response = Mock()
+        response.raise_for_status.return_value = None
+        response.json.return_value = {
+            "data": {
+                "id": "inc-123",
+                "type": "incidents",
+                "attributes": {
+                    "title": "Database latency spike",
+                    "summary": "Primary API requests timing out",
+                    "severity_id": "sev-1",
+                    "service_ids": ["svc-1", "svc-2"],
+                    "group_ids": ["team-1", "team-2"],
+                    "environment_ids": ["env-1"],
+                    "incident_type_ids": ["type-1"],
+                },
+            }
+        }
+        request.return_value = response
+
+        result = await tools["createIncident"](
+            title="  Database latency spike  ",
+            summary=" Primary API requests timing out ",
+            severity_id=" sev-1 ",
+            service_ids="svc-1, svc-2",
+            team_ids="team-1, team-2",
+            environment_ids="env-1",
+            incident_type_ids="type-1",
+        )
+
+        request.assert_awaited_once_with(
+            "POST",
+            "/v1/incidents",
+            json={
+                "data": {
+                    "type": "incidents",
+                    "attributes": {
+                        "title": "Database latency spike",
+                        "summary": "Primary API requests timing out",
+                        "severity_id": "sev-1",
+                        "service_ids": ["svc-1", "svc-2"],
+                        "group_ids": ["team-1", "team-2"],
+                        "environment_ids": ["env-1"],
+                        "incident_type_ids": ["type-1"],
+                    },
+                }
+            },
+        )
+        assert result["data"]["id"] == "inc-123"
+        assert result["data"]["attributes"]["title"] == "Database latency spike"
+
+    @pytest.mark.asyncio
+    async def test_create_incident_requires_title_or_summary(self):
+        tools, request = self._register_tools()
+
+        result = await tools["createIncident"](title="   ", summary=None)
+
+        request.assert_not_called()
+        assert result["error"] is True
+        assert result["error_type"] == "validation_error"
+        assert "Must provide at least one of title or summary" in result["message"]
+
     @pytest.mark.asyncio
     async def test_get_incident_fetches_single_incident(self):
         tools, request = self._register_tools()

{rootly_mcp_server-2.2.18 → rootly_mcp_server-2.2.19}/uv.lock

@@ -1702,7 +1702,7 @@ wheels = [
 
 [[package]]
 name = "rootly-mcp-server"
-version = "2.2.16"
+version = "2.2.19"
 source = { editable = "." }
 dependencies = [
     { name = "authlib" },