Respond to PR comments

Author: Quinn-With-Two-Ns

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

@@ -4,6 +4,7 @@
 import io.temporal.client.WorkflowOptions;
 import io.temporal.common.Experimental;
 import io.temporal.workflow.Functions;
+import java.lang.reflect.Type;
 
 /**
  * Nexus-aware client wrapping {@link WorkflowClient}. Provides methods for interacting with
@@ -217,6 +218,45 @@ <T, A1, A2, A3, A4, A5, R> TemporalOperationResult<R> startWorkflow(
       A5 arg5,
       WorkflowOptions options);
 
+  /**
+   * Starts a six-argument workflow that returns a value.
+   *
+   * <p>Example:
+   *
+   * <pre>{@code
+   * client.startWorkflow(MyWorkflow.class, MyWorkflow::run, arg1, arg2, arg3, arg4, arg5, arg6, options)
+   * }</pre>
+   *
+   * @param workflowClass the workflow interface class
+   * @param workflowMethod unbound method reference to the workflow method
+   * @param arg1 first workflow argument
+   * @param arg2 second workflow argument
+   * @param arg3 third workflow argument
+   * @param arg4 fourth workflow argument
+   * @param arg5 fifth workflow argument
+   * @param arg6 sixth workflow argument
+   * @param options workflow start options (must include workflowId)
+   * @param <T> the workflow interface type
+   * @param <A1> the type of the first workflow argument
+   * @param <A2> the type of the second workflow argument
+   * @param <A3> the type of the third workflow argument
+   * @param <A4> the type of the fourth workflow argument
+   * @param <A5> the type of the fifth workflow argument
+   * @param <A6> the type of the sixth workflow argument
+   * @param <R> the workflow return type
+   * @return an async {@link TemporalOperationResult} with the workflow-run operation token
+   */
+  <T, A1, A2, A3, A4, A5, A6, R> TemporalOperationResult<R> startWorkflow(
+      Class<T> workflowClass,
+      Functions.Func7<T, A1, A2, A3, A4, A5, A6, R> workflowMethod,
+      A1 arg1,
+      A2 arg2,
+      A3 arg3,
+      A4 arg4,
+      A5 arg5,
+      A6 arg6,
+      WorkflowOptions options);
+
   /**
    * Starts a zero-argument workflow with no return value.
    *
@@ -380,6 +420,44 @@ <T, A1, A2, A3, A4, A5> TemporalOperationResult<Void> startWorkflow(
       A5 arg5,
       WorkflowOptions options);
 
+  /**
+   * Starts a six-argument workflow with no return value.
+   *
+   * <p>Example:
+   *
+   * <pre>{@code
+   * client.startWorkflow(MyWorkflow.class, MyWorkflow::execute, arg1, arg2, arg3, arg4, arg5, arg6, options)
+   * }</pre>
+   *
+   * @param workflowClass the workflow interface class
+   * @param workflowMethod unbound method reference to the workflow method
+   * @param arg1 first workflow argument
+   * @param arg2 second workflow argument
+   * @param arg3 third workflow argument
+   * @param arg4 fourth workflow argument
+   * @param arg5 fifth workflow argument
+   * @param arg6 sixth workflow argument
+   * @param options workflow start options (must include workflowId)
+   * @param <T> the workflow interface type
+   * @param <A1> the type of the first workflow argument
+   * @param <A2> the type of the second workflow argument
+   * @param <A3> the type of the third workflow argument
+   * @param <A4> the type of the fourth workflow argument
+   * @param <A5> the type of the fifth workflow argument
+   * @param <A6> the type of the sixth workflow argument
+   * @return an async {@link TemporalOperationResult} with the workflow-run operation token
+   */
+  <T, A1, A2, A3, A4, A5, A6> TemporalOperationResult<Void> startWorkflow(
+      Class<T> workflowClass,
+      Functions.Proc7<T, A1, A2, A3, A4, A5, A6> workflowMethod,
+      A1 arg1,
+      A2 arg2,
+      A3 arg3,
+      A4 arg4,
+      A5 arg5,
+      A6 arg6,
+      WorkflowOptions options);
+
   /**
    * Starts a workflow using an untyped workflow type name.
    *
@@ -398,4 +476,35 @@ <T, A1, A2, A3, A4, A5> TemporalOperationResult<Void> startWorkflow(
    */
   <R> TemporalOperationResult<R> startWorkflow(
       String workflowType, Class<R> resultClass, WorkflowOptions options, Object... args);
