fix(sdk): correct FAILURE_TOLERANCE_EXCEEDED behavior in concurrent operations

packages/aws-durable-execution-sdk-js-examples/src/examples/force-checkpointing/invoke/force-checkpointing-invoke.test.ts

@@ -60,6 +60,6 @@ createTests({
       // Verify operations were tracked
       const operations = execution.getOperations();
       expect(operations.length).toBeGreaterThan(0);
-    }, 30000); // 30 second timeout
+    }, 60000); // 60 second timeout
   },
 });

packages/aws-durable-execution-sdk-js-examples/src/examples/force-checkpointing/invoke/force-checkpointing-invoke.ts

@@ -1,6 +1,7 @@
 import {
   withDurableExecution,
   DurableContext,
+  retryPresets,
 } from "@aws/durable-execution-sdk-js";
 import { ExampleConfig } from "../../../types";
 

packages/aws-durable-execution-sdk-js-examples/src/examples/map/failure-threshold-exceeded-count/map-failure-threshold-exceeded-count.test.ts

@@ -0,0 +1,21 @@
+import { handler } from "./map-failure-threshold-exceeded-count";
+import { createTests } from "../../../utils/test-helper";
+
+createTests({
+  name: "Map failure threshold exceeded count",
+  functionName: "map-failure-threshold-exceeded-count",
+  handler,
+  tests: (runner) => {
+    it("should return FAILURE_TOLERANCE_EXCEEDED when failure count exceeds threshold", async () => {
+      const execution = await runner.run();
+      const result = execution.getResult() as any;
+
+      console.log("DEBUG: Actual result:", JSON.stringify(result, null, 2));
+
+      expect(result.completionReason).toBe("FAILURE_TOLERANCE_EXCEEDED");
+      expect(result.successCount).toBe(2); // Items 4 and 5 succeed
+      expect(result.failureCount).toBe(3); // Items 1, 2, 3 fail (exceeds threshold of 2)
+      expect(result.totalCount).toBe(5);
+    });
+  },
+});

packages/aws-durable-execution-sdk-js-examples/src/examples/map/failure-threshold-exceeded-count/map-failure-threshold-exceeded-count.ts

@@ -0,0 +1,43 @@
+import {
+  DurableContext,
+  withDurableExecution,
+} from "@aws/durable-execution-sdk-js";
+import { ExampleConfig } from "../../../types";
+
+export const config: ExampleConfig = {
+  name: "Map failure threshold exceeded count",
+  description: "Map operation where failure count exceeds tolerance threshold",
+};
+
+export const handler = withDurableExecution(
+  async (event: any, context: DurableContext) => {
+    const items = [1, 2, 3, 4, 5];
+
+    const result = await context.map(
+      "failure-threshold-items",
+      items,
+      async (ctx: DurableContext, item: number, index: number) => {
+        return await ctx.step(`process-${index}`, async () => {
+          if (item <= 3) {
+            throw new Error(`Item ${item} failed`);
+          }
+          return item * 2;
+        });
+      },
+      {
+        completionConfig: {
+          toleratedFailureCount: 2, // Allow only 2 failures, but we'll have 3
+        },
+      },
+    );
+
+    await context.wait({ seconds: 1 });
+
+    return {
+      completionReason: result.completionReason,
+      successCount: result.successCount,
+      failureCount: result.failureCount,
+      totalCount: result.totalCount,
+    };
+  },
+);

packages/aws-durable-execution-sdk-js-examples/src/examples/map/failure-threshold-exceeded-percentage/map-failure-threshold-exceeded-percentage.test.ts

@@ -0,0 +1,19 @@
+import { handler } from "./map-failure-threshold-exceeded-percentage";
+import { createTests } from "../../../utils/test-helper";
+
+createTests({
+  name: "Map failure threshold exceeded percentage",
+  functionName: "map-failure-threshold-exceeded-percentage",
+  handler,
+  tests: (runner) => {
+    it("should return FAILURE_TOLERANCE_EXCEEDED when failure percentage exceeds threshold", async () => {
+      const execution = await runner.run();
+      const result = execution.getResult() as any;
+
+      expect(result.completionReason).toBe("FAILURE_TOLERANCE_EXCEEDED");
+      expect(result.successCount).toBe(2); // Items 4 and 5 succeed
+      expect(result.failureCount).toBe(3); // Items 1, 2, 3 fail (60% > 50% threshold)
+      expect(result.totalCount).toBe(5);
+    });
+  },
+});

packages/aws-durable-execution-sdk-js-examples/src/examples/map/failure-threshold-exceeded-percentage/map-failure-threshold-exceeded-percentage.ts

