Extract legacy entity failure message from result, not exceptionType

In the WebJobs old-protocol ResponseMessage, exceptionType is only a presence marker / exception type name; the human-readable message is serialized into result. Detect failures by exceptionType presence (or a structured failureDetails object) and take the message from the deserialized result, matching azure-functions-durable-python / -js. Updates the exceptionType test to the real wire shape (message in result, type name in exceptionType) and guards against surfacing the type name.

Author: andystaples

durabletask/internal/helpers.py

@@ -150,22 +150,44 @@ def _failure_details_from_core_dict(fd: dict[str, Any]) -> pb.TaskFailureDetails
     )
 
 
-def entity_response_failure_details(response: dict[str, Any]) -> pb.TaskFailureDetails | None:
-    """Extract failure details from a legacy-protocol entity ``ResponseMessage``.
-
-    The legacy entity protocol (used when the Durable WebJobs extension
-    translates entity operations) delivers operation results as a
-    ``ResponseMessage`` whose ``exceptionType`` (error message) or
-    ``failureDetails`` field is populated when the operation failed. Returns
-    ``None`` when the response represents a successful operation.
+def entity_response_failure_details(
+        response: dict[str, Any],
+        error_content: Any = None) -> pb.TaskFailureDetails:
+    """Build failure details from a failed legacy-protocol entity ``ResponseMessage``.
+
+    Call this only for responses that :func:`is_entity_error_response` reports as
+    failures. In the WebJobs "old protocol" ``ResponseMessage`` (see
+    ``EntityScheduler/ResponseMessage.cs``), a failed operation serializes the
+    human-readable content into ``result`` while ``exceptionType`` carries only
+    the exception's type name (a presence marker) -- it is *not* the message.
+    This mirrors ``azure-functions-durable-python`` / ``-js``, which read the
+    message from ``result`` and ignore ``exceptionType``'s value.
+
+    Parameters
+    ----------
+    response:
+        The deserialized ``ResponseMessage`` dict.
+    error_content:
+        The already-deserialized ``result`` payload, used as the failure
+        message. A structured ``failureDetails`` object, if present, takes
+        precedence (current-protocol shape).
     """
     failure_details = response.get("failureDetails")
     if isinstance(failure_details, dict):
         return _failure_details_from_core_dict(cast(dict[str, Any], failure_details))
-    error_message = response.get("exceptionType")
-    if error_message is not None:
-        return pb.TaskFailureDetails(errorType="", errorMessage=str(error_message))
-    return None
+    error_type = str(response.get("exceptionType") or "")
+    error_message = "" if error_content is None else str(error_content)
+    return pb.TaskFailureDetails(errorType=error_type, errorMessage=error_message)
+
+
+def is_entity_error_response(response: dict[str, Any]) -> bool:
+    """Return ``True`` if a legacy-protocol entity ``ResponseMessage`` is a failure.
+
+    In the WebJobs "old protocol" a failed operation is marked by the presence of
+    an ``exceptionType`` field (successful responses omit it). Current-protocol
+    payloads may instead carry a structured ``failureDetails`` object.
+    """
+    return "exceptionType" in response or isinstance(response.get("failureDetails"), dict)
 
 
 def new_event_sent_event(event_id: int, instance_id: str, input: str):

durabletask/worker.py

@@ -2818,18 +2818,24 @@ def _handle_entity_event_raised(self,
         if not ph.is_empty(event.eventRaised.input):
             response = self._data_converter.deserialize(event.eventRaised.input.value)
 
-        # For entity operation calls (lock acquisitions never fail this way), the legacy-protocol
-        # ResponseMessage signals a failed operation via its "exceptionType" (error message) or
-        # "failureDetails" field. Propagate that as a task failure so an awaiting call_entity raises,
-        # matching the new entity protocol and the .NET SDK.
-        if not is_lock_event and isinstance(response, dict):
-            failure_details = ph.entity_response_failure_details(response)
-            if failure_details is not None:
-                failure = EntityOperationFailedException(entity_id, operation or "", failure_details)
-                ctx._entity_context.recover_lock_after_call(entity_id)  # pyright: ignore[reportPrivateUsage]
-                entity_task.fail(str(failure), failure)
-                ctx.resume()
-                return
+        # For entity operation calls (lock acquisitions never fail this way), the legacy WebJobs
+        # "old protocol" ResponseMessage signals a failed operation via the presence of an
+        # "exceptionType" marker (or a structured "failureDetails" object). The human-readable
+        # message lives in the *serialized* "result" field -- "exceptionType" is only the exception
+        # type name, not the message -- so deserialize "result" to recover it, matching
+        # azure-functions-durable-python / -js. Propagate as a task failure so an awaiting
+        # call_entity raises, like the current entity protocol and the .NET SDK.
+        if not is_lock_event and isinstance(response, dict) and ph.is_entity_error_response(response):
+            raw_result = response.get("result")
+            error_content = (
+                self._data_converter.deserialize(raw_result) if isinstance(raw_result, str) else raw_result
+            )
+            failure_details = ph.entity_response_failure_details(response, error_content)
+            failure = EntityOperationFailedException(entity_id, operation or "", failure_details)
+            ctx._entity_context.recover_lock_after_call(entity_id)  # pyright: ignore[reportPrivateUsage]
+            entity_task.fail(str(failure), failure)
+            ctx.resume()
+            return
 
         result = None
         if response is not None:

tests/durabletask/test_orchestration_executor.py

@@ -2096,8 +2096,9 @@ def orchestrator(ctx: task.OrchestrationContext, _):
 
 
 def test_entity_call_failure_propagated_over_old_protocol():
-    """A failed entity operation delivered via the legacy protocol (an eventRaised
-    ResponseMessage with failureDetails) must surface as a TaskFailedError to the caller."""
+    """A failed entity response carrying a structured ``failureDetails`` object
+    (defensively supported, current-protocol shape) must surface as a
+    TaskFailedError with the structured message."""
     test_entity_id = entities.EntityInstanceId("Counter", "myCounter")
 
     def orchestrator(ctx: task.OrchestrationContext, _):
@@ -2122,8 +2123,8 @@ def orchestrator(ctx: task.OrchestrationContext, _):
     assert actions[0].sendEntityMessage.HasField("entityOperationCalled")
     request_id = actions[0].sendEntityMessage.entityOperationCalled.requestId
 
-    # The Durable WebJobs extension translates a failed entity operation into a
-    # legacy-protocol ResponseMessage carrying a serialized FailureDetails.
+    # A structured FailureDetails object, when present, takes precedence over the
+    # WebJobs result/exceptionType fields.
     response_message = {
         "result": None,
         "failureDetails": {
@@ -2148,8 +2149,9 @@ def orchestrator(ctx: task.OrchestrationContext, _):
 
 
 def test_entity_call_failure_propagated_over_old_protocol_exception_type():
-    """A failed entity operation whose legacy ResponseMessage only carries the
-    ``exceptionType`` (error message) field must still surface as a TaskFailedError."""
+    """A WebJobs "old protocol" failure carries the message in the serialized
+    ``result`` field, while ``exceptionType`` is only the exception type name.
+    The surfaced message must come from ``result``, not ``exceptionType``."""
     test_entity_id = entities.EntityInstanceId("Counter", "myCounter")
 
     def orchestrator(ctx: task.OrchestrationContext, _):
@@ -2173,7 +2175,12 @@ def orchestrator(ctx: task.OrchestrationContext, _):
     assert len(actions) == 1
     request_id = actions[0].sendEntityMessage.entityOperationCalled.requestId
 
-    response_message = {"result": None, "exceptionType": "Something went wrong!"}
+    # Real WebJobs shape: message serialized into "result"; "exceptionType" is the
+    # (assembly-qualified) exception type name and must NOT be used as the message.
+    response_message = {
+        "result": json.dumps("Something went wrong!"),
+        "exceptionType": "System.InvalidOperationException, mscorlib",
+    }
     new_events = [
         helpers.new_event_sent_event(1, str(test_entity_id), json.dumps({"id": request_id})),
         helpers.new_event_raised_event(request_id, json.dumps(response_message)),
@@ -2185,6 +2192,8 @@ def orchestrator(ctx: task.OrchestrationContext, _):
     assert output == (
         "Operation 'set' on entity '@counter@myCounter' failed with error: Something went wrong!"
     )
+    # Guard against the regression of surfacing the type name instead of the message.
+    assert "InvalidOperationException" not in output
 
 
 def test_entity_call_success_over_old_protocol():