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

package/sdk-core/crates/sdk-core/tests/integ_tests/update_tests.rs

@@ -1,24 +1,28 @@
 use crate::common::{
-    CoreWfStarter, WorkflowHandleExt, init_core_and_create_wf, init_core_replay_preloaded,
+    CoreWfStarter, WorkflowHandleExt, activity_functions::StdActivities, init_core_and_create_wf,
+    init_core_replay_preloaded,
 };
 use anyhow::anyhow;
 use assert_matches::assert_matches;
-use futures_util::{StreamExt, future, future::join_all};
+use futures_util::{future, future::join_all};
 use std::{
     sync::{
-        Arc, LazyLock,
+        LazyLock,
         atomic::{AtomicBool, AtomicUsize, Ordering},
     },
     time::Duration,
 };
 use temporalio_client::{
-    Client, NamespacedClient, RetryClient, WorkflowClientTrait, WorkflowService,
+    Client, NamespacedClient, UntypedSignal, UntypedUpdate, UntypedWorkflow,
+    WorkflowExecuteUpdateOptions, WorkflowExecutionInfo, WorkflowSignalOptions,
+    WorkflowStartOptions, grpc::WorkflowService,
 };
 use temporalio_common::{
-    Worker, prost_dur,
+    data_converters::RawValue,
+    prost_dur,
     protos::{
         coresdk::{
-            ActivityTaskCompletion, AsJsonPayloadExt, IntoPayloadsExt,
+            ActivityTaskCompletion,
             activity_result::ActivityExecutionResult,
             workflow_activation::{
                 WorkflowActivationJob, remove_from_cache::EvictionReason, workflow_activation_job,
@@ -30,16 +34,21 @@ use temporalio_common::{
         },
         temporal::api::{
             common::v1::WorkflowExecution,
-            enums::v1::{EventType, ResetReapplyType, UpdateWorkflowExecutionLifecycleStage},
-            update::{self, v1::WaitPolicy},
-            workflowservice::v1::ResetWorkflowExecutionRequest,
+            enums::v1::{EventType, ResetReapplyType},
+            workflowservice::v1::{ResetStickyTaskQueueRequest, ResetWorkflowExecutionRequest},
         },
         test_utils::start_timer_cmd,
     },
     worker::WorkerTaskTypes,
 };
-use temporalio_sdk::{ActContext, ActivityOptions, LocalActivityOptions, UpdateContext, WfContext};
+use temporalio_macros::{activities, workflow, workflow_methods};
+use temporalio_sdk::{
+    ActivityOptions, LocalActivityOptions, SyncWorkflowContext, WorkflowContext,
+    WorkflowContextView, WorkflowResult,
+    activities::{ActivityContext, ActivityError},
+};
 use temporalio_sdk_core::{
+    Worker,
     replay::HistoryForReplay,
     test_help::{WorkerTestHelpers, drain_pollers_and_shutdown},
 };
@@ -73,18 +82,18 @@ async fn update_workflow(#[values(FailUpdate::Yes, FailUpdate::No)] will_fail: F
         will_fail,
         CompleteWorkflow::Yes,
         core.as_ref(),
-        client.as_ref(),
+        &client,
     )
     .await;
 
     // Make sure replay works
-    let history = client
-        .get_workflow_execution_history(workflow_id.to_string(), None, vec![])
+    let events = client
+        .get_workflow_handle::<UntypedWorkflow>(workflow_id)
+        .fetch_history(Default::default())
         .await
         .unwrap()
-        .history
-        .unwrap();
-    let with_id = HistoryForReplay::new(history, workflow_id.to_string());
+        .into_events();
+    let with_id = HistoryForReplay::new(events, workflow_id.to_string());
     let replay_worker = init_core_replay_preloaded(workflow_id, [with_id]);
     // Init workflow comes by itself
     let act = replay_worker.poll_workflow_activation().await.unwrap();
@@ -92,7 +101,7 @@ async fn update_workflow(#[values(FailUpdate::Yes, FailUpdate::No)] will_fail: F
         .complete_workflow_activation(WorkflowActivationCompletion::empty(act.run_id))
         .await
         .unwrap();
-    handle_update(will_fail, CompleteWorkflow::Yes, replay_worker.as_ref(), 0).await;
+    handle_update(will_fail, CompleteWorkflow::Yes, &replay_worker, 0).await;
 }
 
 #[tokio::test]
@@ -107,7 +116,7 @@ async fn reapplied_updates_due_to_reset() {
         FailUpdate::No,
         CompleteWorkflow::Yes,
         core.as_ref(),
-        client.as_ref(),
+        &client,
     )
     .await;
 
@@ -116,12 +125,12 @@ async fn reapplied_updates_due_to_reset() {
 
     let mut client_mut = client.clone();
     let reset_response = WorkflowService::reset_workflow_execution(
-        Arc::make_mut(&mut client_mut),
+        &mut client_mut,
         #[allow(deprecated)]
         ResetWorkflowExecutionRequest {
             namespace: client.namespace(),
             workflow_execution: Some(WorkflowExecution {
-                workflow_id: workflow_id.into(),
+                workflow_id: workflow_id.to_string(),
                 run_id: pre_reset_run_id.clone(),
             }),
             workflow_task_finish_event_id,
@@ -147,32 +156,31 @@ async fn reapplied_updates_due_to_reset() {
         FailUpdate::No,
         CompleteWorkflow::Yes,
         core.as_ref(),
-        client.as_ref(),
+        &client,
     )
     .await;
 
     assert_eq!(post_reset_run_id, reset_response.run_id);
 
     // Make sure replay works
-    let history = client
-        .get_workflow_execution_history(workflow_id.to_string(), Some(post_reset_run_id), vec![])
-        .await
-        .unwrap()
-        .history
-        .unwrap();
-    let with_id = HistoryForReplay::new(history, workflow_id.to_string());
+    let events = WorkflowExecutionInfo {
+        namespace: client.namespace(),
+        workflow_id: workflow_id.to_string(),
+        run_id: Some(post_reset_run_id.clone()),
+        first_execution_run_id: None,
+    }
+    .bind_untyped(client.clone())
+    .fetch_history(Default::default())
+    .await
+    .unwrap()
+    .into_events();
+    let with_id = HistoryForReplay::new(events, workflow_id.to_string());
 
     let replay_worker = init_core_replay_preloaded(workflow_id, [with_id]);
     // We now recapitulate the actions that the worker took on first execution above, pretending
     // that we always followed the post-reset history.
     // First, we handled the post-reset reapplied update and did not complete the workflow.
-    handle_update(
-        FailUpdate::No,
-        CompleteWorkflow::No,
-        replay_worker.as_ref(),
-        2,
-    )
-    .await;
+    handle_update(FailUpdate::No, CompleteWorkflow::No, &replay_worker, 2).await;
     // Then the timer fires
     let act = replay_worker.poll_workflow_activation().await.unwrap();
     replay_worker
@@ -180,13 +188,7 @@ async fn reapplied_updates_due_to_reset() {
         .await
         .unwrap();
     // Then the client sent a second update; we handled it and completed the workflow.
-    handle_update(
-        FailUpdate::No,
-        CompleteWorkflow::Yes,
-        replay_worker.as_ref(),
-        0,
-    )
-    .await;
+    handle_update(FailUpdate::No, CompleteWorkflow::Yes, &replay_worker, 0).await;
 
     drain_pollers_and_shutdown(&replay_worker).await;
 }
@@ -197,8 +199,8 @@ async fn send_and_handle_update(
     update_id: &str,
     fail_update: FailUpdate,
     complete_workflow: CompleteWorkflow,
-    core: &dyn Worker,
-    client: &RetryClient<Client>,
+    core: &Worker,
+    client: &Client,
 ) -> String {
     // Complete first task with no commands
     let act = core.poll_workflow_activation().await.unwrap();
@@ -206,30 +208,32 @@ async fn send_and_handle_update(
         .await
         .unwrap();
 
+    let handle = WorkflowExecutionInfo {
+        namespace: client.namespace(),
+        workflow_id: workflow_id.to_string(),
+        run_id: Some(act.run_id.clone()),
+        first_execution_run_id: None,
+    }
+    .bind_untyped(client.clone());
+
     // Send the update to the server
     let update_task = async {
-        client
-            .update_workflow_execution(
-                workflow_id.to_string(),
-                act.run_id.to_string(),
-                update_id.to_string(),
-                WaitPolicy {
-                    lifecycle_stage: UpdateWorkflowExecutionLifecycleStage::Completed as i32,
-                },
-                Some("hi".into()),
+        handle
+            .execute_update(
+                UntypedUpdate::new(update_id),
+                RawValue::from_value(&"hi", client.data_converter().payload_converter()),
+                WorkflowExecuteUpdateOptions::default(),
             )
             .await
-            .unwrap()
     };
 
     // Accept update, complete update and complete workflow
     let processing_task = handle_update(fail_update, complete_workflow, core, 0);
     let (ur, _) = join!(update_task, processing_task);
 
-    let v = ur.outcome.unwrap().value.unwrap();
     match fail_update {
-        FailUpdate::Yes => assert_matches!(v, update::v1::outcome::Value::Failure(_)),
-        FailUpdate::No => assert_matches!(v, update::v1::outcome::Value::Success(_)),
+        FailUpdate::Yes => assert!(ur.is_err()),
+        FailUpdate::No => assert!(ur.is_ok()),
     }
     act.run_id
 }
@@ -241,7 +245,7 @@ async fn send_and_handle_update(
 async fn handle_update(
     fail_update: FailUpdate,
     complete_workflow: CompleteWorkflow,
-    core: &dyn Worker,
+    core: &Worker,
     update_job_index: usize,
 ) {
     let act = core.poll_workflow_activation().await.unwrap();
@@ -313,20 +317,24 @@ async fn update_rejection() {
     .await
     .unwrap();
 
+    let handle = WorkflowExecutionInfo {
+        namespace: client.namespace(),
+        workflow_id: workflow_id.clone(),
+        run_id: Some(res.run_id.clone()),
+        first_execution_run_id: None,
+    }
+    .bind_untyped(client.clone());
+
     // Send the update to the server
     let update_task = async {
-        client
-            .update_workflow_execution(
-                workflow_id.to_string(),
-                res.run_id.to_string(),
-                update_id.to_string(),
-                WaitPolicy {
-                    lifecycle_stage: UpdateWorkflowExecutionLifecycleStage::Completed as i32,
-                },
-                Some("hi".into()),
+        // rejected
+        let _ = handle
+            .execute_update(
+                UntypedUpdate::new(update_id),
+                RawValue::from_value(&"hi", client.data_converter().payload_converter()),
+                WorkflowExecuteUpdateOptions::default(),
             )
-            .await
-            .unwrap();
+            .await;
     };
 
     let processing_task = async {
@@ -355,13 +363,13 @@ async fn update_rejection() {
         core.complete_execution(&res.run_id).await;
     };
     join!(update_task, processing_task);
-    let history = client
-        .get_workflow_execution_history(workflow_id, None, vec![])
+    let events = client
+        .get_workflow_handle::<UntypedWorkflow>(&workflow_id)
+        .fetch_history(Default::default())
         .await
         .unwrap()
-        .history
-        .unwrap();
-    let has_update_event = history.events.iter().any(|e| {
+        .into_events();
+    let has_update_event = events.iter().any(|e| {
         matches!(
             e.event_type(),
             EventType::WorkflowExecutionUpdateAccepted | EventType::WorkflowExecutionUpdateRejected
@@ -388,17 +396,21 @@ async fn update_insta_complete(#[values(true, false)] accept_first: bool) {
     .await
     .unwrap();
 
+    let handle = WorkflowExecutionInfo {
+        namespace: client.namespace(),
+        workflow_id,
+        run_id: Some(res.run_id.clone()),
+        first_execution_run_id: None,
+    }
+    .bind_untyped(client.clone());
+
     // Send the update to the server
     let (update_task, stop_wait_update) = future::abortable(async {
-        client
-            .update_workflow_execution(
-                workflow_id.to_string(),
-                res.run_id.to_string(),
-                update_id.to_string(),
-                WaitPolicy {
-                    lifecycle_stage: UpdateWorkflowExecutionLifecycleStage::Completed as i32,
-                },
-                Some("hi".into()),
+        handle
+            .execute_update(
+                UntypedUpdate::new(update_id),
+                RawValue::from_value(&"hi", client.data_converter().payload_converter()),
+                WorkflowExecuteUpdateOptions::default(),
             )
             .await
             .unwrap();
@@ -477,17 +489,21 @@ async fn update_complete_after_accept_without_new_task() {
     .await
     .unwrap();
 
+    let handle = WorkflowExecutionInfo {
+        namespace: client.namespace(),
+        workflow_id,
+        run_id: Some(res.run_id.clone()),
+        first_execution_run_id: None,
+    }
+    .bind_untyped(client.clone());
+
     // Send the update to the server
     let update_task = async {
-        client
-            .update_workflow_execution(
-                workflow_id.to_string(),
-                res.run_id.to_string(),
-                update_id.to_string(),
-                WaitPolicy {
-                    lifecycle_stage: UpdateWorkflowExecutionLifecycleStage::Completed as i32,
-                },
-                Some("hi".into()),
+        handle
+            .execute_update(
+                UntypedUpdate::new(update_id),
+                RawValue::from_value(&"hi", client.data_converter().payload_converter()),
+                WorkflowExecuteUpdateOptions::default(),
             )
             .await
             .unwrap();
@@ -565,30 +581,26 @@ async fn update_speculative_wft() {
 
     let update_id = "some_update";
 
+    let handle = client.get_workflow_handle::<UntypedWorkflow>(workflow_id);
+
     // Send update after the timer has fired
     let barr = Barrier::new(2);
     let sender_task = async {
         barr.wait().await;
-        client
-            .update_workflow_execution(
-                workflow_id.to_string(),
-                "".to_string(),
-                update_id.to_string(),
-                WaitPolicy {
-                    lifecycle_stage: UpdateWorkflowExecutionLifecycleStage::Completed as i32,
-                },
-                Some("hi".into()),
+        // rejected
+        let _ = handle
+            .execute_update(
+                UntypedUpdate::new(update_id),
+                RawValue::from_value(&"hi", client.data_converter().payload_converter()),
+                WorkflowExecuteUpdateOptions::default(),
             )
-            .await
-            .unwrap();
+            .await;
         barr.wait().await;
-        client
-            .signal_workflow_execution(
-                workflow_id.to_string(),
-                "".to_string(),
-                "hi".into(),
-                None,
-                None,
+        handle
+            .signal(
+                UntypedSignal::new("hi"),
+                RawValue::empty(),
+                WorkflowSignalOptions::default(),
             )
             .await
             .unwrap();
@@ -649,63 +661,70 @@ async fn update_with_local_acts() {
     let mut starter = CoreWfStarter::new(wf_name);
     // Short task timeout to get activities to heartbeat without taking ages
     starter.workflow_options.task_timeout = Some(Duration::from_secs(1));
+    starter.sdk_config.register_activities(StdActivities);
     let mut worker = starter.worker().await;
-    let client = starter.get_client().await;
-    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| async move {
-        ctx.update_handler(
-            "update",
-            |_: &_, _: ()| Ok(()),
-            move |ctx: UpdateContext, _: ()| async move {
-                ctx.wf_ctx
-                    .local_activity(LocalActivityOptions {
-                        activity_type: "echo_activity".to_string(),
-                        input: "hi!".as_json_payload().expect("serializes fine"),
-                        ..Default::default()
-                    })
-                    .await;
-                Ok("hi")
-            },
-        );
-        let mut sig = ctx.make_signal_channel("done");
-        sig.next().await;
-        Ok(().into())
-    });
-    worker.register_activity(
-        "echo_activity",
-        |_ctx: ActContext, echo_me: String| async move {
-            // Sleep so we'll heartbeat
-            tokio::time::sleep(Duration::from_secs(3)).await;
-            Ok(echo_me)
-        },
-    );
 
-    let handle = starter.start_with_worker(wf_name, &mut worker).await;
-    let wf_id = starter.get_task_queue().to_string();
+    #[workflow]
+    #[derive(Default)]
+    struct UpdateWithLocalActsWf {
+        done: bool,
+    }
+
+    #[workflow_methods]
+    impl UpdateWithLocalActsWf {
+        #[run]
+        async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+            ctx.wait_condition(|s| s.done).await;
+            Ok(())
+        }
+
+        #[signal]
+        fn done_signal(&mut self, _ctx: &mut SyncWorkflowContext<Self>, _: ()) {
+            self.done = true;
+        }
+
+        #[update]
+        async fn do_update(
+            ctx: &mut WorkflowContext<Self>,
+            _: (),
+        ) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
+            ctx.start_local_activity(
+                StdActivities::delay,
+                Duration::from_secs(3),
+                LocalActivityOptions::default(),
+            )
+            .await?;
+            Ok("hi".to_string())
+        }
+    }
+
+    worker.register_workflow::<UpdateWithLocalActsWf>();
+    let task_queue = starter.get_task_queue().to_owned();
+    let handle = worker
+        .submit_workflow(
+            UpdateWithLocalActsWf::run,
+            (),
+            WorkflowStartOptions::new(task_queue, starter.get_wf_id().to_owned()).build(),
+        )
+        .await
+        .unwrap();
     let update = async {
-        // make sure update has a chance to get registered
-        tokio::time::sleep(Duration::from_millis(100)).await;
         // do a handful at once
         let updates = (1..=5).map(|_| {
-            client.update_workflow_execution(
-                wf_id.clone(),
-                "".to_string(),
-                "update".to_string(),
-                WaitPolicy {
-                    lifecycle_stage: UpdateWorkflowExecutionLifecycleStage::Completed as i32,
-                },
-                [().as_json_payload().unwrap()].into_payloads(),
+            handle.execute_update(
+                UpdateWithLocalActsWf::do_update,
+                (),
+                WorkflowExecuteUpdateOptions::default(),
             )
         });
         for res in join_all(updates).await {
-            assert!(res.unwrap().outcome.unwrap().is_success());
+            assert!(res.unwrap() == "hi");
         }
-        client
-            .signal_workflow_execution(
-                wf_id.clone(),
-                "".to_string(),
-                "done".to_string(),
-                None,
-                None,
+        handle
+            .signal(
+                UpdateWithLocalActsWf::done_signal,
+                (),
+                WorkflowSignalOptions::default(),
             )
             .await
             .unwrap();
@@ -724,37 +743,57 @@ async fn update_with_local_acts() {
 async fn update_rejection_sdk() {
     let wf_name = "update_rejection_sdk";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter
-        .worker_config
-        .task_types(WorkerTaskTypes::workflow_only());
+    starter.sdk_config.task_types = WorkerTaskTypes::workflow_only();
     let mut worker = starter.worker().await;
-    let client = starter.get_client().await;
-    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
-        ctx.update_handler(
-            "update",
-            |_: &_, _: ()| Err(anyhow!("ahhhhh noooo")),
-            move |_: UpdateContext, _: ()| async { Ok("hi") },
-        );
-        ctx.timer(Duration::from_secs(1)).await;
-        Ok(().into())
-    });
+    #[workflow]
+    #[derive(Default)]
+    struct UpdateRejectionSdkWf;
+
+    #[workflow_methods]
+    impl UpdateRejectionSdkWf {
+        #[run]
+        async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+            ctx.timer(Duration::from_secs(1)).await;
+            Ok(())
+        }
+
+        #[update_validator(do_update)]
+        fn validate_do_update(
+            &self,
+            _ctx: &WorkflowContextView,
+            _: &(),
+        ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+            Err("ahhhhh noooo".into())
+        }
+
+        #[update]
+        async fn do_update(
+            _ctx: &mut WorkflowContext<Self>,
+            _: (),
+        ) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
+            Ok("hi".to_string())
+        }
+    }
 
-    let handle = starter.start_with_worker(wf_name, &mut worker).await;
-    let wf_id = starter.get_task_queue().to_string();
+    worker.register_workflow::<UpdateRejectionSdkWf>();
+    let task_queue = starter.get_task_queue().to_owned();
+    let handle = worker
+        .submit_workflow(
+            UpdateRejectionSdkWf::run,
+            (),
+            WorkflowStartOptions::new(task_queue, starter.get_wf_id().to_owned()).build(),
+        )
+        .await
+        .unwrap();
     let update = async {
-        let res = client
-            .update_workflow_execution(
-                wf_id.clone(),
-                "".to_string(),
-                "update".to_string(),
-                WaitPolicy {
-                    lifecycle_stage: UpdateWorkflowExecutionLifecycleStage::Completed as i32,
-                },
-                [().as_json_payload().unwrap()].into_payloads(),
+        let res = handle
+            .execute_update(
+                UpdateRejectionSdkWf::do_update,
+                (),
+                WorkflowExecuteUpdateOptions::default(),
             )
-            .await
-            .unwrap();
-        assert!(!res.outcome.unwrap().is_success());
+            .await;
+        assert!(res.is_err());
     };
     let run = async {
         worker.run_until_done().await.unwrap();
@@ -770,37 +809,48 @@ async fn update_rejection_sdk() {
 async fn update_fail_sdk() {
     let wf_name = "update_fail_sdk";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter
-        .worker_config
-        .task_types(WorkerTaskTypes::workflow_only());
+    starter.sdk_config.task_types = WorkerTaskTypes::workflow_only();
     let mut worker = starter.worker().await;
-    let client = starter.get_client().await;
-    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
-        ctx.update_handler(
-            "update",
-            |_: &_, _: ()| Ok(()),
-            move |_: UpdateContext, _: ()| async { Err::<(), _>(anyhow!("nooooo")) },
-        );
-        ctx.timer(Duration::from_secs(1)).await;
-        Ok(().into())
-    });
+    #[workflow]
+    #[derive(Default)]
+    struct UpdateFailSdkWf;
+
+    #[workflow_methods]
+    impl UpdateFailSdkWf {
+        #[run]
+        async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+            ctx.timer(Duration::from_secs(1)).await;
+            Ok(())
+        }
+
+        #[update]
+        async fn do_update(
+            _ctx: &mut WorkflowContext<Self>,
+            _: (),
+        ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+            Err("nooooo".into())
+        }
+    }
 
-    let handle = starter.start_with_worker(wf_name, &mut worker).await;
-    let wf_id = starter.get_task_queue().to_string();
+    worker.register_workflow::<UpdateFailSdkWf>();
+    let task_queue = starter.get_task_queue().to_owned();
+    let handle = worker
+        .submit_workflow(
+            UpdateFailSdkWf::run,
+            (),
+            WorkflowStartOptions::new(task_queue, starter.get_wf_id().to_owned()).build(),
+        )
+        .await
+        .unwrap();
     let update = async {
-        let res = client
-            .update_workflow_execution(
-                wf_id.clone(),
-                "".to_string(),
-                "update".to_string(),
-                WaitPolicy {
-                    lifecycle_stage: UpdateWorkflowExecutionLifecycleStage::Completed as i32,
-                },
-                [().as_json_payload().unwrap()].into_payloads(),
+        let res = handle
+            .execute_update(
+                UpdateFailSdkWf::do_update,
+                (),
+                WorkflowExecuteUpdateOptions::default(),
             )
-            .await
-            .unwrap();
-        assert!(!res.outcome.unwrap().is_success());
+            .await;
+        assert!(res.is_err());
     };
     let run = async {
         worker.run_until_done().await.unwrap();
@@ -816,41 +866,53 @@ async fn update_fail_sdk() {
 async fn update_timer_sequence() {
     let wf_name = "update_timer_sequence";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter
-        .worker_config
-        .task_types(WorkerTaskTypes::workflow_only());
+    starter.sdk_config.task_types = WorkerTaskTypes::workflow_only();
     let mut worker = starter.worker().await;
-    let client = starter.get_client().await;
-    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
-        ctx.update_handler(
-            "update",
-            |_: &_, _: ()| Ok(()),
-            move |ctx: UpdateContext, _: ()| async move {
-                ctx.wf_ctx.timer(Duration::from_millis(1)).await;
-                ctx.wf_ctx.timer(Duration::from_millis(1)).await;
-                Ok("done")
-            },
-        );
-        ctx.timer(Duration::from_secs(2)).await;
-        Ok(().into())
-    });
+    #[workflow]
+    #[derive(Default)]
+    struct UpdateTimerSequenceWf {
+        done: bool,
+    }
+
+    #[workflow_methods]
+    impl UpdateTimerSequenceWf {
+        #[run]
+        async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+            ctx.wait_condition(|s| s.done).await;
+            Ok(())
+        }
 
-    let handle = starter.start_with_worker(wf_name, &mut worker).await;
-    let wf_id = starter.get_task_queue().to_string();
+        #[update]
+        async fn do_update(
+            ctx: &mut WorkflowContext<Self>,
+            _: (),
+        ) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
+            ctx.timer(Duration::from_millis(1)).await;
+            ctx.timer(Duration::from_millis(1)).await;
+            ctx.state_mut(|s| s.done = true);
+            Ok("done".to_string())
+        }
+    }
+
+    worker.register_workflow::<UpdateTimerSequenceWf>();
+    let task_queue = starter.get_task_queue().to_owned();
+    let handle = worker
+        .submit_workflow(
+            UpdateTimerSequenceWf::run,
+            (),
+            WorkflowStartOptions::new(task_queue, starter.get_wf_id().to_owned()).build(),
+        )
+        .await
+        .unwrap();
     let update = async {
-        let res = client
-            .update_workflow_execution(
-                wf_id.clone(),
-                "".to_string(),
-                "update".to_string(),
-                WaitPolicy {
-                    lifecycle_stage: UpdateWorkflowExecutionLifecycleStage::Completed as i32,
-                },
-                [().as_json_payload().unwrap()].into_payloads(),
+        let res = handle
+            .execute_update(
+                UpdateTimerSequenceWf::do_update,
+                (),
+                WorkflowExecuteUpdateOptions::default(),
             )
-            .await
-            .unwrap();
-        assert!(res.outcome.unwrap().is_success());
+            .await;
+        assert!(res.unwrap() == "done");
     };
     let run = async {
         worker.run_until_done().await.unwrap();
@@ -866,44 +928,62 @@ async fn update_timer_sequence() {
 async fn task_failure_during_validation() {
     let wf_name = "task_failure_during_validation";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter
-        .worker_config
-        .task_types(WorkerTaskTypes::workflow_only());
+    starter.sdk_config.task_types = WorkerTaskTypes::workflow_only();
     starter.workflow_options.task_timeout = Some(Duration::from_secs(1));
     let mut worker = starter.worker().await;
-    let client = starter.get_client().await;
-    static FAILCT: AtomicUsize = AtomicUsize::new(0);
-    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
-        ctx.update_handler(
-            "update",
-            |_: &_, _: ()| {
-                if FAILCT.fetch_add(1, Ordering::Relaxed) < 2 {
-                    panic!("ahhhhhh");
-                }
-                Ok(())
-            },
-            move |_: UpdateContext, _: ()| async move { Ok("done") },
-        );
-        ctx.timer(Duration::from_secs(1)).await;
-        Ok(().into())
-    });
+    #[workflow]
+    #[derive(Default)]
+    struct TaskFailureDuringValidationWf;
+
+    #[workflow_methods]
+    impl TaskFailureDuringValidationWf {
+        #[run]
+        async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+            ctx.timer(Duration::from_secs(1)).await;
+            Ok(())
+        }
+
+        #[update_validator(do_update)]
+        fn validate_do_update(
+            &self,
+            _ctx: &WorkflowContextView,
+            _: &(),
+        ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+            static FAILCT: AtomicUsize = AtomicUsize::new(0);
+            if FAILCT.fetch_add(1, Ordering::Relaxed) < 2 {
+                panic!("ahhhhhh");
+            }
+            Ok(())
+        }
+
+        #[update]
+        async fn do_update(
+            _ctx: &mut WorkflowContext<Self>,
+            _: (),
+        ) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
+            Ok("done".to_string())
+        }
+    }
 
-    let handle = starter.start_with_worker(wf_name, &mut worker).await;
-    let wf_id = starter.get_task_queue().to_string();
+    worker.register_workflow::<TaskFailureDuringValidationWf>();
+    let task_queue = starter.get_task_queue().to_owned();
+    let handle = worker
+        .submit_workflow(
+            TaskFailureDuringValidationWf::run,
+            (),
+            WorkflowStartOptions::new(task_queue, starter.get_wf_id().to_owned()).build(),
+        )
+        .await
+        .unwrap();
     let update = async {
-        let res = client
-            .update_workflow_execution(
-                wf_id.clone(),
-                "".to_string(),
-                "update".to_string(),
-                WaitPolicy {
-                    lifecycle_stage: UpdateWorkflowExecutionLifecycleStage::Completed as i32,
-                },
-                [().as_json_payload().unwrap()].into_payloads(),
+        let res = handle
+            .execute_update(
+                TaskFailureDuringValidationWf::do_update,
+                (),
+                WorkflowExecuteUpdateOptions::default(),
             )
-            .await
-            .unwrap();
-        assert!(res.outcome.unwrap().is_success());
+            .await;
+        assert!(res.unwrap() == "done");
     };
     let run = async {
         worker.run_until_done().await.unwrap();
@@ -929,42 +1009,53 @@ async fn task_failure_during_validation() {
 async fn task_failure_after_update() {
     let wf_name = "task_failure_after_update";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter
-        .worker_config
-        .task_types(WorkerTaskTypes::workflow_only());
+    starter.sdk_config.task_types = WorkerTaskTypes::workflow_only();
     starter.workflow_options.task_timeout = Some(Duration::from_secs(1));
     let mut worker = starter.worker().await;
-    let client = starter.get_client().await;
-    static FAILCT: AtomicUsize = AtomicUsize::new(0);
-    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
-        ctx.update_handler(
-            "update",
-            |_: &_, _: ()| Ok(()),
-            move |_: UpdateContext, _: ()| async move { Ok("done") },
-        );
-        ctx.timer(Duration::from_millis(1)).await;
-        if FAILCT.fetch_add(1, Ordering::Relaxed) < 1 {
-            panic!("ahhhhhh");
+    #[workflow]
+    #[derive(Default)]
+    struct TaskFailureAfterUpdateWf;
+
+    #[workflow_methods]
+    impl TaskFailureAfterUpdateWf {
+        #[run]
+        async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+            static FAILCT: AtomicUsize = AtomicUsize::new(0);
+            ctx.timer(Duration::from_millis(1)).await;
+            if FAILCT.fetch_add(1, Ordering::Relaxed) < 1 {
+                panic!("ahhhhhh");
+            }
+            Ok(())
         }
-        Ok(().into())
-    });
 
-    let handle = starter.start_with_worker(wf_name, &mut worker).await;
-    let wf_id = starter.get_task_queue().to_string();
+        #[update]
+        async fn do_update(
+            _ctx: &mut WorkflowContext<Self>,
+            _: (),
+        ) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
+            Ok("done".to_string())
+        }
+    }
+
+    worker.register_workflow::<TaskFailureAfterUpdateWf>();
+    let task_queue = starter.get_task_queue().to_owned();
+    let handle = worker
+        .submit_workflow(
+            TaskFailureAfterUpdateWf::run,
+            (),
+            WorkflowStartOptions::new(task_queue, starter.get_wf_id().to_owned()).build(),
+        )
+        .await
+        .unwrap();
     let update = async {
-        let res = client
-            .update_workflow_execution(
-                wf_id.clone(),
-                "".to_string(),
-                "update".to_string(),
-                WaitPolicy {
-                    lifecycle_stage: UpdateWorkflowExecutionLifecycleStage::Completed as i32,
-                },
-                [().as_json_payload().unwrap()].into_payloads(),
+        let res = handle
+            .execute_update(
+                TaskFailureAfterUpdateWf::do_update,
+                (),
+                WorkflowExecuteUpdateOptions::default(),
             )
-            .await
-            .unwrap();
-        assert!(res.outcome.unwrap().is_success());
+            .await;
+        assert!(res.unwrap() == "done");
     };
     let run = async {
         worker.run_until_done().await.unwrap();
@@ -976,68 +1067,94 @@ async fn task_failure_after_update() {
         .unwrap();
 }
 
+static BARR: LazyLock<Barrier> = LazyLock::new(|| Barrier::new(2));
+static ACT_RAN: AtomicBool = AtomicBool::new(false);
 #[tokio::test]
 async fn worker_restarted_in_middle_of_update() {
     let wf_name = "worker_restarted_in_middle_of_update";
     let mut starter = CoreWfStarter::new(wf_name);
+
+    struct BlockingActivities;
+    #[activities]
+    impl BlockingActivities {
+        #[activity]
+        async fn blocks(_ctx: ActivityContext, echo_me: String) -> Result<String, ActivityError> {
+            BARR.wait().await;
+            if !ACT_RAN.fetch_or(true, Ordering::Relaxed) {
+                // On first run fail the task so we'll get retried on the new worker
+                return Err(anyhow!("Fail first time").into());
+            }
+            Ok(echo_me)
+        }
+    }
+
+    starter.sdk_config.register_activities(BlockingActivities);
     let mut worker = starter.worker().await;
     let client = starter.get_client().await;
 
-    static BARR: LazyLock<Barrier> = LazyLock::new(|| Barrier::new(2));
-    static ACT_RAN: AtomicBool = AtomicBool::new(false);
-    worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
-        ctx.update_handler(
-            "update",
-            |_: &_, _: ()| Ok(()),
-            move |ctx: UpdateContext, _: ()| async move {
-                ctx.wf_ctx
-                    .activity(ActivityOptions {
-                        activity_type: "blocks".to_string(),
-                        input: "hi!".as_json_payload().expect("serializes fine"),
-                        start_to_close_timeout: Some(Duration::from_secs(2)),
-                        ..Default::default()
-                    })
-                    .await;
-                Ok(())
-            },
-        );
-        let mut sig = ctx.make_signal_channel("done");
-        sig.next().await;
-        Ok(().into())
-    });
-    worker.register_activity("blocks", |_ctx: ActContext, echo_me: String| async move {
-        BARR.wait().await;
-        if !ACT_RAN.fetch_or(true, Ordering::Relaxed) {
-            // On first run fail the task so we'll get retried on the new worker
-            return Err(anyhow!("Fail first time").into());
+    #[workflow]
+    #[derive(Default)]
+    struct WorkerRestartedInMiddleOfUpdateWf {
+        done: bool,
+    }
+
+    #[workflow_methods]
+    impl WorkerRestartedInMiddleOfUpdateWf {
+        #[run]
+        async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+            ctx.wait_condition(|s| s.done).await;
+            Ok(())
         }
-        Ok(echo_me)
-    });
 
-    let handle = starter.start_with_worker(wf_name, &mut worker).await;
+        #[signal]
+        fn done_signal(&mut self, _ctx: &mut SyncWorkflowContext<Self>, _: ()) {
+            self.done = true;
+        }
 
-    let wf_id = starter.get_task_queue().to_string();
-    let update = async {
-        let res = client
-            .update_workflow_execution(
-                wf_id.clone(),
-                "".to_string(),
-                "update".to_string(),
-                WaitPolicy {
-                    lifecycle_stage: UpdateWorkflowExecutionLifecycleStage::Completed as i32,
+        #[update]
+        async fn do_update(
+            ctx: &mut WorkflowContext<Self>,
+            _: (),
+        ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+            ctx.start_activity(
+                BlockingActivities::blocks,
+                "hi!".to_string(),
+                ActivityOptions {
+                    start_to_close_timeout: Some(Duration::from_secs(2)),
+                    ..Default::default()
                 },
-                [().as_json_payload().unwrap()].into_payloads(),
             )
-            .await
-            .unwrap();
-        assert!(res.outcome.unwrap().is_success());
-        client
-            .signal_workflow_execution(
-                wf_id.clone(),
-                "".to_string(),
-                "done".to_string(),
-                None,
-                None,
+            .await?;
+            Ok(())
+        }
+    }
+
+    worker.register_workflow::<WorkerRestartedInMiddleOfUpdateWf>();
+    let task_queue = starter.get_task_queue().to_owned();
+    let handle = worker
+        .submit_workflow(
+            WorkerRestartedInMiddleOfUpdateWf::run,
+            (),
+            WorkflowStartOptions::new(task_queue.clone(), starter.get_wf_id().to_owned()).build(),
+        )
+        .await
+        .unwrap();
+
+    let wf_id = task_queue;
+    let update = async {
+        let res = handle
+            .execute_update(
+                WorkerRestartedInMiddleOfUpdateWf::do_update,
+                (),
+                WorkflowExecuteUpdateOptions::default(),
+            )
+            .await;
+        assert!(res.is_ok());
+        handle
+            .signal(
+                WorkerRestartedInMiddleOfUpdateWf::done_signal,
+                (),
+                WorkflowSignalOptions::default(),
             )
             .await
             .unwrap();
@@ -1051,10 +1168,19 @@ async fn worker_restarted_in_middle_of_update() {
         // Allow it to start again, the second time
         BARR.wait().await;
         // Poke the workflow off the sticky queue to get it to complete faster than WFT timeout
-        client
-            .reset_sticky_task_queue(wf_id.clone(), "".to_string())
-            .await
-            .unwrap();
+        WorkflowService::reset_sticky_task_queue(
+            &mut client.clone(),
+            ResetStickyTaskQueueRequest {
+                namespace: client.namespace(),
+                execution: Some(WorkflowExecution {
+                    workflow_id: wf_id.clone(),
+                    run_id: "".to_string(),
+                }),
+            }
+            .into_request(),
+        )
+        .await
+        .unwrap();
     };
     let run = async {
         // This run attempt will get shut down
@@ -1076,79 +1202,94 @@ async fn worker_restarted_in_middle_of_update() {
 async fn update_after_empty_wft() {
     let wf_name = "update_after_empty_wft";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.sdk_config.register_activities(StdActivities);
     let mut worker = starter.worker().await;
-    let client = starter.get_client().await;
 
     static ACT_STARTED: AtomicBool = AtomicBool::new(false);
-    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| async move {
-        ctx.update_handler(
-            "update",
-            |_: &_, _: ()| Ok(()),
-            move |ctx: UpdateContext, _: ()| async move {
-                if ACT_STARTED.load(Ordering::Acquire) {
-                    return Ok(());
-                }
-                ctx.wf_ctx
-                    .activity(ActivityOptions {
-                        activity_type: "echo".to_string(),
-                        input: "hi!".as_json_payload().expect("serializes fine"),
+
+    #[workflow]
+    #[derive(Default)]
+    struct UpdateAfterEmptyWftWf {
+        signal_received: bool,
+    }
+
+    #[workflow_methods]
+    impl UpdateAfterEmptyWftWf {
+        #[run]
+        async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+            let sig_handle = async {
+                ctx.wait_condition(|s| s.signal_received).await;
+                ACT_STARTED.store(true, Ordering::Release);
+                let _ = ctx
+                    .start_activity(
+                        StdActivities::echo,
+                        "hi!".to_string(),
+                        ActivityOptions {
+                            start_to_close_timeout: Some(Duration::from_secs(2)),
+                            ..Default::default()
+                        },
+                    )
+                    .await;
+                ACT_STARTED.store(false, Ordering::Release);
+            };
+            join!(sig_handle, async {
+                ctx.timer(Duration::from_secs(2)).await;
+            });
+            Ok(())
+        }
+
+        #[signal]
+        fn signal_handler(&mut self, _ctx: &mut SyncWorkflowContext<Self>, _: ()) {
+            self.signal_received = true;
+        }
+
+        #[update]
+        async fn do_update(ctx: &mut WorkflowContext<Self>, _: ()) {
+            if ACT_STARTED.load(Ordering::Acquire) {
+                return;
+            }
+            let _ = ctx
+                .start_activity(
+                    StdActivities::echo,
+                    "hi!".to_string(),
+                    ActivityOptions {
                         start_to_close_timeout: Some(Duration::from_secs(2)),
                         ..Default::default()
-                    })
-                    .await;
-                Ok(())
-            },
-        );
-        let mut sig = ctx.make_signal_channel("signal");
-        let sig_handle = async {
-            sig.next().await;
-            ACT_STARTED.store(true, Ordering::Release);
-            ctx.activity(ActivityOptions {
-                activity_type: "echo".to_string(),
-                input: "hi!".as_json_payload().expect("serializes fine"),
-                start_to_close_timeout: Some(Duration::from_secs(2)),
-                ..Default::default()
-            })
-            .await;
-            ACT_STARTED.store(false, Ordering::Release);
-        };
-        join!(sig_handle, async {
-            ctx.timer(Duration::from_secs(2)).await;
-        });
-        Ok(().into())
-    });
-    worker.register_activity("echo", |_ctx: ActContext, echo_me: String| async move {
-        Ok(echo_me)
-    });
+                    },
+                )
+                .await;
+        }
+    }
 
-    let handle = starter.start_with_worker(wf_name, &mut worker).await;
+    worker.register_workflow::<UpdateAfterEmptyWftWf>();
+    let task_queue = starter.get_task_queue().to_owned();
+    let handle = worker
+        .submit_workflow(
+            UpdateAfterEmptyWftWf::run,
+            (),
+            WorkflowStartOptions::new(task_queue, starter.get_wf_id().to_owned()).build(),
+        )
+        .await
+        .unwrap();
 
-    let wf_id = starter.get_task_queue().to_string();
     let update = async {
-        client
-            .signal_workflow_execution(
-                wf_id.clone(),
-                "".to_string(),
-                "signal".to_string(),
-                None,
-                None,
+        handle
+            .signal(
+                UpdateAfterEmptyWftWf::signal_handler,
+                (),
+                WorkflowSignalOptions::default(),
             )
             .await
             .unwrap();
         tokio::time::sleep(Duration::from_millis(500)).await;
-        let res = client
-            .update_workflow_execution(
-                wf_id.clone(),
-                "".to_string(),
-                "update".to_string(),
-                WaitPolicy {
-                    lifecycle_stage: UpdateWorkflowExecutionLifecycleStage::Completed as i32,
-                },
-                [().as_json_payload().unwrap()].into_payloads(),
+        handle
+            .execute_update(
+                UpdateAfterEmptyWftWf::do_update,
+                (),
+                WorkflowExecuteUpdateOptions::default(),
             )
             .await
             .unwrap();
-        assert!(res.outcome.unwrap().is_success());
     };
     let runner = async {
         worker.run_until_done().await.unwrap();
@@ -1164,64 +1305,69 @@ async fn update_after_empty_wft() {
 async fn update_lost_on_activity_mismatch() {
     let wf_name = "update_lost_on_activity_mismatch";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.sdk_config.register_activities(StdActivities);
     let mut worker = starter.worker().await;
-    let client = starter.get_client().await;
 
-    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| async move {
-        let can_run = Arc::new(AtomicUsize::new(1));
-        let cr = can_run.clone();
-        ctx.update_handler(
-            "update",
-            |_: &_, _: ()| Ok(()),
-            move |_: UpdateContext, _: ()| {
-                let cr = cr.clone();
-                async move {
-                    cr.fetch_add(1, Ordering::Relaxed);
-                    Ok(())
-                }
-            },
-        );
-        for _ in 1..=3 {
-            let cr = can_run.clone();
-            ctx.wait_condition(|| cr.load(Ordering::Relaxed) > 0).await;
-            ctx.activity(ActivityOptions {
-                activity_type: "echo".to_string(),
-                input: "hi!".as_json_payload().expect("serializes fine"),
-                start_to_close_timeout: Some(Duration::from_secs(2)),
-                ..Default::default()
-            })
-            .await;
-            can_run.fetch_sub(1, Ordering::Release);
+    #[workflow]
+    #[derive(Default)]
+    struct UpdateLostOnActivityMismatchWf {
+        can_run: usize,
+    }
+
+    #[workflow_methods]
+    impl UpdateLostOnActivityMismatchWf {
+        #[run]
+        async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+            ctx.state_mut(|s| s.can_run = 1);
+            for _ in 1..=3 {
+                ctx.wait_condition(|s| s.can_run > 0).await;
+                let _ = ctx
+                    .start_activity(
+                        StdActivities::echo,
+                        "hi!".to_string(),
+                        ActivityOptions {
+                            start_to_close_timeout: Some(Duration::from_secs(2)),
+                            ..Default::default()
+                        },
+                    )
+                    .await;
+                ctx.state_mut(|s| s.can_run -= 1);
+            }
+            Ok(())
         }
-        Ok(().into())
-    });
-    worker.register_activity("echo", |_ctx: ActContext, echo_me: String| async move {
-        Ok(echo_me)
-    });
 
-    let core_worker = worker.core_worker.clone();
-    let handle = starter.start_with_worker(wf_name, &mut worker).await;
+        #[update]
+        fn do_update(&mut self, _ctx: &mut SyncWorkflowContext<Self>, _: ()) {
+            self.can_run += 1;
+        }
+    }
+
+    worker.register_workflow::<UpdateLostOnActivityMismatchWf>();
+    let core_worker = worker.core_worker();
+    let task_queue = starter.get_task_queue().to_owned();
+    let handle = worker
+        .submit_workflow(
+            UpdateLostOnActivityMismatchWf::run,
+            (),
+            WorkflowStartOptions::new(task_queue, starter.get_wf_id().to_owned()).build(),
+        )
+        .await
+        .unwrap();
 
-    let wf_id = starter.get_task_queue().to_string();
     let update = async {
         // Need time to get to condition
         tokio::time::sleep(Duration::from_millis(200)).await;
         // Evict wf
-        core_worker.request_workflow_eviction(handle.info().run_id.as_ref().unwrap());
+        core_worker.request_workflow_eviction(handle.run_id().unwrap());
         for _ in 1..=2 {
-            let res = client
-                .update_workflow_execution(
-                    wf_id.clone(),
-                    "".to_string(),
-                    "update".to_string(),
-                    WaitPolicy {
-                        lifecycle_stage: UpdateWorkflowExecutionLifecycleStage::Completed as i32,
-                    },
-                    [().as_json_payload().unwrap()].into_payloads(),
+            handle
+                .execute_update(
+                    UpdateLostOnActivityMismatchWf::do_update,
+                    (),
+                    WorkflowExecuteUpdateOptions::default(),
                 )
                 .await
                 .unwrap();
-            assert!(res.outcome.unwrap().is_success());
         }
     };
     let runner = async {