@@ -0,0 +1,44 @@
+import {
+  DurableContext,
+  withDurableExecution,
+} from "@aws/durable-execution-sdk-js";
+import { ExampleConfig } from "../../../types";
+
+export const config: ExampleConfig = {
+  name: "Map failure threshold exceeded percentage",
+  description:
+    "Map operation where failure percentage exceeds tolerance threshold",
+};
+
+export const handler = withDurableExecution(
+  async (event: any, context: DurableContext) => {
+    const items = [1, 2, 3, 4, 5];
+
+    const result = await context.map(
+      "failure-threshold-items",
+      items,
+      async (ctx: DurableContext, item: number, index: number) => {
+        return await ctx.step(`process-${index}`, async () => {
+          if (item <= 3) {
+            throw new Error(`Item ${item} failed`);
+          }
+          return item * 2;
+        });
+      },
+      {
+        completionConfig: {
+          toleratedFailurePercentage: 50, // Allow 50% failures, but we'll have 60% (3/5)
+        },
+      },
+    );
+
+    await context.wait({ seconds: 1 });
+
+    return {
+      completionReason: result.completionReason,
+      successCount: result.successCount,
+      failureCount: result.failureCount,
+      totalCount: result.totalCount,
+    };
+  },
+);

packages/aws-durable-execution-sdk-js-examples/src/examples/map/min-successful/map-min-successful.test.ts

@@ -0,0 +1,58 @@
+import { handler } from "./map-min-successful";
+import { createTests } from "../../../utils/test-helper";
+
+createTests({
+  name: "Map minSuccessful",
+  functionName: "map-min-successful",
+  handler,
+  tests: (runner) => {
+    it("should complete early when minSuccessful is reached", async () => {
+      const execution = await runner.run();
+      const result = execution.getResult() as any;
+
+      // Assert overall results
+      expect(result.successCount).toBe(2);
+      expect(result.completionReason).toBe("MIN_SUCCESSFUL_REACHED");
+      expect(result.results).toHaveLength(2);
+      expect(result.totalCount).toBe(5);
+
+      // Get the map operation from history to verify individual item results
+      const historyEvents = execution.getHistoryEvents();
+      const mapContext = historyEvents.find(
+        (event) =>
+          event.EventType === "ContextSucceeded" &&
+          event.Name === "min-successful-items",
+      );
+
+      expect(mapContext).toBeDefined();
+      const mapResult = JSON.parse(
+        mapContext!.ContextSucceededDetails!.Result!.Payload!,
+      );
+
+      // Assert individual item results - includes all started items (2 completed + 3 started)
+      expect(mapResult.all).toHaveLength(5);
+
+      // First two items should succeed (items 1 and 2 process fastest due to timeout)
+      expect(mapResult.all[0].status).toBe("SUCCEEDED");
+      expect(mapResult.all[0].result).toBe("Item 1 processed");
+      expect(mapResult.all[0].index).toBe(0);
+
+      expect(mapResult.all[1].status).toBe("SUCCEEDED");
+      expect(mapResult.all[1].result).toBe("Item 2 processed");
+      expect(mapResult.all[1].index).toBe(1);
+
+      // Remaining items should be in STARTED state (not completed)
+      expect(mapResult.all[2].status).toBe("STARTED");
+      expect(mapResult.all[2].index).toBe(2);
+
+      expect(mapResult.all[3].status).toBe("STARTED");
+      expect(mapResult.all[3].index).toBe(3);
+
+      expect(mapResult.all[4].status).toBe("STARTED");
+      expect(mapResult.all[4].index).toBe(4);
+
+      // Verify the results array matches
+      expect(result.results).toEqual(["Item 1 processed", "Item 2 processed"]);
+    });
+  },
+});

packages/aws-durable-execution-sdk-js-examples/src/examples/map/min-successful/map-min-successful.ts

@@ -0,0 +1,48 @@
+import {
+  DurableContext,
+  withDurableExecution,
+} from "@aws/durable-execution-sdk-js";
+import { ExampleConfig } from "../../../types";
+import { log } from "../../../utils/logger";
+
+export const config: ExampleConfig = {
+  name: "Map minSuccessful",
+  description: "Map operation with minSuccessful completion config",
+};
+
+export const handler = withDurableExecution(
+  async (event: any, context: DurableContext) => {
+    const items = [1, 2, 3, 4, 5];
+
+    log(`Processing ${items.length} items with minSuccessful: 2`);
+
+    const results = await context.map(
+      "min-successful-items",
+      items,
+      async (ctx, item, index) => {
+        return await ctx.step(`process-${index}`, async () => {
+          // Simulate processing time
+          await new Promise((resolve) => setTimeout(resolve, 100 * item));
+          return `Item ${item} processed`;
+        });
+      },
+      {
+        completionConfig: {
+          minSuccessful: 2,
+        },
+      },
+    );
+
+    await context.wait({ seconds: 1 });
+
+    log(`Completed with ${results.successCount} successes`);
+    log(`Completion reason: ${results.completionReason}`);
+
+    return {
+      successCount: results.successCount,
+      totalCount: results.totalCount,
+      completionReason: results.completionReason,
+      results: results.getResults(),
+    };
+  },
+);

