Add support for more timeouts to Nexus operations

src/Temporalio/Worker/WorkflowInstance.cs

@@ -2572,6 +2572,14 @@ public override Task<NexusOperationHandle<TResult>> StartNexusOperationAsync<TRe
                 {
                     cmd.ScheduleToCloseTimeout = Google.Protobuf.WellKnownTypes.Duration.FromTimeSpan(schedToCloseTimeout);
                 }
+                if (input.Options.ScheduleToStartTimeout is TimeSpan schedToStartTimeout)
+                {
+                    cmd.ScheduleToStartTimeout = Google.Protobuf.WellKnownTypes.Duration.FromTimeSpan(schedToStartTimeout);
+                }
+                if (input.Options.StartToCloseTimeout is TimeSpan startToCloseTimeout)
+                {
+                    cmd.StartToCloseTimeout = Google.Protobuf.WellKnownTypes.Duration.FromTimeSpan(startToCloseTimeout);
+                }
                 if (input.Headers is IDictionary<string, string> headers)
                 {
                     cmd.NexusHeader.Add(headers);

src/Temporalio/Workflows/NexusOperationOptions.cs

@@ -12,8 +12,29 @@ public class NexusOperationOptions : ICloneable
         /// <summary>
         /// Gets or sets the schedule to close timeout.
         /// </summary>
+        /// <remarks>Indicates how long the caller is willing to wait for operation completion.
+        /// Calls are retried internally by the server.</remarks>
         public TimeSpan? ScheduleToCloseTimeout { get; set; }
 
+        /// <summary>
+        /// Gets or sets the schedule to start timeout.
+        /// </summary>
+        /// <remarks>Indicates how long the caller is willing to wait for the operation to be started (or completed if synchronous)
+        /// by the handler. If the operation is not started within this timeout, it will fail with TIMEOUT_TYPE_SCHEDULE_TO_START.
+        /// If not set or zero, no schedule-to-start timeout is enforced.
+        /// Requires server version 1.31.0 or later.</remarks>
+        public TimeSpan? ScheduleToStartTimeout { get; set; }
+
+        /// <summary>
+        /// Gets or sets the start to close timeout.
+        /// </summary>
+        /// <remarks>Indicates how long the caller is willing to wait for an asynchronous operation to complete after it has been
+        /// started. If the operation does not complete within this timeout after starting, it will fail with TIMEOUT_TYPE_START_TO_CLOSE.
+        /// Only applies to asynchronous operations. Synchronous operations ignore this timeout.
+        /// If not set or zero, no start-to-close timeout is enforced.
+        /// Requires server version 1.31.0 or later.</remarks>
+        public TimeSpan? StartToCloseTimeout { get; set; }
+
         /// <summary>
         /// Gets or sets the summary.
         /// </summary>

tests/Temporalio.Tests/Worker/NexusWorkerTests.cs

@@ -297,8 +297,9 @@ await Workflow.CreateNexusClient<IStringService>(endpoint).
                         svc => svc.DoSomething("some-name"),
                         new() { ScheduleToCloseTimeout = TimeSpan.FromSeconds(2) });
             }));
-        Assert.IsType<TimeoutFailureException>(
+        var timeoutExc = Assert.IsType<TimeoutFailureException>(
             Assert.IsType<NexusOperationFailureException>(exc.InnerException).InnerException);
+        Assert.Equal(TimeoutType.ScheduleToClose, timeoutExc.TimeoutType);
         // Also check that our cancel token is canceled for the proper reason
         var ctx = await contextSource.Task;
         Assert.True(await Task.Run(() => ctx.CancellationToken.WaitHandle.WaitOne(2000)));
@@ -338,6 +339,75 @@ await Workflow.CreateNexusClient<IStringService>(endpoint).
         Assert.Equal(expectedSummary, actualSummary);
     }
 
