fix: improve large payload error handling — better error message and prevent infinite retry and fix conflict with auto chunking

samples/LargePayloadConsoleApp/Program.cs

@@ -25,7 +25,9 @@
 builder.Services.AddExternalizedPayloadStore(opts =>
 {
     // Keep threshold small to force externalization for demo purposes
-    opts.ExternalizeThresholdBytes = 1024; // 1KB
+    opts.ThresholdBytes = 1024; // 1KB
+
+    opts.MaxPayloadBytes = 50 * 1024; // 50KB cap for overflow testing
     opts.ConnectionString = builder.Configuration.GetValue<string>("DURABLETASK_STORAGE") ?? "UseDevelopmentStorage=true";
     opts.ContainerName = builder.Configuration.GetValue<string>("DURABLETASK_PAYLOAD_CONTAINER") ?? "payloads";
 });
@@ -76,15 +78,15 @@
             (ctx, _) => ctx.Entities.CallEntityAsync<int>(
                 new EntityInstanceId(nameof(EchoLengthEntity), "1"),
                 operationName: "EchoLength",
-                input: new string('E', 700 * 1024)));
+                input: new string('E', 40 * 1024)));
         tasks.AddEntity<EchoLengthEntity>(nameof(EchoLengthEntity));
 
         tasks.AddOrchestratorFunc<object?, int>(
             "LargeEntityOperationOutput",
             async (ctx, _) => (await ctx.Entities.CallEntityAsync<string>(
                 new EntityInstanceId(nameof(LargeResultEntity), "1"),
                 operationName: "Produce",
-                input: 850 * 1024)).Length);
+                input: 40 * 1024)).Length);
         tasks.AddEntity<LargeResultEntity>(nameof(LargeResultEntity));
 
         tasks.AddOrchestratorFunc<object?, object?>(
@@ -94,10 +96,36 @@
                 await ctx.Entities.CallEntityAsync(
                     new EntityInstanceId(nameof(StateEntity), "1"),
                     operationName: "Set",
-                    input: new string('S', 900 * 1024));
+                    input: new string('S', 40 * 1024));
                 return null;
             });
         tasks.AddEntity<StateEntity>(nameof(StateEntity));
+
+
+
+        // Overflow: activity output > MaxPayloadBytes
+
+        tasks.AddOrchestratorFunc<object?, string>("ActivityProducesOversized", async (ctx, _) =>
+
+        {
+
+            return await ctx.CallActivityAsync<string>("ProduceOversized");
+
+        });
+
+        tasks.AddActivityFunc<string>("ProduceOversized", (ctx) => Task.FromResult(new string('O', 60 * 1024)));
+
+
+
+        // Overflow: orchestration output > MaxPayloadBytes
+
+        tasks.AddOrchestratorFunc<object?, string>("OrchestrationProducesOversized", (ctx, _) =>
+
+        {
+
+            return Task.FromResult(new string('P', 60 * 1024));
+
+        });
     });
 
     // Use shared store (no duplication of options)