+
+  /**
+   * Starts a workflow using an untyped workflow type name, with both a result class and a generic
+   * {@link Type}. Use this overload when the workflow returns a generic type (e.g. {@code
+   * List<String>}) so the result can be deserialized correctly.
+   *
+   * <p>Example:
+   *
+   * <pre>{@code
+   * client.startWorkflow(
+   *     "MyWorkflow",
+   *     List.class,
+   *     new TypeToken<List<String>>() {}.getType(),
+   *     options,
+   *     input)
+   * }</pre>
+   *
+   * @param workflowType the workflow type name string
+   * @param resultClass the expected result class
+   * @param resultType the expected result {@link Type} (carries generic parameters)
+   * @param options workflow start options (must include workflowId)
+   * @param args workflow arguments
+   * @param <R> the workflow return type
+   * @return an async {@link TemporalOperationResult} with the workflow-run operation token
+   */
+  <R> TemporalOperationResult<R> startWorkflow(
+      String workflowType,
+      Class<R> resultClass,
+      Type resultType,
+      WorkflowOptions options,
+      Object... args);
 }

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

@@ -10,6 +10,7 @@
 import io.temporal.internal.client.NexusStartWorkflowResponse;
 import io.temporal.internal.nexus.NexusStartWorkflowHelper;
 import io.temporal.workflow.Functions;
+import java.lang.reflect.Type;
 import java.util.Objects;
 import java.util.concurrent.atomic.AtomicBoolean;
 
@@ -112,6 +113,23 @@ public <T, A1, A2, A3, A4, A5, R> TemporalOperationResult<R> startWorkflow(
             () -> workflowMethod.apply(stub, arg1, arg2, arg3, arg4, arg5)));
   }
 
+  @Override
+  public <T, A1, A2, A3, A4, A5, A6, R> TemporalOperationResult<R> startWorkflow(
+      Class<T> workflowClass,
+      Functions.Func7<T, A1, A2, A3, A4, A5, A6, R> workflowMethod,
+      A1 arg1,
+      A2 arg2,
+      A3 arg3,
+      A4 arg4,
+      A5 arg5,
+      A6 arg6,
+      WorkflowOptions options) {
+    T stub = client.newWorkflowStub(workflowClass, options);
+    return invokeAndReturn(
+        WorkflowHandle.fromWorkflowMethod(
+            () -> workflowMethod.apply(stub, arg1, arg2, arg3, arg4, arg5, arg6)));
+  }
+
   // ---------- Void (Proc) overloads ----------
 
   @Override
@@ -188,11 +206,38 @@ public <T, A1, A2, A3, A4, A5> TemporalOperationResult<Void> startWorkflow(
             () -> workflowMethod.apply(stub, arg1, arg2, arg3, arg4, arg5)));
   }
 
