@temporalio/core-bridge 1.14.2-canary-release-testing.0 → 1.16.0

package/sdk-core/crates/sdk-core/tests/integ_tests/workflow_tests/nexus.rs

@@ -2,7 +2,7 @@ use crate::{
     common::{CoreWfStarter, WorkflowHandleExt, rand_6_chars},
     integ_tests::mk_nexus_endpoint,
 };
-use anyhow::bail;
+use anyhow::anyhow;
 use assert_matches::assert_matches;
 use std::{
     sync::{
@@ -11,9 +11,15 @@ use std::{
     },
     time::Duration,
 };
-use temporalio_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions};
+use temporalio_client::{
+    UntypedSignal, UntypedWorkflow, WorkflowCancelOptions, WorkflowSignalOptions,
+    WorkflowStartOptions,
+};
 use temporalio_common::{
-    errors::PollError,
+    data_converters::{
+        GenericPayloadConverter, PayloadConverter, RawValue, SerializationContext,
+        SerializationContextData,
+    },
     protos::{
         coresdk::{
             FromJsonPayloadExt,
@@ -35,15 +41,19 @@ use temporalio_common::{
     },
     worker::WorkerTaskTypes,
 };
-use temporalio_sdk::{CancellableFuture, NexusOperationOptions, WfContext, WfExitValue};
+use temporalio_macros::{workflow, workflow_methods};
+use temporalio_sdk::{
+    CancellableFuture, NexusOperationOptions, SyncWorkflowContext, WorkflowContext,
+    WorkflowContextView, WorkflowResult, WorkflowTermination,
+};
+use temporalio_sdk_core::PollError;
 use tokio::{
     join,
     sync::{mpsc, watch},
 };
-use tokio_stream::StreamExt;
 
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-enum Outcome {
+#[derive(Debug, PartialEq, Eq, Clone, Copy, serde::Serialize, serde::Deserialize)]
+pub(crate) enum Outcome {
     Succeed,
     Fail,
     Cancel,
@@ -51,6 +61,43 @@ enum Outcome {
     Timeout,
 }
 
+#[workflow]
+#[derive(Default)]
+struct NexusBasicWf {
+    endpoint: String,
+}
+
+#[workflow_methods]
+impl NexusBasicWf {
+    #[init]
+    fn new(_ctx: &WorkflowContextView, endpoint: String) -> Self {
+        Self { endpoint }
+    }
+
+    #[run]
+    pub(crate) async fn run(
+        ctx: &mut WorkflowContext<Self>,
+    ) -> WorkflowResult<Result<NexusOperationResult, Failure>> {
+        match ctx
+            .start_nexus_operation(NexusOperationOptions {
+                endpoint: ctx.state(|wf| wf.endpoint.clone()),
+                service: "svc".to_string(),
+                operation: "op".to_string(),
+                schedule_to_close_timeout: Some(Duration::from_secs(3)),
+                ..Default::default()
+            })
+            .await
+        {
+            Ok(started) => {
+                assert_eq!(started.operation_token, None);
+                let res = started.result().await;
+                Ok(Ok(res))
+            }
+            Err(failure) => Ok(Err(failure)),
+        }
+    }
+}
+
 #[rstest::rstest]
 #[tokio::test]
 async fn nexus_basic(
@@ -58,42 +105,28 @@ async fn nexus_basic(
 ) {
     let wf_name = "nexus_basic";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.task_types(WorkerTaskTypes {
+    starter.sdk_config.task_types = WorkerTaskTypes {
         enable_workflows: true,
         enable_local_activities: false,
         enable_remote_activities: false,
         enable_nexus: true,
-    });
+    };
     let mut worker = starter.worker().await;
     let core_worker = starter.get_worker().await;
 
     let endpoint = mk_nexus_endpoint(&mut starter).await;
 
-    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| {
-        let endpoint = endpoint.clone();
-        async move {
-            match ctx
-                .start_nexus_operation(NexusOperationOptions {
-                    endpoint,
-                    service: "svc".to_string(),
-                    operation: "op".to_string(),
-                    schedule_to_close_timeout: Some(Duration::from_secs(3)),
-                    ..Default::default()
-                })
-                .await
-            {
-                Ok(started) => {
-                    assert_eq!(started.operation_token, None);
-                    let res = started.result().await;
-                    Ok(Ok(res).into())
-                }
-                Err(failure) => Ok(Err(failure).into()),
-            }
-        }
-    });
-    let wf_handle = starter.start_with_worker(wf_name, &mut worker).await;
+    worker.register_workflow::<NexusBasicWf>();
+    let wf_handle = worker
+        .submit_workflow(
+            NexusBasicWf::run,
+            endpoint.clone(),
+            starter.workflow_options.clone(),
+        )
+        .await
+        .unwrap();
 
-    let client = starter.get_client().await.get_client().clone();
+    let client = starter.get_client().await;
     let nexus_task_handle = async {
         let nt = core_worker.poll_nexus_task().await.unwrap().unwrap_task();
         match outcome {
@@ -132,6 +165,7 @@ async fn nexus_basic(
                 core_worker
                     .complete_nexus_task(NexusTaskCompletion {
                         task_token: nt.task_token,
+                        #[allow(deprecated)]
                         status: Some(nexus_task_completion::Status::Error(HandlerError {
                             error_type: "BAD_REQUEST".to_string(), // bad req is non-retryable
                             failure: Some(nexus::v1::Failure {
@@ -157,12 +191,13 @@ async fn nexus_basic(
     });
 
     let res = client
-        .get_untyped_workflow_handle(starter.get_task_queue().to_owned(), "")
-        .get_workflow_result(Default::default())
+        .get_workflow_handle::<UntypedWorkflow>(starter.get_task_queue().to_owned())
+        .get_result(Default::default())
         .await
         .unwrap();
-    let res = Result::<NexusOperationResult, Failure>::from_json_payload(&res.unwrap_success()[0])
-        .unwrap();
+    let res =
+        Result::<NexusOperationResult, Failure>::from_json_payload(res.payloads.first().unwrap())
+            .unwrap();
     match outcome {
         Outcome::Succeed => {
             let p = assert_matches!(
@@ -194,6 +229,80 @@ async fn nexus_basic(
         .unwrap();
 }
 
+#[workflow]
+struct NexusAsyncWf {
+    endpoint: String,
+    schedule_to_close_timeout: Option<Duration>,
+    outcome: Outcome,
+}
+
+#[workflow_methods]
+impl NexusAsyncWf {
+    #[init]
+    fn new(
+        _ctx: &WorkflowContextView,
+        (endpoint, schedule_to_close_timeout, outcome): (String, Option<Duration>, Outcome),
+    ) -> Self {
+        Self {
+            endpoint,
+            schedule_to_close_timeout,
+            outcome,
+        }
+    }
+
+    #[run]
+    pub(crate) async fn run(
+        ctx: &mut WorkflowContext<Self>,
+    ) -> WorkflowResult<NexusOperationResult> {
+        let started = ctx.start_nexus_operation(NexusOperationOptions {
+            endpoint: ctx.state(|wf| wf.endpoint.clone()),
+            service: "svc".to_string(),
+            operation: "op".to_string(),
+            schedule_to_close_timeout: ctx.state(|wf| wf.schedule_to_close_timeout),
+            ..Default::default()
+        });
+        if ctx.state(|wf| wf.outcome) == Outcome::CancelAfterRecordedBeforeStarted {
+            ctx.timer(Duration::from_millis(1)).await;
+            started.cancel();
+        }
+        let started = started.await.unwrap();
+        let result = started.result();
+        if matches!(ctx.state(|wf| wf.outcome), Outcome::Cancel) {
+            started.cancel();
+            started.cancel();
+        }
+        let res = result.await;
+        started.cancel();
+        Ok(res)
+    }
+}
+
+#[workflow]
+struct AsyncCompleter {
+    outcome: Outcome,
+}
+
+#[workflow_methods]
+impl AsyncCompleter {
+    #[init]
+    fn new(_ctx: &WorkflowContextView, outcome: Outcome) -> Self {
+        Self { outcome }
+    }
+
+    #[allow(dead_code)] // Started via untyped submitter handle
+    #[run]
+    pub(crate) async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<String> {
+        match ctx.state(|wf| wf.outcome) {
+            Outcome::Succeed => Ok("completed async".to_string()),
+            Outcome::Cancel | Outcome::CancelAfterRecordedBeforeStarted => {
+                ctx.cancelled().await;
+                Err(WorkflowTermination::Cancelled)
+            }
+            _ => Err(anyhow!("broken").into()),
+        }
+    }
+}
+
 #[rstest::rstest]
 #[tokio::test]
 async fn nexus_async(
@@ -208,67 +317,40 @@ async fn nexus_async(
 ) {
     let wf_name = "nexus_async";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.task_types(WorkerTaskTypes {
+    starter.sdk_config.task_types = WorkerTaskTypes {
         enable_workflows: true,
         enable_local_activities: false,
         enable_remote_activities: false,
         enable_nexus: true,
-    });
+    };
     let mut worker = starter.worker().await;
     let core_worker = starter.get_worker().await;
 
     let endpoint = mk_nexus_endpoint(&mut starter).await;
     let schedule_to_close_timeout = if outcome == Outcome::CancelAfterRecordedBeforeStarted {
-        // If we set this, it'll time out before we can cancel it.
         None
     } else {
         Some(Duration::from_secs(5))
     };
 
-    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| {
-        let endpoint = endpoint.clone();
-        async move {
-            let started = ctx.start_nexus_operation(NexusOperationOptions {
-                endpoint,
-                service: "svc".to_string(),
-                operation: "op".to_string(),
-                schedule_to_close_timeout,
-                ..Default::default()
-            });
-            if outcome == Outcome::CancelAfterRecordedBeforeStarted {
-                ctx.timer(Duration::from_millis(1)).await;
-                started.cancel(&ctx);
-            }
-            let started = started.await.unwrap();
-            let result = started.result();
-            if matches!(outcome, Outcome::Cancel) {
-                started.cancel(&ctx);
-                // Make sure double-cancel doesn't cause problems
-                started.cancel(&ctx);
-            }
-            let res = result.await;
-            // Make sure cancel after completion doesn't cause problems
-            started.cancel(&ctx);
-            Ok(res.into())
-        }
-    });
-    worker.register_wf(
-        "async_completer".to_owned(),
-        move |ctx: WfContext| async move {
-            match outcome {
-                Outcome::Succeed => Ok("completed async".into()),
-                Outcome::Cancel | Outcome::CancelAfterRecordedBeforeStarted => {
-                    ctx.cancelled().await;
-                    Ok(WfExitValue::Cancelled)
-                }
-                _ => bail!("broken"),
-            }
-        },
-    );
+    worker.register_workflow::<NexusAsyncWf>();
+    worker.register_workflow::<AsyncCompleter>();
     let submitter = worker.get_submitter_handle();
-    let wf_handle = starter.start_with_worker(wf_name, &mut worker).await;
+    let converter = PayloadConverter::default();
+    let ser_ctx = SerializationContext {
+        data: &SerializationContextData::Workflow,
+        converter: &converter,
+    };
+    let wf_handle = worker
+        .submit_workflow(
+            NexusAsyncWf::run,
+            (endpoint.clone(), schedule_to_close_timeout, outcome),
+            starter.workflow_options.clone(),
+        )
+        .await
+        .unwrap();
 
-    let client = starter.get_client().await.get_client().clone();
+    let client = starter.get_client().await;
     let nexus_task_handle = async {
         let mut nt = core_worker.poll_nexus_task().await.unwrap().unwrap_task();
         // Verify request header key for timeout exists and is lowercase
@@ -311,23 +393,22 @@ async fn nexus_async(
 
             // Start the workflow which will act like the nexus handler and complete the async
             // operation
+            let payloads = vec![converter.to_payload(&ser_ctx, &outcome).unwrap()];
+            let task_queue = starter.get_task_queue().to_owned();
             submitter
                 .submit_wf(
-                    completer_id.clone(),
-                    "async_completer",
-                    vec![],
-                    WorkflowOptions {
-                        completion_callbacks: vec![Callback {
+                    AsyncCompleter::name(),
+                    payloads,
+                    WorkflowStartOptions::new(task_queue, completer_id.clone())
+                        .completion_callbacks(vec![Callback {
                             variant: Some(callback::Variant::Nexus(callback::Nexus {
                                 url: start_req.callback,
                                 header: start_req.callback_header,
                             })),
                             links: links.clone(),
-                        }],
-                        // Also send links in the root of the workflow options for older servers.
-                        links,
-                        ..Default::default()
-                    },
+                        }])
+                        .links(links)
+                        .build(),
                 )
                 .await
                 .unwrap();
@@ -364,8 +445,13 @@ async fn nexus_async(
                 nt.request.unwrap().variant.unwrap(),
                 request::Variant::CancelOperation(_)
             );
-            client
-                .cancel_workflow_execution(completer_id, None, "nexus cancel".to_string(), None)
+            let handle = client.get_workflow_handle::<UntypedWorkflow>(completer_id);
+            handle
+                .cancel(
+                    WorkflowCancelOptions::builder()
+                        .reason("nexus cancel")
+                        .build(),
+                )
                 .await
                 .unwrap();
             core_worker
@@ -393,11 +479,11 @@ async fn nexus_async(
     });
 
     let res = client
-        .get_untyped_workflow_handle(starter.get_task_queue().to_owned(), "")
-        .get_workflow_result(Default::default())
+        .get_workflow_handle::<UntypedWorkflow>(starter.get_task_queue().to_owned())
+        .get_result(Default::default())
         .await
         .unwrap();
-    let res = NexusOperationResult::from_json_payload(&res.unwrap_success()[0]).unwrap();
+    let res = NexusOperationResult::from_json_payload(res.payloads.first().unwrap()).unwrap();
     match outcome {
         Outcome::Succeed => {
             let p = assert_matches!(
@@ -412,7 +498,7 @@ async fn nexus_async(
                 Some(nexus_operation_result::Status::Failed(f)) => f
             );
             assert_eq!(f.message, "nexus operation completed unsuccessfully");
-            assert_eq!(f.cause.unwrap().message, "broken");
+            assert_eq!(f.cause.unwrap().message, "Workflow execution error: broken");
         }
         Outcome::Cancel | Outcome::CancelAfterRecordedBeforeStarted => {
             let f = assert_matches!(
@@ -436,43 +522,64 @@ async fn nexus_async(
         .await
         .unwrap();
 }
+#[workflow]
+#[derive(Default)]
+struct NexusCancelBeforeStartWf {
+    endpoint: String,
+}
+
+#[workflow_methods]
+impl NexusCancelBeforeStartWf {
+    #[init]
+    fn new(_ctx: &WorkflowContextView, endpoint: String) -> Self {
+        Self { endpoint }
+    }
+
+    #[run]
+    pub(crate) async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        let started = ctx.start_nexus_operation(NexusOperationOptions {
+            endpoint: ctx.state(|wf| wf.endpoint.clone()),
+            service: "svc".to_string(),
+            operation: "op".to_string(),
+            ..Default::default()
+        });
+        started.cancel();
+        let res = started.await.unwrap_err();
+        assert_eq!(res.message, "Nexus Operation cancelled before scheduled");
+        if let FailureInfo::NexusOperationExecutionFailureInfo(fi) = res.failure_info.unwrap() {
+            assert_eq!(fi.endpoint, ctx.state(|wf| wf.endpoint.clone()));
+            assert_eq!(fi.service, "svc");
+            assert_eq!(fi.operation, "op");
+        } else {
+            panic!("unexpected failure info");
+        }
+        Ok(())
+    }
+}
+
 #[tokio::test]
 async fn nexus_cancel_before_start() {
     let wf_name = "nexus_cancel_before_start";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.task_types(WorkerTaskTypes {
+    starter.sdk_config.task_types = WorkerTaskTypes {
         enable_workflows: true,
         enable_local_activities: false,
         enable_remote_activities: false,
         enable_nexus: true,
-    });
+    };
     let mut worker = starter.worker().await;
 
     let endpoint = mk_nexus_endpoint(&mut starter).await;
 
-    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| {
-        let endpoint = endpoint.clone();
-        async move {
-            let started = ctx.start_nexus_operation(NexusOperationOptions {
-                endpoint: endpoint.clone(),
-                service: "svc".to_string(),
-                operation: "op".to_string(),
-                ..Default::default()
-            });
-            started.cancel(&ctx);
-            let res = started.await.unwrap_err();
-            assert_eq!(res.message, "Nexus Operation cancelled before scheduled");
-            if let FailureInfo::NexusOperationExecutionFailureInfo(fi) = res.failure_info.unwrap() {
-                assert_eq!(fi.endpoint, endpoint);
-                assert_eq!(fi.service, "svc");
-                assert_eq!(fi.operation, "op");
-            } else {
-                panic!("unexpected failure info");
-            }
-            Ok(().into())
-        }
-    });
-    let handle = starter.start_with_worker(wf_name, &mut worker).await;
+    worker.register_workflow::<NexusCancelBeforeStartWf>();
+    let handle = worker
+        .submit_workflow(
+            NexusCancelBeforeStartWf::run,
+            endpoint,
+            starter.workflow_options.clone(),
+        )
+        .await
+        .unwrap();
 
     worker.run_until_done().await.unwrap();
 
@@ -482,55 +589,71 @@ async fn nexus_cancel_before_start() {
         .unwrap();
 }
 
+#[workflow]
+#[derive(Default)]
+struct NexusMustCompleteTaskWf {
+    endpoint: String,
+}
+
+#[workflow_methods]
+impl NexusMustCompleteTaskWf {
+    #[init]
+    fn new(_ctx: &WorkflowContextView, endpoint: String) -> Self {
+        Self { endpoint }
+    }
+
+    #[run]
+    pub(crate) async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        // We just need to create the command, not await it.
+        drop(ctx.start_nexus_operation(NexusOperationOptions {
+            endpoint: ctx.state(|wf| wf.endpoint.clone()),
+            service: "svc".to_string(),
+            operation: "op".to_string(),
+            ..Default::default()
+        }));
+        // Workflow completes right away, only having scheduled the operation. We need a timer
+        // to make sure the nexus task actually gets scheduled.
+        ctx.timer(Duration::from_millis(1)).await;
+        // started.await.unwrap();
+        Ok(())
+    }
+}
+
 #[rstest::rstest]
 #[tokio::test]
 async fn nexus_must_complete_task_to_shutdown(#[values(true, false)] use_grace_period: bool) {
     let wf_name = "nexus_must_complete_task_to_shutdown";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.task_types(WorkerTaskTypes {
+    starter.sdk_config.task_types = WorkerTaskTypes {
         enable_workflows: true,
         enable_local_activities: false,
         enable_remote_activities: false,
         enable_nexus: true,
-    });
+    };
     if use_grace_period {
-        starter
-            .worker_config
-            .graceful_shutdown_period(Duration::from_millis(500));
+        starter.sdk_config.graceful_shutdown_period = Some(Duration::from_millis(500));
     }
     let mut worker = starter.worker().await;
     let core_worker = starter.get_worker().await;
 
     let endpoint = mk_nexus_endpoint(&mut starter).await;
 
-    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| {
-        let endpoint = endpoint.clone();
-        async move {
-            // We just need to create the command, not await it.
-            drop(ctx.start_nexus_operation(NexusOperationOptions {
-                endpoint: endpoint.clone(),
-                service: "svc".to_string(),
-                operation: "op".to_string(),
-                ..Default::default()
-            }));
-            // Workflow completes right away, only having scheduled the operation. We need a timer
-            // to make sure the nexus task actually gets scheduled.
-            ctx.timer(Duration::from_millis(1)).await;
-            // started.await.unwrap();
-            Ok(().into())
-        }
-    });
-    let handle = starter.start_with_worker(wf_name, &mut worker).await;
+    worker.register_workflow::<NexusMustCompleteTaskWf>();
+    let handle = worker
+        .submit_workflow(
+            NexusMustCompleteTaskWf::run,
+            endpoint,
+            starter.workflow_options.clone(),
+        )
+        .await
+        .unwrap();
     let (complete_order_tx, mut complete_order_rx) = mpsc::unbounded_channel();
 
     let task_handle = async {
         // Should get the nexus task first
         let nt = core_worker.poll_nexus_task().await.unwrap().unwrap_task();
         // The workflow will complete
-        handle
-            .get_workflow_result(Default::default())
-            .await
-            .unwrap();
+        handle.get_result(Default::default()).await.unwrap();
         if use_grace_period {
             // Wait for cancel to be sent
             let nt = core_worker.poll_nexus_task().await.unwrap();
@@ -546,6 +669,7 @@ async fn nexus_must_complete_task_to_shutdown(#[values(true, false)] use_grace_p
             core_worker
                 .complete_nexus_task(NexusTaskCompletion {
                     task_token: nt.task_token,
+                    #[allow(deprecated)]
                     status: Some(nexus_task_completion::Status::Error(HandlerError {
                         error_type: "BAD_REQUEST".to_string(), // bad req is non-retryable
                         failure: Some(nexus::v1::Failure {
@@ -579,6 +703,89 @@ async fn nexus_must_complete_task_to_shutdown(#[values(true, false)] use_grace_p
         .unwrap();
 }
 
+#[workflow]
+struct NexusCancellationCallerWf {
+    endpoint: String,
+    schedule_to_close_timeout: Option<Duration>,
+    cancellation_type: NexusOperationCancellationType,
+    caller_op_future_tx: watch::Sender<bool>,
+}
+
+#[workflow_methods(factory_only)]
+impl NexusCancellationCallerWf {
+    #[run(name = "nexus_cancellation_types")]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<NexusOperationResult> {
+        let options = NexusOperationOptions {
+            endpoint: ctx.state(|wf| wf.endpoint.clone()),
+            service: "svc".to_string(),
+            operation: "op".to_string(),
+            schedule_to_close_timeout: ctx.state(|wf| wf.schedule_to_close_timeout),
+            cancellation_type: Some(ctx.state(|wf| wf.cancellation_type)),
+            ..Default::default()
+        };
+        let started = ctx.start_nexus_operation(options);
+        let started = started.await.unwrap();
+        let result = started.result();
+        started.cancel();
+        started.cancel();
+
+        let res = result.await;
+        ctx.state(|wf| wf.caller_op_future_tx.send(true).unwrap());
+
+        // Make sure cancel after op completion doesn't cause problems
+        started.cancel();
+
+        // We need to wait slightly so that the workflow is not complete at the same time
+        // cancellation is invoked. If it does, the caller workflow will close and the server
+        // won't attempt to send the cancellation to the handler
+        ctx.timer(Duration::from_millis(1)).await;
+        Ok(res)
+    }
+}
+
+#[workflow]
+struct AsyncCompleterWf {
+    cancellation_type: NexusOperationCancellationType,
+    cancellation_wait_happened: Arc<AtomicBool>,
+    cancellation_tx: watch::Sender<bool>,
+    handler_exited_tx: watch::Sender<bool>,
+    proceed_signal_received: bool,
+}
+
+#[workflow_methods(factory_only)]
+impl AsyncCompleterWf {
+    #[run(name = "async_completer")]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        // Wait for cancellation
+        ctx.cancelled().await;
+        ctx.state(|wf| wf.cancellation_tx.send(true).unwrap());
+
+        if ctx.state(|wf| wf.cancellation_type)
+            == NexusOperationCancellationType::WaitCancellationCompleted
+        {
+            ctx.wait_condition(|wf| wf.cancellation_wait_happened.load(Ordering::Relaxed))
+                .await;
+        } else if ctx.state(|wf| wf.cancellation_type)
+            == NexusOperationCancellationType::WaitCancellationRequested
+        {
+            // For WAIT_REQUESTED, wait until the caller nexus op future has been resolved. This
+            // allows the test to verify that it resolved due to
+            // NexusOperationCancelRequestCompleted (written after cancel handler responds)
+            // rather than NexusOperationCanceled (written after handler workflow completes as
+            // cancelled).
+            ctx.wait_condition(|wf| wf.proceed_signal_received).await;
+        }
+
+        ctx.state(|wf| wf.handler_exited_tx.send(true).unwrap());
+        Err(WorkflowTermination::Cancelled)
+    }
+
+    #[signal(name = "proceed-to-exit")]
+    fn handle_proceed_signal(&mut self, _ctx: &mut SyncWorkflowContext<Self>) {
+        self.proceed_signal_received = true;
+    }
+}
+
 #[rstest::rstest]
 #[tokio::test]
 async fn nexus_cancellation_types(
@@ -592,12 +799,12 @@ async fn nexus_cancellation_types(
 ) {
     let wf_name = "nexus_cancellation_types";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.task_types(WorkerTaskTypes {
+    starter.sdk_config.task_types = WorkerTaskTypes {
         enable_workflows: true,
         enable_local_activities: false,
         enable_remote_activities: false,
         enable_nexus: true,
-    });
+    };
     let mut worker = starter.worker().await;
     let core_worker = starter.get_worker().await;
 
@@ -605,72 +812,35 @@ async fn nexus_cancellation_types(
     let schedule_to_close_timeout = Some(Duration::from_secs(5));
 
     let (caller_op_future_tx, caller_op_future_rx) = watch::channel(false);
-    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| {
+    worker.register_workflow_with_factory({
         let endpoint = endpoint.clone();
         let caller_op_future_tx = caller_op_future_tx.clone();
-        async move {
-            let options = NexusOperationOptions {
-                endpoint,
-                service: "svc".to_string(),
-                operation: "op".to_string(),
-                schedule_to_close_timeout,
-                cancellation_type: Some(cancellation_type),
-                ..Default::default()
-            };
-            let started = ctx.start_nexus_operation(options);
-            let started = started.await.unwrap();
-            let result = started.result();
-            started.cancel(&ctx);
-            started.cancel(&ctx);
-
-            let res = result.await;
-            caller_op_future_tx.send(true).unwrap();
-
-            // Make sure cancel after op completion doesn't cause problems
-            started.cancel(&ctx);
-
-            // We need to wait slightly so that the workflow is not complete at the same time
-            // cancellation is invoked. If it does, the caller workflow will close and the server
-            // won't attempt to send the cancellation to the handler
-            ctx.timer(Duration::from_millis(1)).await;
-            Ok(res.into())
+        move || NexusCancellationCallerWf {
+            endpoint: endpoint.clone(),
+            schedule_to_close_timeout,
+            cancellation_type,
+            caller_op_future_tx: caller_op_future_tx.clone(),
         }
     });
 
     let cancellation_wait_happened = Arc::new(AtomicBool::new(false));
-    let cancellation_wait_happened_clone = cancellation_wait_happened.clone();
     let (cancellation_tx, mut cancellation_rx) = watch::channel(false);
     let (handler_exited_tx, mut handler_exited_rx) = watch::channel(false);
-    worker.register_wf("async_completer".to_owned(), move |ctx: WfContext| {
+    worker.register_workflow_with_factory({
+        let cancellation_wait_happened = cancellation_wait_happened.clone();
         let cancellation_tx = cancellation_tx.clone();
-        let cancellation_wait_happened = cancellation_wait_happened_clone.clone();
         let handler_exited_tx = handler_exited_tx.clone();
-        async move {
-            // Wait for cancellation
-            ctx.cancelled().await;
-            cancellation_tx.send(true).unwrap();
-
-            if cancellation_type == NexusOperationCancellationType::WaitCancellationCompleted {
-                ctx.wait_condition(|| cancellation_wait_happened.load(Ordering::Relaxed))
-                    .await;
-            } else if cancellation_type == NexusOperationCancellationType::WaitCancellationRequested
-            {
-                // For WAIT_REQUESTED, wait until the caller nexus op future has been resolved. This
-                // allows the test to verify that it resolved due to
-                // NexusOperationCancelRequestCompleted (written after cancel handler responds)
-                // rather than NexusOperationCanceled (written after handler workflow completes as
-                // cancelled).
-                let mut signal_chan = ctx.make_signal_channel("proceed-to-exit");
-                signal_chan.next().await;
-            }
-
-            handler_exited_tx.send(true).unwrap();
-            Ok(WfExitValue::<()>::Cancelled)
+        move || AsyncCompleterWf {
+            cancellation_type,
+            cancellation_wait_happened: cancellation_wait_happened.clone(),
+            cancellation_tx: cancellation_tx.clone(),
+            handler_exited_tx: handler_exited_tx.clone(),
+            proceed_signal_received: false,
         }
     });
     let submitter = worker.get_submitter_handle();
     let wf_handle = starter.start_with_worker(wf_name, &mut worker).await;
-    let client = starter.get_client().await.get_client().clone();
+    let client = starter.get_client().await;
     let (handler_wf_id_tx, mut handler_wf_id_rx) = tokio::sync::oneshot::channel();
     let completer_id = &format!("completer-{}", rand_6_chars());
     let nexus_task_handle = async {
@@ -689,23 +859,21 @@ async fn nexus_cancellation_types(
 
         // Start the workflow which will act like the nexus handler and complete the async
         // operation
+        let task_queue = starter.get_task_queue().to_owned();
         submitter
             .submit_wf(
-                completer_id.clone(),
                 "async_completer",
                 vec![],
-                WorkflowOptions {
-                    completion_callbacks: vec![Callback {
+                WorkflowStartOptions::new(task_queue, completer_id.clone())
+                    .completion_callbacks(vec![Callback {
                         variant: Some(callback::Variant::Nexus(callback::Nexus {
                             url: start_req.callback,
                             header: start_req.callback_header,
                         })),
                         links: links.clone(),
-                    }],
-                    // Also send links in the root of the workflow options for older servers.
-                    links,
-                    ..Default::default()
-                },
+                    }])
+                    .links(links)
+                    .build(),
             )
             .await
             .unwrap();
@@ -739,10 +907,7 @@ async fn nexus_cancellation_types(
                 assert!(!*caller_op_future_rx.borrow());
             }
             NexusOperationCancellationType::Abandon | NexusOperationCancellationType::TryCancel => {
-                wf_handle
-                    .get_workflow_result(Default::default())
-                    .await
-                    .unwrap();
+                wf_handle.get_result(Default::default()).await.unwrap();
                 // The nexus op future should have been resolved
                 assert!(*caller_op_future_rx.borrow())
             }
@@ -755,12 +920,12 @@ async fn nexus_cancellation_types(
                 nt.request.unwrap().variant.unwrap(),
                 request::Variant::CancelOperation(_)
             );
-            client
-                .cancel_workflow_execution(
-                    completer_id.to_string(),
-                    None,
-                    "nexus cancel".to_string(),
-                    None,
+            let handle = client.get_workflow_handle::<UntypedWorkflow>(completer_id.to_string());
+            handle
+                .cancel(
+                    WorkflowCancelOptions::builder()
+                        .reason("nexus cancel")
+                        .build(),
                 )
                 .await
                 .unwrap();
@@ -789,18 +954,14 @@ async fn nexus_cancellation_types(
             // Send a signal just to wake up the workflow so it'll check the condition
             // (it may already have completed, so ignore the result)
             let _ = client
-                .signal_workflow_execution(
-                    completer_id.to_string(),
-                    "".to_string(),
-                    "wakeupdude".to_string(),
-                    None,
-                    None,
+                .get_workflow_handle::<UntypedWorkflow>(completer_id.to_string())
+                .signal(
+                    UntypedSignal::new("wakeupdude"),
+                    RawValue::empty(),
+                    WorkflowSignalOptions::default(),
                 )
                 .await;
-            wf_handle
-                .get_workflow_result(Default::default())
-                .await
-                .unwrap();
+            wf_handle.get_result(Default::default()).await.unwrap();
             assert!(*caller_op_future_rx.borrow());
         }
 
@@ -829,12 +990,11 @@ async fn nexus_cancellation_types(
             .try_recv()
             .expect("Should have received handler workflow ID");
         client
-            .signal_workflow_execution(
-                handler_wf_id,
-                "".to_string(),
-                "proceed-to-exit".to_string(),
-                None,
-                None,
+            .get_workflow_handle::<async_completer_wf::Run>(handler_wf_id)
+            .signal(
+                AsyncCompleterWf::handle_proceed_signal,
+                (),
+                WorkflowSignalOptions::default(),
             )
             .await
             .unwrap();
@@ -847,10 +1007,7 @@ async fn nexus_cancellation_types(
         nexus_task_handle,
         async { worker.inner_mut().run().await.unwrap() },
         async {
-            wf_handle
-                .get_workflow_result(Default::default())
-                .await
-                .unwrap();
+            wf_handle.get_result(Default::default()).await.unwrap();
             if cancellation_type == NexusOperationCancellationType::TryCancel {
                 cancellation_rx.changed().await.unwrap();
             }
@@ -873,11 +1030,11 @@ async fn nexus_cancellation_types(
     }
 
     let res = client
-        .get_untyped_workflow_handle(starter.get_task_queue().to_owned(), "")
-        .get_workflow_result(Default::default())
+        .get_workflow_handle::<UntypedWorkflow>(starter.get_task_queue().to_owned())
+        .get_result(Default::default())
         .await
         .unwrap();
-    let res = NexusOperationResult::from_json_payload(&res.unwrap_success()[0]).unwrap();
+    let res = NexusOperationResult::from_json_payload(res.payloads.first().unwrap()).unwrap();
 
     match cancellation_type {
         NexusOperationCancellationType::Abandon | NexusOperationCancellationType::TryCancel => {