fix(plugin): guard result on success, keep it out of toString, keep the old arity

Review feedback on the result accessor:

- Only a SUCCEEDED operation reports a result. A wait-for-condition is
  checkpointed as STEP and reuses stepDetails().result() to carry its
  intermediate check-loop state between attempts, so a failed one could
  surface that state as its result, contradicting the documented
  null-on-failure contract. Verified: without the guard the new test
  reports {"polls":2} for a FAILED operation.
- Override toString() to omit result. Records render every component, so
  plugins that log the info object whole would have begun emitting
  customer payloads (possibly secrets or personal data). Output is
  otherwise unchanged; matches the invocation records from #622.
- Add a constructor at the previous 11-argument arity delegating with a
  null result, so existing callers keep compiling and linking.
- Cover the CHAINED_INVOKE, CALLBACK, and CONTEXT extraction branches,
  which had no direct test.

Author: Alex Wang

sdk/src/main/java/software/amazon/lambda/durable/plugin/OperationEndInfo.java

@@ -34,4 +34,52 @@ public record OperationEndInfo(
         Integer attempt,
         boolean isReplay,
         @Experimental Throwable error,
-        @Experimental String result) {}
+        @Experimental String result) {
+
+    /**
+     * Creates operation-end information without a result.
+     *
+     * <p>Retained so callers written before {@code result} was added keep compiling and linking; {@code result}
+     * resolves to null.
+     *
+     * @param id operation ID
+     * @param name human-readable operation name (may be null)
+     * @param type operation type
+     * @param subType operation sub-type (may be null)
+     * @param parentId parent operation ID (null for root-level operations)
+     * @param startTimestamp when the operation started
+     * @param endTimestamp when the operation ended
+     * @param status the operation's terminal status
+     * @param attempt the total number of attempts for retriable operations
+     * @param isReplay true if this operation already existed in the execution state
+     * @param error non-null if the operation failed
+     */
+    public OperationEndInfo(
+            String id,
+            String name,
+            String type,
+            String subType,
+            String parentId,
+            Instant startTimestamp,
+            Instant endTimestamp,
+            String status,
+            Integer attempt,
+            boolean isReplay,
+            Throwable error) {
+        this(id, name, type, subType, parentId, startTimestamp, endTimestamp, status, attempt, isReplay, error, null);
+    }
+
+    /**
+     * Returns a representation that omits {@code result}.
+     *
+     * <p>The generated representation would render the operation result, so plugins that log this object whole would
+     * start emitting customer payloads, potentially including secrets or personal data. Read the component explicitly
+     * to record it.
+     */
+    @Override
+    public String toString() {
+        return "OperationEndInfo[id=" + id + ", name=" + name + ", type=" + type + ", subType=" + subType
+                + ", parentId=" + parentId + ", startTimestamp=" + startTimestamp + ", endTimestamp=" + endTimestamp
+                + ", status=" + status + ", attempt=" + attempt + ", isReplay=" + isReplay + ", error=" + error + "]";
+    }
+}

sdk/src/main/java/software/amazon/lambda/durable/plugin/PluginInfoConverter.java

@@ -6,6 +6,7 @@
 import java.util.Collection;
 import java.util.stream.Collectors;
 import software.amazon.awssdk.services.lambda.model.Operation;
+import software.amazon.awssdk.services.lambda.model.OperationStatus;
 import software.amazon.lambda.durable.model.OperationIdentifier;
 import software.amazon.lambda.durable.operation.BaseDurableOperation;
 