+    [Fact]
+    public async Task ExecuteNexusOperationAsync_ScheduleToStartTimeout_FailsAsExpected()
+    {
+        var contextSource = new TaskCompletionSource<OperationStartContext>();
+        var workerOptions = new TemporalWorkerOptions($"tq-{Guid.NewGuid()}").
+            AddNexusService(new HandlerFactoryStringService(() =>
+                OperationHandler.Sync<string, string>(async (ctx, name) =>
+                {
+                    contextSource.SetResult(ctx);
+                    try
+                    {
+                        await Task.Delay(40000, ctx.CancellationToken);
+                        return "done";
+                    }
+                    catch (TaskCanceledException)
+                    {
+                        return "canceled";
+                    }
+                })));
+        var endpoint = await CreateNexusEndpointAsync(workerOptions.TaskQueue!);
+        // Confirm the workflow fails with the timeout
+        var exc = await Assert.ThrowsAsync<WorkflowFailedException>(() =>
+            RunInWorkflowAsync(workerOptions, async () =>
+            {
+                await Workflow.CreateNexusClient<IStringService>(endpoint).
+                    ExecuteNexusOperationAsync(
+                        svc => svc.DoSomething("some-name"),
+                        new() { ScheduleToStartTimeout = TimeSpan.FromSeconds(2) });
+            }));
+        var timeoutExc = Assert.IsType<TimeoutFailureException>(
+            Assert.IsType<NexusOperationFailureException>(exc.InnerException).InnerException);
+        Assert.Equal(TimeoutType.ScheduleToStart, timeoutExc.TimeoutType);
+        // Also check that our cancel token is canceled for the proper reason
+        var ctx = await contextSource.Task;
+        Assert.True(await Task.Run(() => ctx.CancellationToken.WaitHandle.WaitOne(2000)));
+        Assert.Equal("timed out", ctx.CancellationReason);
+    }
+
+    [Fact]
+    public async Task ExecuteNexusOperationAsync_StartToCloseTimeout_FailsAsExpected()
+    {
+        // Build a workflow-backed async operation that will never complete
+        var workerOptions = new TemporalWorkerOptions($"tq-{Guid.NewGuid()}").
+            AddNexusService(new HandlerFactoryStringService(() =>
+                WorkflowRunOperationHandler.FromHandleFactory(
+                    (WorkflowRunOperationContext context, string input) =>
+                        context.StartWorkflowAsync(
+                            (WaitForeverWorkflow wf) => wf.RunAsync(input),
+                            new() { Id = $"wf-{Guid.NewGuid()}" })))).
+            AddWorkflow<WaitForeverWorkflow>();
+        var endpoint = await CreateNexusEndpointAsync(workerOptions.TaskQueue!);
+        // Confirm the workflow fails with the timeout
+        var exc = await Assert.ThrowsAsync<WorkflowFailedException>(() =>
+            RunInWorkflowAsync(workerOptions, async () =>
+            {
+                await Workflow.CreateNexusClient<IStringService>(endpoint).
+                    ExecuteNexusOperationAsync(
+                        svc => svc.DoSomething("some-name"),
+                        new()
+                        {
+                            ScheduleToStartTimeout = TimeSpan.FromSeconds(30),
+                            StartToCloseTimeout = TimeSpan.FromSeconds(2),
+                        });
+            }));
+        var timeoutExc = Assert.IsType<TimeoutFailureException>(
+            Assert.IsType<NexusOperationFailureException>(exc.InnerException).InnerException);
+        Assert.Equal(TimeoutType.StartToClose, timeoutExc.TimeoutType);
+    }
+
     [Workflow]
     public class WaitForSignalWorkflow
     {

tests/Temporalio.Tests/WorkflowEnvironment.cs

@@ -67,7 +67,7 @@ public async Task InitializeAsync()
             {
                 DevServerOptions = new()
                 {
-                    DownloadVersion = "v1.6.1-server-1.31.0-150.0",
+                    DownloadVersion = "v1.6.1-server-1.31.0-151.0",
                     ExtraArgs = new List<string>
                     {
                         // Disable search attribute cache