update

Author: nytian

client/src/main/java/com/microsoft/durabletask/DurableTaskGrpcWorker.java

@@ -392,9 +392,8 @@ public void startAndBlock() {
                                 activityRequest.getTaskId());
                         } catch (Throwable e) {
                             activityError = e;
-                            Exception ex = e instanceof Exception ? (Exception) e : new RuntimeException(e);
                             failureDetails = FailureDetails.fromException(
-                                    ex, this.exceptionPropertiesProvider).toProto();
+                                    e, this.exceptionPropertiesProvider).toProto();
                         } finally {
                             activityScope.close();
                             TracingHelper.endSpan(activitySpan, activityError);

client/src/main/java/com/microsoft/durabletask/FailureDetails.java

@@ -58,15 +58,21 @@ public final class FailureDetails {
     }
 
     /**
-     * Creates a {@code FailureDetails} from an exception, optionally using the provided
+     * Creates a {@code FailureDetails} from a throwable, optionally using the provided
      * {@link ExceptionPropertiesProvider} to extract custom properties.
+     * <p>
+     * Accepts any {@link Throwable} so callers that catch {@code Throwable} (for example, activity
+     * dispatchers that need to report {@link Error} subclasses such as {@link StackOverflowError}
+     * or {@link OutOfMemoryError}) can preserve the original error type instead of having to wrap
+     * it in a {@link RuntimeException}. The {@link ExceptionPropertiesProvider}, however, is only
+     * invoked for {@link Exception} instances, since that is what its contract accepts.
      *
-     * @param exception the exception that caused the failure
+     * @param throwable the throwable that caused the failure
      * @param provider  the provider for extracting custom properties, or {@code null}
      * @return a new {@code FailureDetails} instance
      */
-    static FailureDetails fromException(Exception exception, @Nullable ExceptionPropertiesProvider provider) {
-        return fromExceptionRecursive(exception, provider, 0);
+    static FailureDetails fromException(Throwable throwable, @Nullable ExceptionPropertiesProvider provider) {
+        return fromExceptionRecursive(throwable, provider, 0);
     }
 
     FailureDetails(TaskFailureDetails proto) {

client/src/test/java/com/microsoft/durabletask/FailureDetailsTest.java

@@ -206,6 +206,52 @@ void fromException_providerReturnsNull_noProperties() {
         assertNull(details.getProperties());
     }
 
+    @Test
+    void fromException_acceptsErrorAndPreservesType() {
+        // Errors aren't Exceptions, but activity dispatchers catch Throwable. fromException should
+        // accept them so the original error type (e.g. StackOverflowError) is reported instead of
+        // being hidden behind a synthetic RuntimeException wrapper.
+        StackOverflowError error = new StackOverflowError("too deep");
+
+        FailureDetails details = FailureDetails.fromException(error, null);
+
+        assertEquals("java.lang.StackOverflowError", details.getErrorType());
+        assertEquals("too deep", details.getErrorMessage());
+        assertNull(details.getProperties());
+    }
+
+    @Test
+    void fromException_errorWithCause_preservesInnerFailure() {
+        IOException cause = new IOException("disk full");
+        OutOfMemoryError error = new OutOfMemoryError("heap exhausted");
+        error.initCause(cause);
+
+        FailureDetails details = FailureDetails.fromException(error, null);
+
+        assertEquals("java.lang.OutOfMemoryError", details.getErrorType());
+        assertNotNull(details.getInnerFailure());
+        assertEquals("java.io.IOException", details.getInnerFailure().getErrorType());
+        assertEquals("disk full", details.getInnerFailure().getErrorMessage());
+    }
+
+    @Test
+    void fromException_errorWithProvider_skipsProviderForError() {
+        // The provider contract takes Exception, not Throwable, so for an Error we shouldn't
+        // call the provider at all. The Error itself still needs to be reported faithfully.
+        ExceptionPropertiesProvider provider = exception -> {
+            Map<String, Object> props = new HashMap<>();
+            props.put("called", true);
+            return props;
+        };
+
+        StackOverflowError error = new StackOverflowError("too deep");
+
+        FailureDetails details = FailureDetails.fromException(error, provider);
+
+        assertEquals("java.lang.StackOverflowError", details.getErrorType());
+        assertNull(details.getProperties());
+    }
+
     @Test
     void fromException_providerSelectivelyReturnsProperties() {
         ExceptionPropertiesProvider provider = exception -> {