@@ -71,7 +71,9 @@
 SERVICE, INVOICING_ENTITY and OPERATING_SYSTEM are NOT valid group_by attributes here —
 grouping coverage by them returns a ValidationException. SERVICE is a FILTER dimension instead: pass it in
 `filter` (one SERVICE value per call; if you omit a SERVICE filter, Cost Explorer
-defaults to EC2), and call once per service to compare across services.
+defaults to EC2), and call once per service to compare across services. A filter
+with more than one SERVICE value is rejected, because Cost Explorer returns each
+service's figures without saying which service they belong to.
 Reservation coverage applies only to reservable services. The valid SERVICE
 filter values are "Amazon Elastic Compute Cloud - Compute" (the default when
 omitted), "Amazon Relational Database Service", "Amazon ElastiCache",
@@ -147,7 +149,7 @@ async def ri_performance(
         granularity: Time granularity of the data (DAILY or MONTHLY). Defaults to DAILY. Ignored when group_by is provided (granularity and group_by are mutually exclusive).
         metrics: List of metrics to retrieve for coverage as a JSON string (e.g., '["Hour", "Cost"]'). Valid values are Hour, Unit and Cost; Unit is EC2 only. Defaults to Hour only.
         group_by: Optional grouping as a JSON string. For coverage: AZ, CACHE_ENGINE, DATABASE_ENGINE, DEPLOYMENT_OPTION, INSTANCE_TYPE, INSTANCE_TYPE_FAMILY, LINKED_ACCOUNT, PLATFORM, REGION, or TENANCY, depending on the service (see the tool description) (SERVICE is NOT valid — filter on it instead). For utilization: SUBSCRIPTION_ID only.
-        filter: Optional filter as a JSON string (e.g., by service, region, or instance type). SERVICE defaults to EC2 when omitted; valid coverage SERVICE values are "Amazon Elastic Compute Cloud - Compute", "Amazon Relational Database Service", "Amazon ElastiCache", "Amazon MemoryDB", "Amazon Redshift", "Amazon OpenSearch Service", and "Amazon Elasticsearch Service" (use the full display name, not "EC2"/"RDS"). SubscriptionId values are numeric, not ARNs/UUIDs. A wide grouped/DAILY query may exceed the result size cap (ToolResultOversized) — scope it with a filter, a shorter window, or MONTHLY granularity.
+        filter: Optional filter as a JSON string (e.g., by service, region, or instance type). SERVICE defaults to EC2 when omitted; valid coverage SERVICE values are "Amazon Elastic Compute Cloud - Compute", "Amazon Relational Database Service", "Amazon ElastiCache", "Amazon MemoryDB", "Amazon Redshift", "Amazon OpenSearch Service", and "Amazon Elasticsearch Service" (use the full display name, not "EC2"/"RDS"); coverage takes one SERVICE value per call and rejects more. SubscriptionId values are numeric, not ARNs/UUIDs. A wide grouped/DAILY query may exceed the result size cap (ToolResultOversized) — scope it with a filter, a shorter window, or MONTHLY granularity.
         sort_by: Optional sorting configuration as a JSON string with key and direction (ASCENDING or DESCENDING).
         max_items: Total number of groups to return across all pages. Omit it to fetch every
             page. Applies only to get_reservation_coverage with group_by set.
@@ -206,6 +208,28 @@ async def ri_performance(
         return await handle_aws_error(ctx, e, 'ri_performance', 'Cost Explorer')
 
 
+def _selected_services(expression: Any) -> List[str]:
+    """Return the distinct SERVICE values a filter expression selects, in order.
+
+    Walks Dimensions and nested And / Or. Values under Not are not counted: Cost Explorer
+    does not split coverage by them (a Not on SERVICE matches no usage).
+    """
+    if not isinstance(expression, dict):
+        return []
+    services: List[str] = []
+    dimension = expression.get('Dimensions')
+    if isinstance(dimension, dict) and dimension.get('Key') == 'SERVICE':
+        values = dimension.get('Values')
+        if isinstance(values, list):
+            services.extend(v for v in values if isinstance(v, str))
+    for operator in ('And', 'Or'):
+        operands = expression.get(operator)
+        if isinstance(operands, list):
+            for operand in operands:
+                services.extend(_selected_services(operand))
+    return list(dict.fromkeys(services))
+
+
 def _count_groups(entries: List[Dict[str, Any]]) -> int:
     """Count the groups across a page's time-period entries."""
     return sum(len(entry.get('Groups') or []) for entry in entries)
@@ -316,6 +340,17 @@ async def get_reservation_coverage(
 
         if filter_expr:
             request_params['Filter'] = parse_json(filter_expr, 'filter')
+            # With several SERVICE values the API returns one entry per service for the same
+            # period (grouped: groups of every service), none saying which service it holds.
+            services = _selected_services(request_params['Filter'])
+            if len(services) > 1:
+                named = ', '.join(f'"{service}"' for service in services)
+                raise ValueError(
+                    'get_reservation_coverage takes one SERVICE value per call, but the filter '
+                    f'names {len(services)}: {named}. Cost Explorer would return their figures '
+                    'without saying which service each belongs to; call once per service and '
+                    'combine the results.'
+                )
 
         if sort_by:
             request_params['SortBy'] = parse_json(sort_by, 'sort_by')
 
@@ -23,6 +23,7 @@
 """
 
 import botocore.session
+import json
 import pytest
 import re
 from awslabs.billing_cost_management_mcp_server.tools.ri_performance_tools import (
@@ -1258,6 +1259,108 @@ async def test_ungrouped_coverage_sends_granularity_to_api_call(self, mock_conte
         assert kwargs['Granularity'] == 'MONTHLY'
 
 
+EC2_SERVICE = 'Amazon Elastic Compute Cloud - Compute'
+RDS_SERVICE = 'Amazon Relational Database Service'
+REGION_FILTER = {'Dimensions': {'Key': 'REGION', 'Values': ['us-east-1', 'us-west-2']}}
+
+
+def _service_filter(*values):
+    return {'Dimensions': {'Key': 'SERVICE', 'Values': list(values)}}
+
+
+@pytest.mark.asyncio
+class TestCoverageServiceFilter:
+    """GetReservationCoverage takes one SERVICE value per call.
+
+    With several, the API returns one unlabeled entry per service for the same period (or,
+    grouped, groups of every service with no service attribute), so they are rejected.
+    """
+
+    @pytest.mark.parametrize(
+        'filter_expr',
+        [
+            _service_filter(EC2_SERVICE, RDS_SERVICE),
+            {'And': [_service_filter(EC2_SERVICE, RDS_SERVICE), REGION_FILTER]},
+            {'Or': [_service_filter(EC2_SERVICE), _service_filter(RDS_SERVICE)]},
+        ],
+        ids=['dimensions', 'nested_and', 'or_of_single_values'],
+    )
+    @pytest.mark.parametrize(
+        'group_by',
+        [None, '[{"Type": "DIMENSION", "Key": "REGION"}]'],
+        ids=['ungrouped', 'grouped'],
+    )
+    async def test_more_than_one_service_is_rejected_before_the_api_call(
+        self, mock_context, filter_expr, group_by
+    ):
+        """Two SERVICE values return a validation_error and Cost Explorer is never called."""
+        client = MagicMock()
+
+        result = await _call_tool(
+            client,
+            mock_context,
+            operation='get_reservation_coverage',
+            granularity='MONTHLY',
+            group_by=group_by,
+            filter=json.dumps(filter_expr),
+        )
+
+        assert result['status'] == 'error'
+        assert result['error_type'] == 'validation_error'
+        message = result['message']
+        assert 'one SERVICE value per call' in message
+        assert f'"{EC2_SERVICE}"' in message and f'"{RDS_SERVICE}"' in message
+        assert 'call once per service' in message
+        client.get_reservation_coverage.assert_not_called()
+
+    @pytest.mark.parametrize(
+        'filter_expr',
+        [
+            _service_filter(EC2_SERVICE),
+            _service_filter(RDS_SERVICE, RDS_SERVICE),
+            {'Not': _service_filter(EC2_SERVICE, RDS_SERVICE)},
+            {'And': [_service_filter(RDS_SERVICE), {'Not': _service_filter(EC2_SERVICE)}]},
+            REGION_FILTER,
+            # A malformed operand is left for Cost Explorer to reject.
+            {'And': ['not-an-expression', _service_filter(EC2_SERVICE)]},
+            {'Dimensions': {'Key': 'SERVICE', 'Values': RDS_SERVICE}},
+        ],
+        ids=[
+            'one_value',
+            'repeated_value',
+            'not',
+            'one_value_and_not',
+            'no_service',
+            'malformed_operand',
+            'values_not_a_list',
+        ],
+    )
+    async def test_at_most_one_selected_service_reaches_the_api(self, mock_context, filter_expr):
+        """One distinct SERVICE value, or values only under Not, pass through unchanged."""
+        client = MagicMock()
+        client.get_reservation_coverage.return_value = {'CoveragesByTime': []}
+
+        result = await _call_tool(
+            client,
+            mock_context,
+            operation='get_reservation_coverage',
+            granularity='MONTHLY',
+            filter=json.dumps(filter_expr),
+        )
+
+        assert result['status'] == 'success'
+        assert client.get_reservation_coverage.call_args.kwargs['Filter'] == filter_expr
+
+    async def test_description_says_the_limit_is_enforced(self):
+        """The description states that more than one SERVICE value is rejected."""
+        description = ' '.join((await _ri_description()).split())
+        assert 'more than one SERVICE value is rejected' in description
+        tool = await ri_performance_server.get_tool('ri-performance')
+        assert tool is not None
+        filter_doc = tool.parameters['properties']['filter'].get('description', '')
+        assert 'coverage takes one SERVICE value per call and rejects more' in filter_doc
+
+
 @pytest.mark.asyncio
 class TestMaxPages:
     """get_reservation_utilization takes max_pages; coverage keeps max_items."""