Update

Author: Quinn-With-Two-Ns

temporal-sdk/src/main/java/io/temporal/nexus/TemporalNexusClient.java

@@ -10,7 +10,6 @@
 import io.temporal.internal.nexus.NexusStartWorkflowHelper;
 import io.temporal.workflow.Functions;
 import java.util.Objects;
-import java.util.function.Consumer;
 
 /**
  * Nexus-aware client wrapping {@link WorkflowClient}. Provides methods for interacting with
@@ -73,33 +72,33 @@ public WorkflowClient getWorkflowClient() {
   }
 
   /**
-   * Starts a workflow by invoking a method on a workflow stub. The client creates the stub from the
-   * given class and options, then passes it to the provided consumer which should call exactly one
-   * workflow method. Works for both returning and void workflow methods.
+   * Starts a workflow by invoking a returning method on a workflow stub. The client creates the
+   * stub from the given class and options, then invokes the workflow method via the provided
+   * function.
    *
-   * <p>Example (returning):
+   * <p>Example:
    *
    * <pre>{@code
    * client.startWorkflow(MyWorkflow.class, wf -> wf.run(input), options)
    * }</pre>
    *
-   * <p>Example (void):
+   * <p>For void-returning workflow methods, use a block lambda that returns null:
    *
    * <pre>{@code
-   * client.startWorkflow(MyWorkflow.class, wf -> wf.execute(input), options)
+   * client.startWorkflow(MyWorkflow.class, wf -> { wf.execute(input); return null; }, options)
    * }</pre>
    *
    * @param workflowClass the workflow interface class
-   * @param workflowInvocation receives the workflow stub and calls exactly one workflow method
+   * @param workflowMethod receives the workflow stub and calls exactly one workflow method
    * @param options workflow start options (must include workflowId)
    * @param <T> the workflow interface type
-   * @param <R> the workflow return type (inferred from calling context)
+   * @param <R> the workflow return type
    * @return an async {@link TemporalOperationResult} with the workflow-run operation token
    */
   public <T, R> TemporalOperationResult<R> startWorkflow(
-      Class<T> workflowClass, Consumer<T> workflowInvocation, WorkflowOptions options) {
+      Class<T> workflowClass, Functions.Func1<T, R> workflowMethod, WorkflowOptions options) {
     T stub = client.newWorkflowStub(workflowClass, options);
-    Functions.Proc bound = () -> workflowInvocation.accept(stub);
+    Functions.Func<R> bound = () -> workflowMethod.apply(stub);
     return invokeAndReturn(WorkflowHandle.fromWorkflowMethod(bound));
   }
 
@@ -120,7 +119,7 @@ public <R> TemporalOperationResult<R> startWorkflow(
     return invokeAndReturn(handle);
   }
 
-  private <R> TemporalOperationResult<R> invokeAndReturn(WorkflowHandle<?> handle) {
+  private <R> TemporalOperationResult<R> invokeAndReturn(WorkflowHandle<R> handle) {
     NexusStartWorkflowResponse response =
         NexusStartWorkflowHelper.startWorkflowAndAttachLinks(
             operationContext,

temporal-sdk/src/main/java/io/temporal/nexus/TemporalOperationHandler.java

@@ -30,8 +30,9 @@
  * }
  * }</pre>
  *
- * <p>The cancel behavior is overridable. By default, canceling an operation backed by a
- * workflow-run token cancels the underlying workflow.
+ * <p>This class supports subclassing to customize cancel behavior. Override {@link
+ * #cancelWorkflowRun} to change how workflow-run cancellations are handled. The {@link #start} and
+ * {@link #cancel} methods should not be overridden — they contain the core dispatch logic.
  *
  * @param <T> the input type
  * @param <R> the result type
@@ -53,17 +54,18 @@ TemporalOperationResult<R> apply(
 
   private final StartFunction<T, R> startFunction;
 
-  private TemporalOperationHandler(StartFunction<T, R> startFunction) {
+  protected TemporalOperationHandler(StartFunction<T, R> startFunction) {
     this.startFunction = startFunction;
   }
 
   /**
-   * Creates an {@link OperationHandler} from a start function.
+   * Creates a {@link TemporalOperationHandler} from a start function. Subclass and override {@link
+   * #cancelWorkflowRun} to customize cancel behavior.
    *
    * @param startFunction the function to invoke on start operation requests
    * @return an operation handler backed by the given start function
    */
-  public static <T, R> OperationHandler<T, R> from(StartFunction<T, R> startFunction) {
+  public static <T, R> TemporalOperationHandler<T, R> from(StartFunction<T, R> startFunction) {
     return new TemporalOperationHandler<>(startFunction);
   }
 

temporal-sdk/src/test/java/io/temporal/workflow/nexus/GenericHandlerTypedProcTest.java

@@ -64,7 +64,10 @@ public OperationHandler<String, Void> operation() {
           (context, client, input) ->
               client.startWorkflow(
                   TestMultiArgWorkflowFunctions.TestNoArgsWorkflowProc.class,
-                  wf -> wf.proc(),
+                  wf -> {
+                    wf.proc();
+                    return null;
+                  },
                   WorkflowOptions.newBuilder()
                       .setWorkflowId(
                           "generic-handler-proc-"