@@ -43,6 +43,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Corrected AWS Compute Optimizer ECS and Lambda recommendation response field names that read non-existent SDK fields and returned null. ECS now reads `currentPerformanceRisk`, `autoScalingConfiguration`, and `projectedUtilizationMetrics` (previously the non-existent `currentPerformance`, `autoScalingGroupArn`, and `projectedPerformance`), and Lambda derives the function name from the ARN (there is no `functionName` field).
 - Fixed `aws-pricing` tool error responses omitting a structured error type. Each `aws-pricing` operation caught exceptions and returned `format_response('error', ...)` (everything nested under `data`, no top-level `error_type`/`operation`), so the `handle_aws_error` call in the tool wrapper was never reached and failures surfaced without a classifiable type. Operation error paths now route through `handle_aws_error` so responses carry top-level `error_type` and `operation`, and the two non-exception "no results" cases (`get_service_attributes` service-not-found, `get_pricing_from_api` empty price list) carry `error_type='no_results'` plus `operation`. The legacy `data` payload is preserved for backward compatibility.
 - Fixed `session-sql` tool error responses omitting a structured error type. `execute_session_sql` caught every failure and returned a bare `{'status': 'error', 'message': ...}` with no `error_type`/`operation`, so failures surfaced without a classifiable type. Error responses now carry top-level `error_type`, `operation` (`session_sql`), and `service` (`SQL`). The `error_type` is the exception class name (e.g. `OperationalError`, `IntegrityError`, `ValueError`) -- a fixed identifier that never contains the query text or bound values, so no query content is exposed. The legacy `status='error'` and `message` payload is preserved for backward compatibility.
+- Fixed `bcm-pricing-calc`, `cost-anomaly`, and `cost-explorer` error responses missing a structured error type. `bcm-pricing-calc` read the AWS message from a non-existent `data.error` key and reported every `get_preferences` failure (including `AccessDenied`) only as `PREFERENCES_NOT_CONFIGURED`; error responses now carry top-level `error_type`, `operation`, and `service`. `cost-anomaly` local input validation (bad date format, `start_date` after `end_date`, a future `end_date`, unknown `feedback`/`total_impact_operator`, missing `total_impact_end`) now carries top-level `error_type='validation_error'`, `operation`, and `service`. `cost-explorer` client-creation failures now carry top-level `error_type='client_creation_error'`, `operation`, and `service`. The legacy `data` payload is preserved for backward compatibility.
 - Fixed the AWS Compute Optimizer `get_idle_recommendations` operation rejecting `ResourceType` and `Finding` filter values whose casing differs from the idle enums (e.g. `EbsVolume` instead of `EBSVolume`, `idle` instead of `Idle`). Passed values are now normalized case-insensitively against the idle enums read from the installed botocore service model, and the response echoes the normalized filters as `applied_filters`. An `InvalidParameterValueException` now returns a structured error listing `valid_resource_type_values` and `valid_finding_values` so callers can self-correct instead of retrying the same request.
 
 ## [0.0.4] - 2025-10-27
 
@@ -41,6 +41,29 @@
 )
 
 
