feat: Implement advanced retry features with handleFailure predicate and timeout controls

Author: YunchuWang

packages/durabletask-js/src/exception/timeout-error.ts

@@ -4,5 +4,6 @@
 export class TimeoutError extends Error {
   constructor() {
     super("TimeoutError");
+    this.name = "TimeoutError";
   }
 }

packages/durabletask-js/src/orchestration/exception/orchestration-failed-error.ts

@@ -8,6 +8,7 @@ export class OrchestrationFailedError extends Error {
 
   constructor(message: string, details: FailureDetails) {
     super(message);
+    this.name = "OrchestrationFailedError";
     this._failureDetails = details;
   }
 

packages/durabletask-js/src/task/exception/orchestration-state-error.ts

@@ -4,5 +4,6 @@
 export class OrchestrationStateError extends Error {
   constructor(message: string) {
     super(message);
+    this.name = "OrchestrationStateError";
   }
 }

packages/durabletask-js/src/task/exception/task-failed-error.ts

@@ -9,6 +9,7 @@ export class TaskFailedError extends Error {
 
   constructor(message: string, details: pb.TaskFailureDetails) {
     super(message);
+    this.name = "TaskFailedError";
 
     this._details = new FailureDetails(
       details.getErrormessage(),

packages/durabletask-js/src/task/retryable-task.ts

@@ -156,6 +156,7 @@ export class RetryableTask<T> extends CompletableTask<T> {
    *
    * @remarks
    * Returns undefined if:
+   * - The handleFailure predicate returns false for the last failure
    * - The maximum number of attempts has been reached
    * - The retry timeout has been exceeded
    *
@@ -165,6 +166,19 @@ export class RetryableTask<T> extends CompletableTask<T> {
    * The delay is capped at maxRetryInterval.
    */
   computeNextDelayInMilliseconds(currentTime: Date): number | undefined {
+    // Check if handleFailure predicate says we should NOT retry this failure type
+    if (this._lastFailure) {
+      const failureDetails = {
+        errorType: this._lastFailure.getErrortype() || "Error",
+        message: this._lastFailure.getErrormessage() || "",
+        stackTrace: this._lastFailure.getStacktrace()?.getValue(),
+      };
+
+      if (!this._retryPolicy.shouldRetry(failureDetails)) {
+        return undefined;
+      }
+    }
+
     // Check if we've exhausted max attempts
     if (this._attemptCount >= this._retryPolicy.maxNumberOfAttempts) {
       return undefined;

packages/durabletask-js/src/utils/pb-helper.util.ts

@@ -183,7 +183,8 @@ export function newSubOrchestrationFailedEvent(eventId: number, ex: Error): pb.H
 
 export function newFailureDetails(e: any): pb.TaskFailureDetails {
   const failure = new pb.TaskFailureDetails();
-  failure.setErrortype(e.constructor.name);
+  // Use error.name if set (allows custom error names), otherwise fall back to constructor name
+  failure.setErrortype(e.name || e.constructor.name);
   failure.setErrormessage(e.message);
 
   // Construct a google_protobuf_wrappers_pb.StringValue

packages/durabletask-js/test/retryable-task.spec.ts

@@ -194,6 +194,108 @@ describe("RetryableTask", () => {
       // Assert - should still allow retry (timeout is infinite)
       expect(delay).toBeGreaterThan(0);
     });
+
+    it("should return undefined when handleFailure predicate returns false", () => {
+      // Arrange
+      const retryPolicy = new RetryPolicy({
+        maxNumberOfAttempts: 10,
+        firstRetryIntervalInMilliseconds: 1000,
+        handleFailure: (failure) => failure.errorType !== "FatalError",
+      });
+      const action = new pb.OrchestratorAction();
+      const task = new RetryableTask<string>(retryPolicy, action, new Date(), "activity");
+
+      // Record a FatalError (should NOT be retried)
+      const failureDetails = new pb.TaskFailureDetails();
+      failureDetails.setErrortype("FatalError");
+      failureDetails.setErrormessage("This is a fatal error");
+      task.recordFailure("This is a fatal error", failureDetails);
+
+      const currentTime = new Date();
+
+      // Act
+      const delay = task.computeNextDelayInMilliseconds(currentTime);
+
+      // Assert - should return undefined because handleFailure returns false for FatalError
+      expect(delay).toBeUndefined();
+    });
+
+    it("should allow retry when handleFailure predicate returns true", () => {
+      // Arrange
+      const retryPolicy = new RetryPolicy({
+        maxNumberOfAttempts: 10,
+        firstRetryIntervalInMilliseconds: 1000,
+        handleFailure: (failure) => failure.errorType !== "FatalError",
+      });
+      const action = new pb.OrchestratorAction();
+      const task = new RetryableTask<string>(retryPolicy, action, new Date(), "activity");
+
+      // Record a TransientError (should be retried)
+      const failureDetails = new pb.TaskFailureDetails();
+      failureDetails.setErrortype("TransientError");
+      failureDetails.setErrormessage("This is a transient error");
+      task.recordFailure("This is a transient error", failureDetails);
+
+      const currentTime = new Date();
+
+      // Act
+      const delay = task.computeNextDelayInMilliseconds(currentTime);
+
+      // Assert - should return a delay because handleFailure returns true for TransientError
+      expect(delay).toBeDefined();
+      expect(delay).toBeGreaterThan(0);
+    });
+
+    it("should filter based on error message content in handleFailure", () => {
+      // Arrange
+      const retryPolicy = new RetryPolicy({
+        maxNumberOfAttempts: 10,
+        firstRetryIntervalInMilliseconds: 1000,
+        handleFailure: (failure) => failure.message?.includes("timeout") ?? false,
+      });
+      const action = new pb.OrchestratorAction();
+      const task = new RetryableTask<string>(retryPolicy, action, new Date(), "activity");
+
+      // Record a validation error (should NOT be retried - no "timeout" in message)
+      const failureDetails = new pb.TaskFailureDetails();
+      failureDetails.setErrortype("ValidationError");
+      failureDetails.setErrormessage("Invalid input: field is required");
+      task.recordFailure("Invalid input: field is required", failureDetails);
+
+      const currentTime = new Date();
+
+      // Act
+      const delay = task.computeNextDelayInMilliseconds(currentTime);
+
+      // Assert - should return undefined because message doesn't contain "timeout"
+      expect(delay).toBeUndefined();
+    });
+
+    it("should retry when error message matches handleFailure criteria", () => {
+      // Arrange
+      const retryPolicy = new RetryPolicy({
+        maxNumberOfAttempts: 10,
+        firstRetryIntervalInMilliseconds: 1000,
+        handleFailure: (failure) => failure.message?.includes("timeout") ?? false,
+      });
+      const action = new pb.OrchestratorAction();
+      const task = new RetryableTask<string>(retryPolicy, action, new Date(), "activity");
+
+      // Record a timeout error (should be retried - has "timeout" in message)
+      const failureDetails = new pb.TaskFailureDetails();
+      failureDetails.setErrortype("NetworkError");
+      failureDetails.setErrormessage("Connection timeout - please retry");
+      task.recordFailure("Connection timeout - please retry", failureDetails);
+
+      const currentTime = new Date();
+
+      // Act
+      const delay = task.computeNextDelayInMilliseconds(currentTime);
+
+      // Assert - should return a delay because message contains "timeout"
+      expect(delay).toBeDefined();
+      expect(delay).toBeGreaterThan(0);
+    });
   });
 
   describe("incrementAttemptCount", () => {