+  @Override
+  public <T, A1, A2, A3, A4, A5, A6> TemporalOperationResult<Void> startWorkflow(
+      Class<T> workflowClass,
+      Functions.Proc7<T, A1, A2, A3, A4, A5, A6> workflowMethod,
+      A1 arg1,
+      A2 arg2,
+      A3 arg3,
+      A4 arg4,
+      A5 arg5,
+      A6 arg6,
+      WorkflowOptions options) {
+    T stub = client.newWorkflowStub(workflowClass, options);
+    return invokeAndReturn(
+        WorkflowHandle.fromWorkflowMethod(
+            () -> workflowMethod.apply(stub, arg1, arg2, arg3, arg4, arg5, arg6)));
+  }
+
   // ---------- Untyped ----------
 
   @Override
   public <R> TemporalOperationResult<R> startWorkflow(
       String workflowType, Class<R> resultClass, WorkflowOptions options, Object... args) {
+    return startWorkflow(workflowType, resultClass, null, options, args);
+  }
+
+  @Override
+  public <R> TemporalOperationResult<R> startWorkflow(
+      String workflowType,
+      Class<R> resultClass,
+      Type resultType,
+      WorkflowOptions options,
+      Object... args) {
     WorkflowStub stub = client.newUntypedWorkflowStub(workflowType, options);
     WorkflowHandle<R> handle = WorkflowHandle.fromWorkflowStub(stub, resultClass, args);
     return invokeAndReturn(handle);

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

@@ -1,7 +1,6 @@
 package io.temporal.nexus;
 
 import io.nexusrpc.handler.*;
-import io.nexusrpc.handler.OperationHandler;
 import io.temporal.client.WorkflowClient;
 import io.temporal.common.Experimental;
 import io.temporal.internal.nexus.CurrentNexusOperationContext;

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

@@ -61,22 +61,31 @@ public boolean isAsync() {
   }
 
   /**
-   * Returns the synchronous result value, or null if this is an async result.
+   * Returns the synchronous result value.
    *
-   * @return the sync result value, or null
+   * @return the sync result value (may be null if the operation produced a null sync value)
+   * @throws IllegalStateException if this is an async result; check {@link #isSync()} first
    */
   @Nullable
   public R getSyncResult() {
+    if (!isSync) {
+      throw new IllegalStateException(
+          "getSyncResult() called on async result; use getAsyncOperationToken() instead");
+    }
     return syncResult;
   }
 
   /**
-   * Returns the async operation token, or null if this is a sync result.
+   * Returns the async operation token.
    *
-   * @return the operation token, or null
+   * @return the operation token
+   * @throws IllegalStateException if this is a sync result; check {@link #isAsync()} first
    */
-  @Nullable
   public String getAsyncOperationToken() {
+    if (isSync) {
+      throw new IllegalStateException(
+          "getAsyncOperationToken() called on sync result; use getSyncResult() instead");
+    }
     return asyncOperationToken;
   }
 }

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

@@ -45,7 +45,7 @@ public String execute(String input) {
 
       TestNexusServiceProc serviceStub =
           Workflow.newNexusServiceStub(TestNexusServiceProc.class, serviceOptions);
-      for (int i = 0; i < 6; i++) {
+      for (int i = 0; i < 7; i++) {
         serviceStub.operation(i);
       }
       return "done";
@@ -114,6 +114,17 @@ public OperationHandler<Integer, Void> operation() {
                     4,
                     5,
                     options);
+              case 6:
+                return client.startWorkflow(
+                    TestMultiArgWorkflowFunctions.Test6ArgWorkflowProc.class,
+                    TestMultiArgWorkflowFunctions.Test6ArgWorkflowProc::proc6,
+                    "input",
+                    2,
+                    3,
+                    4,
+                    5,
+                    6,
+                    options);
               default:
                 throw new IllegalArgumentException("unexpected input: " + input);
             }

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

@@ -30,7 +30,7 @@ public void typedStartWorkflowTests() {
     TestWorkflows.TestWorkflow1 workflowStub =
         testWorkflowRule.newWorkflowStubTimeoutOptions(TestWorkflows.TestWorkflow1.class);
     String result = workflowStub.execute(testWorkflowRule.getTaskQueue());
-    Assert.assertEquals("funcinputinput2input23input234input2345", result);
+    Assert.assertEquals("funcinputinput2input23input234input2345input23456", result);
   }
 
   public static class TestNexus implements TestWorkflows.TestWorkflow1 {
@@ -46,7 +46,7 @@ public String execute(String input) {
       TestNexusServiceGeneric serviceStub =
           Workflow.newNexusServiceStub(TestNexusServiceGeneric.class, serviceOptions);
       StringBuilder result = new StringBuilder();
-      for (int i = 0; i < 6; i++) {
+      for (int i = 0; i < 7; i++) {
         result.append(serviceStub.operation(i));
       }
       return result.toString();
@@ -115,6 +115,17 @@ public OperationHandler<Integer, String> operation() {
                     4,
                     5,
                     options);
+              case 6:
+                return client.startWorkflow(
+                    TestMultiArgWorkflowFunctions.Test6ArgWorkflowFunc.class,
+                    TestMultiArgWorkflowFunctions.Test6ArgWorkflowFunc::func6,
+                    "input",
+                    2,
+                    3,
+                    4,
+                    5,
+                    6,
+                    options);
               default:
                 throw new IllegalArgumentException("unexpected input: " + input);
             }