createIncidentActionItem

Generate an action item for a specific incident, including details like summary, priority, status, and assigned users or groups, to track and resolve tasks effectively.

Instructions

Creates a new action item from provided data

Path Parameters:

incident_id (Required): No description.

Responses:

201 (Success): incident_action_item created
- Content-Type: application/vnd.api+json
- Example:

{
  "key": "value"
}

401: responds with unauthorized for invalid token
- Content-Type: application/vnd.api+json
- Example:

{
  "key": "value"
}

422: invalid request
- Content-Type: application/vnd.api+json
- Example:

{
  "key": "value"
}

Input Schema

TableJSON Schema

Name	Required	Description	Default
`data`	Yes
`incident_id`	Yes

Implementation Reference

src/rootly_mcp_server/server.py:337-344 (registration)
The FastMCP.from_openapi call dynamically generates and registers all MCP tools from the filtered OpenAPI specification, including the 'createIncidentActionItem' tool derived from POST /incident_action_items or POST /incidents/{incident_id}/action_items endpoints.
```
# By default, all routes become tools which is what we want
mcp = FastMCP.from_openapi(
    openapi_spec=filtered_spec,
    client=http_client.client,
    name=name,
    timeout=30.0,
    tags={"rootly", "incident-management"},
)
```

src/rootly_mcp_server/server.py:121-172 (helper)

Defines the allowed API paths that are exposed as MCP tools. Includes paths for incident action items (/incident_action_items, /incidents/{incident_id}/action_items) from which the createIncidentActionItem tool is generated.

DEFAULT_ALLOWED_PATHS = [
    "/incidents/{incident_id}/alerts",
    "/alerts",
    "/alerts/{alert_id}",
    "/severities",
    "/severities/{severity_id}",
    "/teams",
    "/teams/{team_id}",
    "/services",
    "/services/{service_id}",
    "/functionalities",
    "/functionalities/{functionality_id}",
    # Incident types
    "/incident_types",
    "/incident_types/{incident_type_id}",
    # Action items (all, by id, by incident)
    "/incident_action_items",
    "/incident_action_items/{incident_action_item_id}",
    "/incidents/{incident_id}/action_items",
    # Workflows
    "/workflows",
    "/workflows/{workflow_id}",
    # Workflow runs
    "/workflow_runs",
    "/workflow_runs/{workflow_run_id}",
    # Environments
    "/environments",
    "/environments/{environment_id}",
    # Users
    "/users",
    "/users/{user_id}",
    "/users/me",
    # Status pages
    "/status_pages",
    "/status_pages/{status_page_id}",
    # On-call schedules and shifts
    "/schedules",
    "/schedules/{schedule_id}",
    "/schedules/{schedule_id}/shifts",
    "/shifts",
    "/schedule_rotations/{schedule_rotation_id}",
    "/schedule_rotations/{schedule_rotation_id}/schedule_rotation_users",
    "/schedule_rotations/{schedule_rotation_id}/schedule_rotation_active_days",
    # On-call overrides
    "/schedules/{schedule_id}/override_shifts",
    "/override_shifts/{override_shift_id}",
    # On-call shadows and roles
    "/schedules/{schedule_id}/on_call_shadows",
    "/on_call_shadows/{on_call_shadow_id}",
    "/on_call_roles",
    "/on_call_roles/{on_call_role_id}",
]

src/rootly_mcp_server/server.py:227-234 (handler)

The AuthenticatedHTTPXClient.request method handles all HTTP requests for generated MCP tools, including the API call to create an incident action item.

async def request(self, method: str, url: str, **kwargs):
    """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 and let it handle everything
    return await self.client.request(method, url, **kwargs)

src/rootly_mcp_server/utils.py:45-105 (schema)

Sanitizes parameter names in the OpenAPI spec to make them MCP-compliant. Called before tool registration to prepare input schemas for all generated tools including createIncidentActionItem.

def sanitize_parameters_in_spec(spec: Dict[str, Any]) -> Dict[str, str]:
    """
    Sanitize all parameter names in an OpenAPI specification.
    
    This function modifies the spec in-place and builds a mapping 
    of sanitized names to original names.
    
    Args:
        spec: OpenAPI specification dictionary
        
    Returns:
        Dictionary mapping sanitized names to original names
    """
    parameter_mapping = {}
    
    # Sanitize parameters in paths
    if "paths" in spec:
        for path, path_item in spec["paths"].items():
            if not isinstance(path_item, dict):
                continue
                
            # Sanitize path-level parameters
            if "parameters" in path_item:
                for param in path_item["parameters"]:
                    if "name" in param:
                        original_name = param["name"]
                        sanitized_name = sanitize_parameter_name(original_name)
                        if sanitized_name != original_name:
                            logger.debug(f"Sanitized path-level parameter: '{original_name}' -> '{sanitized_name}'")
                            param["name"] = sanitized_name
                            parameter_mapping[sanitized_name] = original_name
            
            # Sanitize operation-level parameters
            for method, operation in path_item.items():
                if method.lower() not in ["get", "post", "put", "delete", "patch", "options", "head", "trace"]:
                    continue
                if not isinstance(operation, dict):
                    continue
                    
                if "parameters" in operation:
                    for param in operation["parameters"]:
                        if "name" in param:
                            original_name = param["name"]
                            sanitized_name = sanitize_parameter_name(original_name)
                            if sanitized_name != original_name:
                                logger.debug(f"Sanitized operation parameter: '{original_name}' -> '{sanitized_name}'")
                                param["name"] = sanitized_name
                                parameter_mapping[sanitized_name] = original_name
    
    # Sanitize parameters in components (OpenAPI 3.0)
    if "components" in spec and "parameters" in spec["components"]:
        for param_name, param_def in spec["components"]["parameters"].items():
            if isinstance(param_def, dict) and "name" in param_def:
                original_name = param_def["name"]
                sanitized_name = sanitize_parameter_name(original_name)
                if sanitized_name != original_name:
                    logger.debug(f"Sanitized component parameter: '{original_name}' -> '{sanitized_name}'")
                    param_def["name"] = sanitized_name
                    parameter_mapping[sanitized_name] = original_name
    
    return parameter_mapping

src/rootly_mcp_server/server.py:315-320 (schema)

Filters and sanitizes the OpenAPI spec to include only allowed paths and prepare schemas for MCP tool generation.

filtered_spec = _filter_openapi_spec(swagger_spec, allowed_paths_v1)
logger.info(f"Filtered spec to {len(filtered_spec.get('paths', {}))} allowed paths")

# Sanitize all parameter names in the filtered spec to be MCP-compliant
parameter_mapping = sanitize_parameters_in_spec(filtered_spec)
logger.info(f"Sanitized parameter names for MCP compatibility (mapped {len(parameter_mapping)} parameters)")

Rootly MCP server