Responding to PR comments

Author: Evanthx

temporal-sdk/src/main/java/io/temporal/client/NexusServiceClient.java

@@ -37,21 +37,21 @@
  *     .build();
  *
  * // Operation that takes an input (Func2 overload):
- * String hi = client.execute(GreeterService::greet, "Ada", options);
+ * String hi = client.execute(GreeterService::greet, options, "Ada");
  *
  * // Operation with no input (Func1 overload):
  * String t = client.execute(GreeterService::now, options);
  *
  * // Operation that returns Void: the same overloads work, R is just Void.
- * client.execute(GreeterService::log, "hello", options);
+ * client.execute(GreeterService::log, options, "hello");
  *
  * // Get a handle instead of blocking:
- * NexusOperationHandle<String> handle = client.start(GreeterService::greet, "Ada", options);
+ * NexusOperationHandle<String> handle = client.start(GreeterService::greet, options, "Ada");
  * String result = handle.getResult();
  *
  * // Run asynchronously:
  * CompletableFuture<String> future =
- *     client.executeAsync(GreeterService::greet, "Ada", options);
+ *     client.executeAsync(GreeterService::greet, options, "Ada");
  * }</pre>
  *
  * @param <T> the Nexus service interface this client is bound to
@@ -65,35 +65,35 @@ public interface NexusServiceClient<T> extends UntypedNexusServiceClient {
    * Executes an operation synchronously with per-call options.
    *
    * @param operation a method reference on {@code T} identifying the operation
-   * @param input the operation input
    * @param options per-call options controlling timeouts, search attributes, etc.
+   * @param input the operation input
    * @return the operation result
    * @throws NexusOperationException if the operation failed, timed out, or was cancelled
    */
-  <U, R> R execute(Functions.Func2<T, U, R> operation, U input, StartNexusOperationOptions options);
+  <U, R> R execute(Functions.Func2<T, U, R> operation, StartNexusOperationOptions options, U input);
 
   /**
    * Starts an operation with per-call options and returns a typed handle.
    *
    * @param operation a method reference on {@code T} identifying the operation
-   * @param input the operation input
    * @param options per-call options controlling timeouts, search attributes, etc.
+   * @param input the operation input
    * @return a typed handle bound to the started operation
    */
   <U, R> NexusOperationHandle<R> start(
-      Functions.Func2<T, U, R> operation, U input, StartNexusOperationOptions options);
+      Functions.Func2<T, U, R> operation, StartNexusOperationOptions options, U input);
 
   /**
-   * Async variant of {@link #execute(Functions.Func2, Object, StartNexusOperationOptions)}. Returns
+   * Async variant of {@link #execute(Functions.Func2, StartNexusOperationOptions, Object)}. Returns
    * a {@link CompletableFuture} that completes with the typed result, or completes exceptionally if
    * the operation fails.
    *
    * @param operation a method reference on {@code T} identifying the operation
-   * @param input the operation input
    * @param options per-call options controlling timeouts, search attributes, etc.
+   * @param input the operation input
    */
   <U, R> CompletableFuture<R> executeAsync(
-      Functions.Func2<T, U, R> operation, U input, StartNexusOperationOptions options);
+      Functions.Func2<T, U, R> operation, StartNexusOperationOptions options, U input);
 
   /**
    * Executes a no-input operation synchronously with per-call options. Use this overload for Nexus

temporal-sdk/src/main/java/io/temporal/client/NexusServiceClientImpl.java

@@ -48,21 +48,21 @@ private NexusServiceClientImpl(
 
   @Override
   public <U, R> NexusOperationHandle<R> start(
-      Functions.Func2<T, U, R> operation, U input, StartNexusOperationOptions options) {
+      Functions.Func2<T, U, R> operation, StartNexusOperationOptions options, U input) {
     Method method = MethodExtractor.extract(serviceInterface, operation);
     return startResolved(method, input, options);
   }
 
   @Override
   public <U, R> R execute(
-      Functions.Func2<T, U, R> operation, U input, StartNexusOperationOptions options) {
-    return start(operation, input, options).getResult();
+      Functions.Func2<T, U, R> operation, StartNexusOperationOptions options, U input) {
+    return start(operation, options, input).getResult();
   }
 
   @Override
   public <U, R> CompletableFuture<R> executeAsync(
-      Functions.Func2<T, U, R> operation, U input, StartNexusOperationOptions options) {
-    return start(operation, input, options).getResultAsync();
+      Functions.Func2<T, U, R> operation, StartNexusOperationOptions options, U input) {
+    return start(operation, options, input).getResultAsync();
   }
 
   @Override

temporal-sdk/src/test/java/io/temporal/client/nexus/NexusAsyncApiTest.java

@@ -56,7 +56,7 @@ public void serviceClientExecuteAsyncReturnsResult() throws Exception {
     String result =
         buildServiceClient()
             .executeAsync(
-                TestNexusServices.TestNexusService1::operation, "hello", newOptionsWithId())
+                TestNexusServices.TestNexusService1::operation, newOptionsWithId(), "hello")
             .get();
 
     Assert.assertEquals("echo:hello", result);
@@ -72,7 +72,7 @@ public void serviceClientExecuteAsyncWithOptionsReturnsResult() throws Exception
 
     String result =
         buildServiceClient()
-            .executeAsync(TestNexusServices.TestNexusService1::operation, "world", options)
+            .executeAsync(TestNexusServices.TestNexusService1::operation, options, "world")
             .get();
 
     Assert.assertEquals("echo:world", result);
@@ -84,7 +84,7 @@ public void serviceClientExecuteAsyncWithOptionsReturnsResult() throws Exception
   public void typedHandleGetResultAsyncReturnsResult() throws Exception {
     NexusOperationHandle<String> handle =
         buildServiceClient()
-            .start(TestNexusServices.TestNexusService1::operation, "typed", newOptionsWithId());
+            .start(TestNexusServices.TestNexusService1::operation, newOptionsWithId(), "typed");
 
     String result = handle.getResultAsync().get();
 
@@ -95,7 +95,7 @@ public void typedHandleGetResultAsyncReturnsResult() throws Exception {
   public void typedHandleGetResultAsyncWithTimeoutReturnsResult() throws Exception {
     NexusOperationHandle<String> handle =
         buildServiceClient()
-            .start(TestNexusServices.TestNexusService1::operation, "typed-tm", newOptionsWithId());
+            .start(TestNexusServices.TestNexusService1::operation, newOptionsWithId(), "typed-tm");
 
     // The 60s argument here exists to satisfy the API signature being exercised; the test rule's
     // global timeout will fail the test long before this value matters.
@@ -150,8 +150,8 @@ public void executeAsyncPropagatesOperationFailure() throws Exception {
         buildServiceClient()
             .executeAsync(
                 TestNexusServices.TestNexusService1::operation,
-                EchoNexusServiceImpl.FAIL_PREFIX + "boom",
-                newOptionsWithId());
+                newOptionsWithId(),
+                EchoNexusServiceImpl.FAIL_PREFIX + "boom");
 
     try {
       future.get();

temporal-sdk/src/test/java/io/temporal/client/nexus/NexusServiceClientTest.java

@@ -54,7 +54,7 @@ public void executeReturnsTypedResult() {
         buildServiceClient(testWorkflowRule.getNexusEndpoint());
 
     String result =
-        client.execute(TestNexusServices.TestNexusService1::operation, "hello", newOptionsWithId());
+        client.execute(TestNexusServices.TestNexusService1::operation, newOptionsWithId(), "hello");
 
     Assert.assertEquals("echo:hello", result);
   }
@@ -65,15 +65,15 @@ public void startReturnsTypedHandleAndPollsResult() {
         buildServiceClient(testWorkflowRule.getNexusEndpoint());
 
     NexusOperationHandle<String> handle =
-        client.start(TestNexusServices.TestNexusService1::operation, "world", newOptionsWithId());
+        client.start(TestNexusServices.TestNexusService1::operation, newOptionsWithId(), "world");
 
     Assert.assertNotNull(handle.getNexusOperationId());
     Assert.assertEquals("echo:world", handle.getResult());
   }
 
   @Test
   public void executeWithOptionsReturnsResult() {
-    // Covers the 3-arg execute(op, input, options) overload — exercises a non-default
+    // Covers the 3-arg execute(op, options, input) overload — exercises a non-default
     // scheduleToCloseTimeout in addition to the required id.
     StartNexusOperationOptions options =
         StartNexusOperationOptions.newBuilder()
@@ -83,7 +83,7 @@ public void executeWithOptionsReturnsResult() {
 
     String result =
         buildServiceClient(testWorkflowRule.getNexusEndpoint())
-            .execute(TestNexusServices.TestNexusService1::operation, "with-opts", options);
+            .execute(TestNexusServices.TestNexusService1::operation, options, "with-opts");
 
     Assert.assertEquals("echo:with-opts", result);
   }
@@ -99,7 +99,7 @@ public void startWithExplicitIdHonoursId() {
 
     NexusOperationHandle<String> handle =
         buildServiceClient(testWorkflowRule.getNexusEndpoint())
-            .start(TestNexusServices.TestNexusService1::operation, "id-test", options);
+            .start(TestNexusServices.TestNexusService1::operation, options, "id-test");
 
     Assert.assertEquals(
         "explicit ID supplied via StartNexusOperationOptions.setId must round-trip on the handle",
@@ -120,7 +120,7 @@ public void clientSummaryReachesServer() {
             .setSummary("per-call-summary")
             .build();
     NexusOperationHandle<String> handle =
-        client.start(TestNexusServices.TestNexusService1::operation, "world", startOptions);
+        client.start(TestNexusServices.TestNexusService1::operation, startOptions, "world");
 
     // Describe round-trips the operation through the server, proving the summary was actually
     // persisted on the server-side record rather than just forwarded through the local interceptor
@@ -161,7 +161,7 @@ public void executeWithVoidReturnCompletes() {
 
     Void result =
         client.execute(
-            TestNexusServices.TestNexusServiceVoidReturn::operation, "ignored", newOptionsWithId());
+            TestNexusServices.TestNexusServiceVoidReturn::operation, newOptionsWithId(), "ignored");
 
     Assert.assertNull(result);
     Assert.assertEquals(