refactor(application): rename storage envelope key aws_error to provider_error with read-side alias

Outer envelope key in error_details is renamed to be provider-neutral. The read side
accepts both old and new key names so persisted records written before this change keep
working. Inner AWS-specific dict keys (aws_request_id, aws_error_code, aws_error_message)
remain — they are AWS exception field names, not shared types.

Author: fgogolli

src/orb/application/request/dto.py

@@ -117,7 +117,8 @@ class RequestDTO(BaseDTO):
     version: int = 0
     resource_ids: list[str] = Field(default_factory=list)
     # Structured error block surfaced when status is failed or partial.
-    # Populated from error_details["aws_error"] when an AWS API error was captured.
+    # Populated from error_details["provider_error"] (or legacy "aws_error") when
+    # an AWS API error was captured.
     error: Optional[dict[str, Any]] = None
     # Capacity fields from ProviderFulfilment — present when the provider emits them.
     # For weighted fleets target_units and fulfilled_units reflect capacity units;
@@ -170,9 +171,13 @@ def from_domain(
                     resolved_fulfilment = None
 
         # Build structured error block from error_details when available.
-        error_block: Optional[dict[str, Any]] = (
-            request.error_details.get("aws_error") if request.error_details else None
-        )
+        # Accept both "provider_error" (new) and legacy "aws_error" so that
+        # records persisted before this deploy continue to surface the error block.
+        error_block: Optional[dict[str, Any]] = None
+        if request.error_details:
+            error_block = request.error_details.get("provider_error") or request.error_details.get(
+                "aws_error"
+            )
 
         # Create the DTO with all available fields
         return cls(

src/orb/application/services/request_status_management_service.py

@@ -117,7 +117,7 @@ def _handle_provisioning_failure(self, request: Any, provisioning_result: Any) -
 
             # Merge into error_details so it survives serialization / persistence.
             current = dict(request.error_details) if request.error_details else {}
-            current["aws_error"] = aws_error_block
+            current["provider_error"] = aws_error_block
             # Pydantic freeze-safe: use model_copy for the error_details field.
             from orb.domain.request.aggregate import Request as RequestAggregate
 

tests/providers/aws/unit/test_aws_error_propagation.py

@@ -8,9 +8,9 @@
     and returns None values for non-AWSError exceptions.
   - ProvisioningResult carries AWS error fields through from the exception.
   - RequestStatusManagementService._handle_provisioning_failure writes
-    error_details["aws_error"] onto the Request aggregate.
-  - RequestDTO.from_domain exposes error_details["aws_error"] as the top-level
-    error field; to_dict includes the error block only when present.
+    error_details["provider_error"] onto the Request aggregate.
+  - RequestDTO.from_domain exposes error_details["provider_error"] (or legacy
+    "aws_error") as the top-level error field; to_dict includes it only when present.
 """
 
 from __future__ import annotations
@@ -207,7 +207,7 @@ def test_partial_aws_error_attrs(self):
 
 
 class TestHandleProvisioningFailure:
-    """error_details["aws_error"] is written when provisioning fails with AWS context."""
+    """error_details["provider_error"] is written when provisioning fails with AWS context."""
 
     def _make_service(self):
         from orb.application.services.request_status_management_service import (
@@ -265,10 +265,10 @@ def test_no_aws_fields_leaves_error_details_clean(self):
         result = self._make_provisioning_result(error_message="generic error")
         updated = svc._handle_provisioning_failure(request, result)
         # aws_error key should be absent when no AWS details are available
-        assert "aws_error" not in updated.error_details
+        assert "provider_error" not in updated.error_details
 
     def test_aws_error_code_written_to_error_details(self):
-        """UnauthorizedOperation is stored in error_details["aws_error"]["code"]."""
+        """UnauthorizedOperation is stored in error_details["provider_error"]["code"]."""
         svc = self._make_service()
         request = self._make_real_request()
         result = self._make_provisioning_result(
@@ -279,7 +279,7 @@ def test_aws_error_code_written_to_error_details(self):
             error_source="aws.ec2.run_instances",
         )
         updated = svc._handle_provisioning_failure(request, result)
-        aws_err = updated.error_details.get("aws_error", {})
+        aws_err = updated.error_details.get("provider_error", {})
         assert aws_err["code"] == "UnauthorizedOperation"
         assert aws_err["message"] == "You are not authorized."
         assert aws_err["aws_request_id"] == "rid-aws-001"
@@ -295,7 +295,7 @@ def test_partial_aws_fields_stored(self):
             # aws_error_message, aws_request_id, error_source intentionally absent
         )
         updated = svc._handle_provisioning_failure(request, result)
-        aws_err = updated.error_details.get("aws_error", {})
+        aws_err = updated.error_details.get("provider_error", {})
         assert aws_err["code"] == "InsufficientInstanceCapacity"
         assert "message" not in aws_err
         assert "aws_request_id" not in aws_err