@@ -112,7 +140,7 @@ await ctx.Entities.CallEntityAsync(
 await using DurableTaskClient client = host.Services.GetRequiredService<DurableTaskClient>();
 
 // Option A: Directly pass an oversized input to orchestration to trigger externalization
-string largeInput = new string('B', 1024 * 1024); // 1MB
+string largeInput = new string('B', 40 * 1024); // 40KB
 string instanceId = await client.ScheduleNewOrchestrationInstanceAsync("LargeInputEcho", largeInput);
 Console.WriteLine($"Started orchestration with direct large input. Instance: {instanceId}");
 
@@ -136,7 +164,7 @@ await ctx.Entities.CallEntityAsync(
 // Run entity samples
 Console.WriteLine();
 Console.WriteLine("Running LargeEntityOperationInput...");
-string largeEntityInput = new string('E', 700 * 1024); // 700KB
+string largeEntityInput = new string('E', 40 * 1024); // 40KB
 string entityInputInstance = await client.ScheduleNewOrchestrationInstanceAsync("LargeEntityOperationInput");
 OrchestrationMetadata entityInputResult = await client.WaitForInstanceCompletionAsync(entityInputInstance, getInputsAndOutputs: true, cts.Token);
 int entityInputLength = entityInputResult.ReadOutputAs<int>();
@@ -145,7 +173,7 @@ await ctx.Entities.CallEntityAsync(
 
 Console.WriteLine();
 Console.WriteLine("Running LargeEntityOperationOutput...");
-int largeEntityOutputLength = 850 * 1024; // 850KB
+int largeEntityOutputLength = 40 * 1024; // 40KB
 string entityOutputInstance = await client.ScheduleNewOrchestrationInstanceAsync("LargeEntityOperationOutput");
 OrchestrationMetadata entityOutputResult = await client.WaitForInstanceCompletionAsync(entityOutputInstance, getInputsAndOutputs: true, cts.Token);
 int entityOutputLength = entityOutputResult.ReadOutputAs<int>();
@@ -154,7 +182,7 @@ await ctx.Entities.CallEntityAsync(
 
 Console.WriteLine();
 Console.WriteLine("Running LargeEntityState and querying state...");
-string largeEntityState = new string('S', 900 * 1024); // 900KB
+string largeEntityState = new string('S', 40 * 1024); // 40KB
 string entityStateInstance = await client.ScheduleNewOrchestrationInstanceAsync("LargeEntityState");
 OrchestrationMetadata entityStateOrch = await client.WaitForInstanceCompletionAsync(entityStateInstance, getInputsAndOutputs: true, cts.Token);
 Console.WriteLine($"Status: {entityStateOrch.RuntimeStatus}");
@@ -163,6 +191,86 @@ await ctx.Entities.CallEntityAsync(
 Console.WriteLine($"State length: {stateLength}");
 Console.WriteLine($"Deserialized state equals original: {state?.State == largeEntityState}");
 
+
+
+// ==================== Overflow Scenarios ====================
+
+Console.WriteLine();
+
+Console.WriteLine("=== Overflow Scenarios (MaxPayloadBytes=50KB) ===");
+
+
+
+// Scenario 1: Client input > cap -> PayloadStorageException
+
+Console.WriteLine("[Scenario 1] Client oversized input");
+
+try
+
+{
+
+    string tooLarge = new string('Z', 60 * 1024);
+
+    await client.ScheduleNewOrchestrationInstanceAsync("LargeInputEcho", tooLarge);
+
+    Console.WriteLine("ERROR: Expected PayloadStorageException!");
+
+}
+
+catch (PayloadStorageException ex)
+
+{
+
+    Console.WriteLine("PASS: " + ex.GetType().Name + ": " + ex.Message);
+
+}
+
+catch (Exception ex)
+
+{
+
+    Console.WriteLine("FAIL: " + ex.GetType().Name + ": " + ex.Message);
+
+}
+
+
+
+// Scenario 2: Activity output > cap -> orchestration fails
+
+Console.WriteLine("[Scenario 2] Activity oversized output");
+
+string actOvfId = await client.ScheduleNewOrchestrationInstanceAsync("ActivityProducesOversized");
+
+OrchestrationMetadata actOvfResult = await client.WaitForInstanceCompletionAsync(actOvfId, getInputsAndOutputs: true, cts.Token);
+
+Console.WriteLine("  Status: " + actOvfResult.RuntimeStatus);
+
+Console.WriteLine(actOvfResult.RuntimeStatus == OrchestrationRuntimeStatus.Failed ? "PASS" : "FAIL: expected Failed");
+
+if (actOvfResult.FailureDetails != null) Console.WriteLine("  Error: " + actOvfResult.FailureDetails.ErrorMessage);
+
+
+
+// Scenario 3: Orchestration output > cap -> fails
+
+Console.WriteLine("[Scenario 3] Orchestration oversized output");
+
+string orchOvfId = await client.ScheduleNewOrchestrationInstanceAsync("OrchestrationProducesOversized");
+
+OrchestrationMetadata orchOvfResult = await client.WaitForInstanceCompletionAsync(orchOvfId, getInputsAndOutputs: true, cts.Token);
+
+Console.WriteLine("  Status: " + orchOvfResult.RuntimeStatus);
+
+Console.WriteLine(orchOvfResult.RuntimeStatus == OrchestrationRuntimeStatus.Failed ? "PASS" : "FAIL: expected Failed");
+
+if (orchOvfResult.FailureDetails != null) Console.WriteLine("  Error: " + orchOvfResult.FailureDetails.ErrorMessage);
+
+
+
+Console.WriteLine("=== All scenarios complete ===");
+
+
+
 public class EchoLengthEntity : TaskEntity<int>
 {
     public int EchoLength(string input)

src/Extensions/AzureBlobPayloads/Exceptions/PayloadStorageException.cs

@@ -0,0 +1,29 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace Microsoft.DurableTask;
+
+/// <summary>
+/// Exception thrown when a payload storage operation fails permanently.
+/// </summary>
+public sealed class PayloadStorageException : InvalidOperationException
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PayloadStorageException" /> class.
+    /// </summary>
+    /// <param name="message">The error message.</param>
+    public PayloadStorageException(string message)
+        : base(message)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PayloadStorageException" /> class.
+    /// </summary>
+    /// <param name="message">The error message.</param>
+    /// <param name="innerException">The inner exception.</param>
+    public PayloadStorageException(string message, Exception innerException)
+        : base(message, innerException)
+    {
+    }
+}

src/Extensions/AzureBlobPayloads/Interceptors/PayloadInterceptor.cs

@@ -80,6 +80,7 @@ Status GetStatus()
             return new Status(StatusCode.Unknown, string.Empty);
         }
 
+
         Metadata GetTrailers()
         {
             return startCallTask.Status == TaskStatus.RanToCompletion ? startCallTask.Result.GetTrailers() : [];
@@ -174,17 +175,17 @@ public override AsyncServerStreamingCall<TResponse> AsyncServerStreamingCall<TRe
         }
 
         int size = Encoding.UTF8.GetByteCount(value);
-        if (size < this.options.ExternalizeThresholdBytes)
+        if (size < this.options.ThresholdBytes)
         {
             return value;
         }
 
         // Enforce a hard cap to prevent unbounded payload sizes
-        if (size > this.options.MaxExternalizedPayloadBytes)
+        if (size > this.options.MaxPayloadBytes)
         {
-            throw new InvalidOperationException(
-                $"Payload size {size / 1024} kb exceeds the configured maximum of {this.options.MaxExternalizedPayloadBytes / 1024} kb. " +
-                "Consider reducing the payload or increase MaxExternalizedPayloadBytes setting.");
+            throw new PayloadStorageException(
+                $"Payload size {size / 1024} KB exceeds the configured maximum of {this.options.MaxPayloadBytes / 1024} KB. " +
+                "Reduce the payload size or increase the max payload size limit.");
         }
 
         return await this.payloadStore.UploadAsync(value!, cancellation);

src/Extensions/AzureBlobPayloads/Options/LargePayloadStorageOptions.cs

@@ -26,7 +26,7 @@ namespace Microsoft.DurableTask;
 /// </summary>
 public sealed class LargePayloadStorageOptions
 {
-    int externalizeThresholdBytes = 900_000;
+    int thresholdBytes = 900_000;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="LargePayloadStorageOptions"/> class.
@@ -63,20 +63,20 @@ public LargePayloadStorageOptions(Uri accountUri, TokenCredential credential)
     /// Gets or sets the threshold in bytes at which payloads are externalized. Default is 900_000 bytes.
     /// Value must not exceed 1 MiB (1,048,576 bytes).
     /// </summary>
-    public int ExternalizeThresholdBytes
+    public int ThresholdBytes
     {
-        get => this.externalizeThresholdBytes;
+        get => this.thresholdBytes;
         set
         {
             const int OneMiB = 1 * 1024 * 1024;
             if (value > OneMiB)
             {
                 throw new ArgumentOutOfRangeException(
-                    nameof(this.ExternalizeThresholdBytes),
-                    $"ExternalizeThresholdBytes cannot exceed 1 MiB ({OneMiB} bytes).");
+                    nameof(this.ThresholdBytes),
+                    $"Payload storage threshold cannot exceed 1 MiB ({OneMiB} bytes).");
             }
 
-            this.externalizeThresholdBytes = value;
+            this.thresholdBytes = value;
         }
     }
 
@@ -85,7 +85,7 @@ public int ExternalizeThresholdBytes
     /// Defaults to 10MB. Requests exceeding this limit will fail fast
     /// with a clear error to prevent unbounded payload growth and excessive storage/network usage.
     /// </summary>
-    public int MaxExternalizedPayloadBytes { get; set; } = 10 * 1024 * 1024;
+    public int MaxPayloadBytes { get; set; } = 10 * 1024 * 1024;
 
     /// <summary>
     /// Gets or sets the Azure Storage connection string to the customer's storage account.
@@ -114,5 +114,5 @@ public int ExternalizeThresholdBytes
     /// Gets or sets a value indicating whether payloads should be gzip-compressed when stored.
     /// Defaults to true for reduced storage and bandwidth.
     /// </summary>
-    public bool CompressPayloads { get; set; } = true;
+    public bool CompressionEnabled { get; set; } = true;
 }

src/Extensions/AzureBlobPayloads/PayloadStore/BlobPayloadStore.cs

@@ -55,7 +55,7 @@ public BlobPayloadStore(LargePayloadStorageOptions options)
                 Mode = RetryMode.Exponential,
                 MaxRetries = MaxRetryAttempts,
                 Delay = TimeSpan.FromMilliseconds(BaseDelayMs),
-                MaxDelay = TimeSpan.FromSeconds(MaxDelayMs),
+                MaxDelay = TimeSpan.FromMilliseconds(MaxDelayMs),
                 NetworkTimeout = TimeSpan.FromMinutes(NetworkTimeoutMinutes),
             },
         };
@@ -79,7 +79,7 @@ public override async Task<string> UploadAsync(string payLoad, CancellationToken
         // Ensure container exists (idempotent)
         await this.containerClient.CreateIfNotExistsAsync(PublicAccessType.None, default, default, cancellationToken);
 
-        if (this.options.CompressPayloads)
+        if (this.options.CompressionEnabled)
         {
             BlobOpenWriteOptions writeOptions = new()
             {
@@ -138,7 +138,7 @@ public override async Task<string> DownloadAsync(string token, CancellationToken
         }
         catch (RequestFailedException ex) when (ex.Status == (int)HttpStatusCode.NotFound)
         {
-            throw new InvalidOperationException(
+            throw new PayloadStorageException(
                 $"The blob '{name}' was not found in container '{container}'. " +
                 "The payload may have been deleted or the container was never created.",
                 ex);