@@ -71,9 +72,14 @@ public static OperationEndInfo toOperationEndInfo(
     /**
      * Extracts the serialized result from an operation based on its type. Returns null if the operation has no result
      * (e.g., failed or still running).
+     *
+     * <p>Only a SUCCEEDED operation reports a result. The status guard is required, not just defensive: a
+     * wait-for-condition is checkpointed as {@link OperationType#STEP} and reuses {@code stepDetails().result()} to
+     * carry its intermediate check-loop state between attempts, so a failed one can still hold state that must not be
+     * surfaced as that operation's result.
      */
     private static String extractResult(Operation operation) {
-        if (operation == null || operation.type() == null) {
+        if (operation == null || operation.type() == null || operation.status() != OperationStatus.SUCCEEDED) {
             return null;
         }
         return switch (operation.type()) {

sdk/src/test/java/software/amazon/lambda/durable/plugin/PluginInfoConverterTest.java

@@ -6,6 +6,9 @@
 
 import java.time.Instant;
 import org.junit.jupiter.api.Test;
+import software.amazon.awssdk.services.lambda.model.CallbackDetails;
+import software.amazon.awssdk.services.lambda.model.ChainedInvokeDetails;
+import software.amazon.awssdk.services.lambda.model.ContextDetails;
 import software.amazon.awssdk.services.lambda.model.Operation;
 import software.amazon.awssdk.services.lambda.model.OperationStatus;
 import software.amazon.awssdk.services.lambda.model.OperationType;
@@ -113,6 +116,103 @@ void toOperationEndInfo_extractsResult_fromSucceededStep() {
         assertEquals("\"hello\"", info.result());
     }
 
+    @Test
+    void toOperationEndInfo_extractsResult_fromSucceededChainedInvoke() {
+        var operation = Operation.builder()
+                .startTimestamp(START)
+                .endTimestamp(END)
+                .type(OperationType.CHAINED_INVOKE)
+                .status(OperationStatus.SUCCEEDED)
+                .chainedInvokeDetails(
+                        ChainedInvokeDetails.builder().result("\"invoked\"").build())
+                .build();
+
+        var info = PluginInfoConverter.toOperationEndInfo(operation, STEP_IDENTIFIER, null, false, null);
+
+        assertEquals("\"invoked\"", info.result());
+    }
+
+    @Test
+    void toOperationEndInfo_extractsResult_fromSucceededCallback() {
+        var operation = Operation.builder()
+                .startTimestamp(START)
+                .endTimestamp(END)
+                .type(OperationType.CALLBACK)
+                .status(OperationStatus.SUCCEEDED)
+                .callbackDetails(
+                        CallbackDetails.builder().result("\"called-back\"").build())
+                .build();
+
+        var info = PluginInfoConverter.toOperationEndInfo(operation, STEP_IDENTIFIER, null, false, null);
+
+        assertEquals("\"called-back\"", info.result());
+    }
+
+    @Test
+    void toOperationEndInfo_extractsResult_fromSucceededContext() {
+        var operation = Operation.builder()
+                .startTimestamp(START)
+                .endTimestamp(END)
+                .type(OperationType.CONTEXT)
+                .status(OperationStatus.SUCCEEDED)
+                .contextDetails(
+                        ContextDetails.builder().result("\"child-done\"").build())
+                .build();
+
+        var info = PluginInfoConverter.toOperationEndInfo(operation, STEP_IDENTIFIER, null, false, null);
+
+        assertEquals("\"child-done\"", info.result());
+    }
+
+    @Test
+    void toOperationEndInfo_resultIsNull_whenFailedWaitForConditionRetainsCheckpointState() {
+        // A wait-for-condition is checkpointed as STEP and reuses stepDetails().result() to carry its
+        // intermediate check-loop state between attempts, so a failed one can still hold state.
+        var operation = Operation.builder()
+                .startTimestamp(START)
+                .endTimestamp(END)
+                .type(OperationType.STEP)
+                .status(OperationStatus.FAILED)
+                .stepDetails(
+                        StepDetails.builder().attempt(3).result("{\"polls\":2}").build())
+                .build();
+
+        var info = PluginInfoConverter.toOperationEndInfo(operation, STEP_IDENTIFIER, null, false, null);
+
+        assertNull(info.result(), "a failed operation must not report intermediate state as its result");
+    }
+
+    @Test
+    void operationEndInfo_compatibilityConstructor_leavesResultNull() {
+        var info = new OperationEndInfo(
+                OPERATION_ID, OPERATION_NAME, "STEP", "Step", PARENT_ID, START, END, "SUCCEEDED", 1, false, null);
+
+        assertNull(info.result());
+    }
+
+    @Test
+    void operationEndInfo_toString_omitsResult() {
+        var info = new OperationEndInfo(
+                OPERATION_ID,
+                OPERATION_NAME,
+                "STEP",
+                "Step",
+                PARENT_ID,
+                START,
+                END,
+                "SUCCEEDED",
+                1,
+                false,
+                null,
+                "s3cret-result");
+
+        var rendered = info.toString();
+
+        assertFalse(rendered.contains("s3cret-result"), "operation result must not leak into logs");
+        assertTrue(rendered.contains(OPERATION_ID));
+        assertTrue(rendered.contains("SUCCEEDED"));
+    }
+
     @Test
     void toOperationEndInfo_resultIsNull_whenOperationHasNoResult() {
         var operation = Operation.builder()