+def _preferences_error_response(preferences_result: Dict[str, Any]) -> Dict[str, Any]:
+    """Build the error response for a failed get_preferences check.
+
+    Keeps the legacy data payload and adds top-level error_type, operation, and
+    service, so an AWS failure (e.g. AccessDenied) is not reported only as
+    PREFERENCES_NOT_CONFIGURED.
+
+    Args:
+        preferences_result: The dict returned by get_preferences on failure.
+
+    Returns:
+        Dict containing the error response
+    """
+    return format_response(
+        'error',
+        {'error': preferences_result['error'], 'error_code': 'PREFERENCES_NOT_CONFIGURED'},
+        preferences_result['error'],
+        error_type=preferences_result.get('error_type', 'PREFERENCES_NOT_CONFIGURED'),
+        operation='get_preferences',
+        service=BCM_PRICING_CALCULATOR_SERVICE_NAME,
+    )
+
+
 async def bcm_pricing_calc_core(
     ctx: Context,
     operation: str,
@@ -139,11 +162,7 @@ async def bcm_pricing_calc_core(
         elif operation == 'get_preferences':
             preferences_result = await get_preferences(ctx)
             if 'error' in preferences_result:
-                return format_response(
-                    'error',
-                    {'error': preferences_result['error']},
-                    preferences_result['error'],
-                )
+                return _preferences_error_response(preferences_result)
             else:
                 return format_response(
                     'success',
@@ -158,15 +177,19 @@ async def bcm_pricing_calc_core(
     except Exception as e:
         # Use shared error handler for consistent error handling
         error_response = await handle_aws_error(
-            ctx, e, operation, 'AWS Billing and Cost Management Pricing Calculator'
-        )
-        await ctx.error(
-            f'Failed to process AWS Billing and Cost Management Pricing Calculator request: {error_response.get("data", {}).get("error", str(e))}'
+            ctx, e, operation, BCM_PRICING_CALCULATOR_SERVICE_NAME
         )
+        # handle_aws_error puts the message and classification at the top level.
+        error_message = error_response.get('message', str(e))
+        full_message = f'Failed to process AWS Billing and Cost Management Pricing Calculator request: {error_message}'
+        await ctx.error(full_message)
         return format_response(
             'error',
-            {'error': error_response.get('data', {}).get('error', str(e))},
-            f'Failed to process AWS Billing and Cost Management Pricing Calculator request: {error_response.get("data", {}).get("error", str(e))}',
+            {'error': error_message},
+            full_message,
+            error_type=error_response.get('error_type', 'unknown_error'),
+            operation=operation,
+            service=BCM_PRICING_CALCULATOR_SERVICE_NAME,
         )
 
 
@@ -331,9 +354,12 @@ async def get_preferences(ctx: Context) -> dict:
         error_response = await handle_aws_error(
             ctx, e, 'get_preferences', BCM_PRICING_CALCULATOR_SERVICE_NAME
         )
-        error_msg = f'Failed to check BCM Pricing Calculator preferences: {error_response.get("data", {}).get("error", str(e))}'
+        error_msg = f'Failed to check BCM Pricing Calculator preferences: {error_response.get("message", str(e))}'
         await ctx.error(error_msg)
-        return {'error': error_msg}
+        return {
+            'error': error_msg,
+            'error_type': error_response.get('error_type', 'unknown_error'),
+        }
 
 
 async def list_workload_estimates(
@@ -383,13 +409,7 @@ async def list_workload_estimates(
         # Check preferences before proceeding
         preferences_result = await get_preferences(ctx)
         if 'error' in preferences_result:
-            return format_response(
-                'error',
-                {
-                    'error': preferences_result['error'],
-                    'error_code': 'PREFERENCES_NOT_CONFIGURED',
-                },
-            )
+            return _preferences_error_response(preferences_result)
 
         request_params: Dict[str, Any] = {}
         # Build request parameters
@@ -553,13 +573,7 @@ async def get_workload_estimate(
         # Check preferences before proceeding
         preferences_result = await get_preferences(ctx)
         if 'error' in preferences_result:
-            return format_response(
-                'error',
-                {
-                    'error': preferences_result['error'],
-                    'error_code': 'PREFERENCES_NOT_CONFIGURED',
-                },
-            )
+            return _preferences_error_response(preferences_result)
 
         # Build request parameters
         request_params: Dict[str, Any] = {'identifier': identifier}
@@ -653,13 +667,7 @@ async def list_workload_estimate_usage(
         # Check preferences before proceeding
         preferences_result = await get_preferences(ctx)
         if 'error' in preferences_result:
-            return format_response(
-                'error',
-                {
-                    'error': preferences_result['error'],
-                    'error_code': 'PREFERENCES_NOT_CONFIGURED',
-                },
-            )
+            return _preferences_error_response(preferences_result)
 
         request_params: Dict[str, Any] = {}
         # Build request parameters
 
@@ -92,13 +92,19 @@ async def cost_anomaly(
                 'error',
                 {'invalid_parameter': 'start_date'},
                 f'Invalid start_date format: {start_date}. Date must be in YYYY-MM-DD format.',
+                error_type='validation_error',
+                operation='cost_anomaly',
+                service='Cost Explorer',
             )
 
         if not validate_date_format(end_date):
             return format_response(
                 'error',
                 {'invalid_parameter': 'end_date'},
                 f'Invalid end_date format: {end_date}. Date must be in YYYY-MM-DD format.',
+                error_type='validation_error',
+                operation='cost_anomaly',
+                service='Cost Explorer',
             )
 
         # Parse dates for validation
@@ -115,6 +121,9 @@ async def cost_anomaly(
                 'error',
                 {'start_date': start_date, 'end_date': end_date},
                 'Invalid date range: start_date must be before or equal to end_date.',
+                error_type='validation_error',
+                operation='cost_anomaly',
+                service='Cost Explorer',
             )
 
         # Check if dates are in the future
@@ -123,6 +132,9 @@ async def cost_anomaly(
                 'error',
                 {'end_date': end_date},
                 'Invalid end_date: Cannot request anomalies for future dates.',
+                error_type='validation_error',
+                operation='cost_anomaly',
+                service='Cost Explorer',
             )
 
         # Check if dates are beyond the 90-day lookback period
@@ -149,6 +161,9 @@ async def cost_anomaly(
                 'error',
                 {'invalid_parameter': 'feedback', 'value': feedback},
                 f'Invalid feedback value: {feedback}. Must be one of: YES, NO, PLANNED_ACTIVITY.',
+                error_type='validation_error',
+                operation='cost_anomaly',
+                service='Cost Explorer',
             )
 
         # Validate total impact operator if provided
@@ -165,6 +180,9 @@ async def cost_anomaly(
                 'error',
                 {'invalid_parameter': 'total_impact_operator', 'value': total_impact_operator},
                 f'Invalid total_impact_operator: {total_impact_operator}. Must be one of: {", ".join(valid_operators)}',
+                error_type='validation_error',
+                operation='cost_anomaly',
+                service='Cost Explorer',
             )
 
         # Validate total_impact_end is provided when using BETWEEN operator
@@ -173,6 +191,9 @@ async def cost_anomaly(
                 'error',
                 {'missing_parameter': 'total_impact_end'},
                 'When using BETWEEN operator for total_impact, both total_impact_start and total_impact_end must be provided.',
+                error_type='validation_error',
+                operation='cost_anomaly',
+                service='Cost Explorer',
             )
 
         await ctx_logger.info(f'Retrieving cost anomalies from {start_date} to {end_date}')
@@ -196,7 +217,12 @@ async def cost_anomaly(
     except ValueError as e:
         # Handle date parsing errors
         return format_response(
-            'error', {'error_type': 'validation_error'}, f'Date validation error: {str(e)}'
+            'error',
+            {'error_type': 'validation_error'},
+            f'Date validation error: {str(e)}',
+            error_type='validation_error',
+            operation='cost_anomaly',
+            service='Cost Explorer',
         )
     except ClientError as e:
         # Handle AWS service-specific errors
 
@@ -28,7 +28,6 @@
     get_tags,
     get_usage_forecast,
 )
-from botocore.exceptions import ClientError
 from fastmcp import Context, FastMCP
 from typing import Any, Dict, Optional
 
@@ -209,13 +208,18 @@ async def cost_explorer(
         ce_client = create_aws_client('ce')
     except Exception as client_error:
         await ctx.error(f'Failed to create AWS client: {str(client_error)}')
+        error_message = f'Failed to create AWS client: {str(client_error)}'
         return format_response(
             'error',
             {
                 'error_type': 'client_creation_error',
-                'message': f'Failed to create AWS client: {str(client_error)}',
+                'message': error_message,
                 'details': repr(client_error),
             },
+            error_message,
+            error_type='client_creation_error',
+            operation=operation,
+            service='Cost Explorer',
         )
 
     # Route to the appropriate operation handler
@@ -346,9 +350,6 @@ async def cost_explorer(
         else:
             return format_response('error', {'message': f'Unknown operation: {operation}'})
 
-    except ClientError as e:
-        # Let the shared handler take care of this
-        return await handle_aws_error(ctx, e, operation, 'Cost Explorer')
     except Exception as e:
-        # For all other exceptions, use the shared error handler
+        # The shared handler classifies ClientError and all other exceptions
         return await handle_aws_error(ctx, e, operation, 'Cost Explorer')
@@ -381,13 +381,24 @@ async def paginate_aws_response(
     return all_results, pagination_metadata
 
 
-def format_response(status: str, data: Any, message: Optional[str] = None) -> Dict[str, Any]:
+def format_response(
+    status: str,
+    data: Any,
+    message: Optional[str] = None,
+    *,
+    error_type: Optional[str] = None,
+    operation: Optional[str] = None,
+    service: Optional[str] = None,
+) -> Dict[str, Any]:
     """Format a standard API response.
 
     Args:
         status: Response status ("success" or "error")
         data: Response data payload
         message: Optional message to include
+        error_type: Optional error classification, set at the top level like handle_aws_error
+        operation: Optional name of the operation that produced the response
+        service: Optional AWS service name
 
     Returns:
         Dict containing a standardized response format
@@ -397,4 +408,12 @@ def format_response(status: str, data: Any, message: Optional[str] = None) -> Di
     if message:
         response['message'] = message
 
+    # Only added when supplied, so existing callers keep the same shape
+    if error_type is not None:
+        response['error_type'] = error_type
+    if operation is not None:
+        response['operation'] = operation
+    if service is not None:
+        response['service'] = service
+
     return response