packages/aws-durable-execution-sdk-js-examples/src/examples/map/tolerated-failure-count/map-tolerated-failure-count.test.ts

@@ -0,0 +1,62 @@
+import { handler } from "./map-tolerated-failure-count";
+import { createTests } from "../../../utils/test-helper";
+
+createTests({
+  name: "Map toleratedFailureCount",
+  functionName: "map-tolerated-failure-count",
+  handler,
+  tests: (runner) => {
+    it("should complete when failure tolerance is reached", async () => {
+      const execution = await runner.run();
+      const result = execution.getResult() as any;
+
+      // Assert overall results
+      expect(result.failureCount).toBe(2);
+      expect(result.successCount).toBe(3);
+      expect(result.completionReason).toBe("ALL_COMPLETED");
+      expect(result.hasFailure).toBe(true);
+      expect(result.totalCount).toBe(5);
+
+      // Get the map operation from history to verify individual item results
+      const historyEvents = execution.getHistoryEvents();
+      const mapContext = historyEvents.find(
+        (event) =>
+          event.EventType === "ContextSucceeded" &&
+          event.Name === "failure-count-items",
+      );
+
+      expect(mapContext).toBeDefined();
+      const mapResult = JSON.parse(
+        mapContext!.ContextSucceededDetails!.Result!.Payload!,
+      );
+
+      // Assert individual item results
+      expect(mapResult.all).toHaveLength(5);
+
+      // Item 1 should succeed (index 0)
+      expect(mapResult.all[0].status).toBe("SUCCEEDED");
+      expect(mapResult.all[0].result).toBe("Item 1 processed");
+      expect(mapResult.all[0].index).toBe(0);
+
+      // Item 2 should fail (index 1)
+      expect(mapResult.all[1].status).toBe("FAILED");
+      expect(mapResult.all[1].error).toBeDefined();
+      expect(mapResult.all[1].index).toBe(1);
+
+      // Item 3 should succeed (index 2)
+      expect(mapResult.all[2].status).toBe("SUCCEEDED");
+      expect(mapResult.all[2].result).toBe("Item 3 processed");
+      expect(mapResult.all[2].index).toBe(2);
+
+      // Item 4 should fail (index 3)
+      expect(mapResult.all[3].status).toBe("FAILED");
+      expect(mapResult.all[3].error).toBeDefined();
+      expect(mapResult.all[3].index).toBe(3);
+
+      // Item 5 should succeed (index 4)
+      expect(mapResult.all[4].status).toBe("SUCCEEDED");
+      expect(mapResult.all[4].result).toBe("Item 5 processed");
+      expect(mapResult.all[4].index).toBe(4);
+    });
+  },
+});

packages/aws-durable-execution-sdk-js-examples/src/examples/map/tolerated-failure-count/map-tolerated-failure-count.ts

@@ -0,0 +1,56 @@
+import {
+  DurableContext,
+  withDurableExecution,
+  retryPresets,
+} from "@aws/durable-execution-sdk-js";
+import { ExampleConfig } from "../../../types";
+import { log } from "../../../utils/logger";
+
+export const config: ExampleConfig = {
+  name: "Map toleratedFailureCount",
+  description: "Map operation with toleratedFailureCount completion config",
+};
+
+export const handler = withDurableExecution(
+  async (event: any, context: DurableContext) => {
+    const items = [1, 2, 3, 4, 5];
+
+    log(`Processing ${items.length} items with toleratedFailureCount: 2`);
+
+    const results = await context.map(
+      "failure-count-items",
+      items,
+      async (ctx, item, index) => {
+        return await ctx.step(
+          `process-${index}`,
+          async () => {
+            // Items 2 and 4 will fail
+            if (item === 2 || item === 4) {
+              throw new Error(`Processing failed for item ${item}`);
+            }
+            return `Item ${item} processed`;
+          },
+          { retryStrategy: retryPresets.noRetry },
+        );
+      },
+      {
+        completionConfig: {
+          toleratedFailureCount: 2,
+        },
+      },
+    );
+
+    await context.wait({ seconds: 1 });
+
+    log(`Completed with ${results.failureCount} failures`);
+    log(`Completion reason: ${results.completionReason}`);
+
+    return {
+      successCount: results.successCount,
+      failureCount: results.failureCount,
+      totalCount: results.totalCount,
+      completionReason: results.completionReason,
+      hasFailure: results.hasFailure,
+    };
+  },
+);