@temporalio/core-bridge 1.13.2 → 1.14.0

package/sdk-core/{tests → crates/sdk-core/tests}/integ_tests/metrics_tests.rs

@@ -1,7 +1,7 @@
 use crate::{
     common::{
         ANY_PORT, CoreWfStarter, NAMESPACE, OTEL_URL_ENV_VAR, PROMETHEUS_QUERY_API,
-        get_integ_server_options, get_integ_telem_options, prom_metrics,
+        get_integ_runtime_options, get_integ_server_options, get_integ_telem_options, prom_metrics,
     },
     integ_tests::mk_nexus_endpoint,
 };
@@ -14,20 +14,39 @@ use std::{
     sync::{Arc, OnceLock},
     time::Duration,
 };
-use temporal_client::{
+use temporalio_client::{
     REQUEST_LATENCY_HISTOGRAM_NAME, WorkflowClientTrait, WorkflowOptions, WorkflowService,
 };
-use temporal_sdk::{
-    ActContext, ActivityError, ActivityOptions, CancellableFuture, LocalActivityOptions,
-    NexusOperationOptions, WfContext,
-};
-use temporal_sdk_core::{
-    CoreRuntime, FixedSizeSlotSupplier, TokioRuntimeBuilder, TunerBuilder, init_worker,
-    telemetry::{WORKFLOW_TASK_EXECUTION_LATENCY_HISTOGRAM_NAME, build_otlp_metric_exporter},
-};
-use temporal_sdk_core_api::{
+use temporalio_common::{
     Worker,
     errors::PollError,
+    prost_dur,
+    protos::{
+        coresdk::{
+            ActivityTaskCompletion, AsJsonPayloadExt,
+            activity_result::ActivityExecutionResult,
+            nexus::{NexusTaskCompletion, nexus_task, nexus_task_completion},
+            workflow_activation::{WorkflowActivationJob, workflow_activation_job},
+            workflow_commands::{
+                CancelWorkflowExecution, CompleteWorkflowExecution, ContinueAsNewWorkflowExecution,
+                FailWorkflowExecution, QueryResult, QuerySuccess, ScheduleActivity,
+                ScheduleLocalActivity, workflow_command,
+            },
+            workflow_completion::WorkflowActivationCompletion,
+        },
+        temporal::api::{
+            common::v1::RetryPolicy,
+            enums::v1::{NexusHandlerErrorRetryBehavior, WorkflowIdReusePolicy},
+            failure::v1::Failure,
+            nexus,
+            nexus::v1::{
+                HandlerError, StartOperationResponse, UnsuccessfulOperationError, request::Variant,
+                start_operation_response,
+            },
+            query::v1::WorkflowQuery,
+            workflowservice::v1::{DescribeNamespaceRequest, ListNamespacesRequest},
+        },
+    },
     telemetry::{
         HistogramBucketOverrides, OtelCollectorOptionsBuilder, OtlpProtocol,
         PrometheusExporterOptionsBuilder, TaskQueueLabelStrategy, TelemetryOptionsBuilder,
@@ -38,36 +57,17 @@ use temporal_sdk_core_api::{
     },
     worker::{
         PollerBehavior, SlotKind, SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext,
-        SlotSupplier, SlotSupplierPermit, WorkerConfigBuilder, WorkerVersioningStrategy,
-        WorkflowSlotKind,
+        SlotSupplier, SlotSupplierPermit, WorkerConfigBuilder, WorkerTaskTypes,
+        WorkerVersioningStrategy, WorkflowSlotKind,
     },
 };
-use temporal_sdk_core_protos::{
-    coresdk::{
-        ActivityTaskCompletion, AsJsonPayloadExt,
-        activity_result::ActivityExecutionResult,
-        nexus::{NexusTaskCompletion, nexus_task, nexus_task_completion},
-        workflow_activation::{WorkflowActivationJob, workflow_activation_job},
-        workflow_commands::{
-            CancelWorkflowExecution, CompleteWorkflowExecution, ContinueAsNewWorkflowExecution,
-            FailWorkflowExecution, QueryResult, QuerySuccess, ScheduleActivity,
-            ScheduleLocalActivity, workflow_command,
-        },
-        workflow_completion::WorkflowActivationCompletion,
-    },
-    prost_dur,
-    temporal::api::{
-        common::v1::RetryPolicy,
-        enums::v1::{NexusHandlerErrorRetryBehavior, WorkflowIdReusePolicy},
-        failure::v1::Failure,
-        nexus,
-        nexus::v1::{
-            HandlerError, StartOperationResponse, UnsuccessfulOperationError, request::Variant,
-            start_operation_response,
-        },
-        query::v1::WorkflowQuery,
-        workflowservice::v1::{DescribeNamespaceRequest, ListNamespacesRequest},
-    },
+use temporalio_sdk::{
+    ActContext, ActivityError, ActivityOptions, CancellableFuture, LocalActivityOptions,
+    NexusOperationOptions, WfContext,
+};
+use temporalio_sdk_core::{
+    CoreRuntime, FixedSizeSlotSupplier, TokioRuntimeBuilder, TunerBuilder, init_worker,
+    telemetry::{WORKFLOW_TASK_EXECUTION_LATENCY_HISTOGRAM_NAME, build_otlp_metric_exporter},
 };
 use tokio::{join, sync::Barrier};
 use tonic::IntoRequest;
@@ -98,7 +98,7 @@ async fn prometheus_metrics_exported(
         });
     }
     let (telemopts, addr, _aborter) = prom_metrics(Some(opts_builder.build().unwrap()));
-    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let opts = get_integ_server_options();
     let mut raw_client = opts
         .connect_no_namespace(rt.telemetry().get_temporal_metric_meter())
@@ -149,7 +149,7 @@ async fn prometheus_metrics_exported(
 async fn one_slot_worker_reports_available_slot() {
     let (telemopts, addr, _aborter) = prom_metrics(None);
     let tq = "one_slot_worker_tq";
-    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
 
     let worker_cfg = WorkerConfigBuilder::default()
         .namespace(NAMESPACE)
@@ -164,6 +164,7 @@ async fn one_slot_worker_reports_available_slot() {
         .max_outstanding_workflow_tasks(2_usize)
         .max_outstanding_nexus_tasks(1_usize)
         .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(2_usize))
+        .task_types(WorkerTaskTypes::all())
         .build()
         .unwrap();
 
@@ -402,7 +403,7 @@ async fn query_of_closed_workflow_doesnt_tick_terminal_metric(
     completion: workflow_command::Variant,
 ) {
     let (telemopts, addr, _aborter) = prom_metrics(None);
-    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let mut starter =
         CoreWfStarter::new_with_runtime("query_of_closed_workflow_doesnt_tick_terminal_metric", rt);
     // Disable cache to ensure replay happens completely
@@ -524,8 +525,11 @@ async fn query_of_closed_workflow_doesnt_tick_terminal_metric(
 
 #[test]
 fn runtime_new() {
-    let mut rt =
-        CoreRuntime::new(get_integ_telem_options(), TokioRuntimeBuilder::default()).unwrap();
+    let mut rt = CoreRuntime::new(
+        get_integ_runtime_options(get_integ_telem_options()),
+        TokioRuntimeBuilder::default(),
+    )
+    .unwrap();
     let handle = rt.tokio_handle();
     let _rt = handle.enter();
     let (telemopts, addr, _aborter) = prom_metrics(None);
@@ -571,7 +575,7 @@ async fn latency_metrics(
             .build()
             .unwrap(),
     ));
-    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let mut starter = CoreWfStarter::new_with_runtime("latency_metrics", rt);
     let worker = starter.get_worker().await;
     starter.start_wf().await;
@@ -625,7 +629,7 @@ async fn latency_metrics(
 #[tokio::test]
 async fn request_fail_codes() {
     let (telemopts, addr, _aborter) = prom_metrics(None);
-    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let opts = get_integ_server_options();
     let mut client = opts
         .connect(NAMESPACE, rt.telemetry().get_temporal_metric_meter())
@@ -671,8 +675,8 @@ async fn request_fail_codes_otel() {
     let mut telemopts = TelemetryOptionsBuilder::default();
     let exporter = Arc::new(exporter);
     telemopts.metrics(exporter as Arc<dyn CoreMeter>);
-
-    let rt = CoreRuntime::new_assume_tokio(telemopts.build().unwrap()).unwrap();
+    let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts.build().unwrap()))
+        .unwrap();
     let opts = get_integ_server_options();
     let mut client = opts
         .connect(NAMESPACE, rt.telemetry().get_temporal_metric_meter())
@@ -725,7 +729,7 @@ async fn docker_metrics_with_prometheus(
         .metric_prefix(test_uid.clone())
         .build()
         .unwrap();
-    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let test_name = "docker_metrics_with_prometheus";
     let mut starter = CoreWfStarter::new_with_runtime(test_name, rt);
     let worker = starter.get_worker().await;
@@ -779,7 +783,7 @@ async fn docker_metrics_with_prometheus(
 #[tokio::test]
 async fn activity_metrics() {
     let (telemopts, addr, _aborter) = prom_metrics(None);
-    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let wf_name = "activity_metrics";
     let mut starter = CoreWfStarter::new_with_runtime(wf_name, rt);
     starter
@@ -913,10 +917,15 @@ async fn activity_metrics() {
 #[tokio::test]
 async fn nexus_metrics() {
     let (telemopts, addr, _aborter) = prom_metrics(None);
-    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let wf_name = "nexus_metrics";
     let mut starter = CoreWfStarter::new_with_runtime(wf_name, rt);
-    starter.worker_config.no_remote_activities(true);
+    starter.worker_config.task_types(WorkerTaskTypes {
+        enable_workflows: true,
+        enable_local_activities: false,
+        enable_remote_activities: false,
+        enable_nexus: true,
+    });
     let task_queue = starter.get_task_queue().to_owned();
     let mut worker = starter.worker().await;
     let core_worker = starter.get_worker().await;
@@ -1090,10 +1099,12 @@ async fn nexus_metrics() {
 #[tokio::test]
 async fn evict_on_complete_does_not_count_as_forced_eviction() {
     let (telemopts, addr, _aborter) = prom_metrics(None);
-    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let wf_name = "evict_on_complete_does_not_count_as_forced_eviction";
     let mut starter = CoreWfStarter::new_with_runtime(wf_name, rt);
-    starter.worker_config.no_remote_activities(true);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
     let mut worker = starter.worker().await;
 
     worker.register_wf(
@@ -1173,10 +1184,12 @@ where
 #[tokio::test]
 async fn metrics_available_from_custom_slot_supplier() {
     let (telemopts, addr, _aborter) = prom_metrics(None);
-    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let mut starter =
         CoreWfStarter::new_with_runtime("metrics_available_from_custom_slot_supplier", rt);
-    starter.worker_config.no_remote_activities(true);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
     starter.worker_config.clear_max_outstanding_opts();
     let mut tb = TunerBuilder::default();
     tb.workflow_slot_supplier(Arc::new(MetricRecordingSlotSupplier::<WorkflowSlotKind> {
@@ -1340,12 +1353,14 @@ async fn sticky_queue_label_strategy(
             .unwrap(),
     ));
     telemopts.task_queue_label_strategy = strategy;
-    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
     let wf_name = format!("sticky_queue_label_strategy_{strategy:?}");
     let mut starter = CoreWfStarter::new_with_runtime(&wf_name, rt);
     // Enable sticky queues by setting a reasonable cache size
     starter.worker_config.max_cached_workflows(10_usize);
-    starter.worker_config.no_remote_activities(true);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
     let task_queue = starter.get_task_queue().to_owned();
     let mut worker = starter.worker().await;
 
@@ -1404,8 +1419,7 @@ async fn sticky_queue_label_strategy(
                 if l.contains("task_queue=") && l.contains("WorkflowTask") {
                     assert!(
                         l.contains(&format!("task_queue=\"{task_queue}\"")),
-                        "With UseNormal, all workflow task_queue labels should use normal name. Found: {}",
-                        l
+                        "With UseNormal, all workflow task_queue labels should use normal name. Found: {l}",
                     );
                 }
             }
@@ -1413,3 +1427,63 @@ async fn sticky_queue_label_strategy(
         _ => unreachable!("Test only covers UseNormal and UseNormalAndSticky"),
     }
 }
+
+#[tokio::test]
+async fn resource_based_tuner_metrics() {
+    use temporalio_sdk_core::ResourceBasedTuner;
+
+    let (telemopts, addr, _aborter) = prom_metrics(None);
+    let rt = CoreRuntime::new_assume_tokio(get_integ_runtime_options(telemopts)).unwrap();
+    let wf_name = "resource_based_tuner_metrics";
+    let mut starter = CoreWfStarter::new_with_runtime(wf_name, rt);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
+    starter.worker_config.clear_max_outstanding_opts();
+
+    // Create a resource-based tuner with reasonable thresholds
+    let tuner = ResourceBasedTuner::new(0.8, 0.8);
+    starter.worker_config.tuner(Arc::new(tuner));
+
+    let mut worker = starter.worker().await;
+
+    worker.register_wf(wf_name.to_string(), |ctx: WfContext| async move {
+        ctx.timer(Duration::from_millis(100)).await;
+        Ok(().into())
+    });
+
+    worker
+        .submit_wf(
+            wf_name.to_owned(),
+            wf_name.to_owned(),
+            vec![],
+            WorkflowOptions::default(),
+        )
+        .await
+        .unwrap();
+
+    worker.run_until_done().await.unwrap();
+
+    // Give metrics time to be recorded (metrics are emitted every 1 second)
+    tokio::time::sleep(Duration::from_millis(1500)).await;
+
+    let body = get_text(format!("http://{addr}/metrics")).await;
+
+    // Verify that the resource-based tuner metrics are present
+    assert!(
+        body.contains("temporal_resource_slots_mem_usage"),
+        "Memory usage metric should be present"
+    );
+    assert!(
+        body.contains("temporal_resource_slots_cpu_usage"),
+        "CPU usage metric should be present"
+    );
+    assert!(
+        body.contains("temporal_resource_slots_mem_pid_output"),
+        "Memory PID output metric should be present"
+    );
+    assert!(
+        body.contains("temporal_resource_slots_cpu_pid_output"),
+        "CPU PID output metric should be present"
+    );
+}

package/sdk-core/{tests → crates/sdk-core/tests}/integ_tests/pagination_tests.rs

@@ -4,10 +4,8 @@ use std::sync::{
     Arc,
     atomic::{AtomicUsize, Ordering},
 };
-use temporal_client::WorkflowOptions;
-use temporal_sdk::WfContext;
-use temporal_sdk_core::test_help::{MockPollCfg, ResponseType, mock_worker_client};
-use temporal_sdk_core_protos::{
+use temporalio_client::WorkflowOptions;
+use temporalio_common::protos::{
     DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder,
     temporal::api::{
         common::v1::WorkflowExecution,
@@ -16,6 +14,8 @@ use temporal_sdk_core_protos::{
         workflowservice::v1::GetWorkflowExecutionHistoryResponse,
     },
 };
+use temporalio_sdk::WfContext;
+use temporalio_sdk_core::test_help::{MockPollCfg, ResponseType, mock_worker_client};
 
 #[tokio::test]
 async fn weird_pagination_doesnt_drop_wft_events() {

package/sdk-core/{tests → crates/sdk-core/tests}/integ_tests/polling_tests.rs

@@ -15,32 +15,31 @@ use std::{
     },
     time::Duration,
 };
-use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions};
-use temporal_sdk::{ActivityOptions, WfContext};
-use temporal_sdk_core::{
-    ClientOptionsBuilder, CoreRuntime,
+use temporalio_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions};
+use temporalio_common::{
+    Worker, prost_dur,
+    protos::{
+        coresdk::{
+            AsJsonPayloadExt, IntoCompletion,
+            activity_task::activity_task as act_task,
+            workflow_activation::{FireTimer, WorkflowActivationJob, workflow_activation_job},
+            workflow_commands::{ActivityCancellationType, RequestCancelActivity, StartTimer},
+            workflow_completion::WorkflowActivationCompletion,
+        },
+        temporal::api::enums::v1::EventType,
+        test_utils::schedule_activity_cmd,
+    },
+    telemetry::{Logger, TelemetryOptionsBuilder},
+    worker::PollerBehavior,
+};
+use temporalio_sdk::{ActivityOptions, WfContext};
+use temporalio_sdk_core::{
+    ClientOptions, CoreRuntime, RuntimeOptionsBuilder,
     ephemeral_server::{TemporalDevServerConfigBuilder, default_cached_download},
     init_worker,
     telemetry::CoreLogStreamConsumer,
     test_help::{NAMESPACE, WorkerTestHelpers, drain_pollers_and_shutdown},
 };
-use temporal_sdk_core_api::{
-    Worker,
-    telemetry::{Logger, TelemetryOptionsBuilder},
-    worker::PollerBehavior,
-};
-use temporal_sdk_core_protos::{
-    coresdk::{
-        AsJsonPayloadExt, IntoCompletion,
-        activity_task::activity_task as act_task,
-        workflow_activation::{FireTimer, WorkflowActivationJob, workflow_activation_job},
-        workflow_commands::{ActivityCancellationType, RequestCancelActivity, StartTimer},
-        workflow_completion::WorkflowActivationCompletion,
-    },
-    prost_dur,
-    temporal::api::enums::v1::EventType,
-    test_utils::schedule_activity_cmd,
-};
 use tokio::{sync::Notify, time::timeout};
 use tracing::info;
 use url::Url;
@@ -147,24 +146,21 @@ async fn switching_worker_client_changes_poll() {
     let result = std::panic::AssertUnwindSafe(async {
         // Connect clients to both servers
         info!("Connecting clients");
-        let mut client_common_config = ClientOptionsBuilder::default();
-        client_common_config
+        let client1 = ClientOptions::builder()
             .identity("integ_tester".to_owned())
             .client_name("temporal-core".to_owned())
-            .client_version("0.1.0".to_owned());
-        let client1 = client_common_config
-            .clone()
+            .client_version("0.1.0".to_owned())
             .target_url(Url::parse(&format!("http://{}", server1.target)).unwrap())
             .build()
-            .unwrap()
             .connect("default", None)
             .await
             .unwrap();
-        let client2 = client_common_config
-            .clone()
+        let client2 = ClientOptions::builder()
+            .identity("integ_tester".to_owned())
+            .client_name("temporal-core".to_owned())
+            .client_version("0.1.0".to_owned())
             .target_url(Url::parse(&format!("http://{}", server2.target)).unwrap())
             .build()
-            .unwrap()
             .connect("default", None)
             .await
             .unwrap();
@@ -221,7 +217,9 @@ async fn switching_worker_client_changes_poll() {
 
         // Swap client, poll for next task, confirm it's second wf, and respond w/ empty
         info!("Replacing client and polling again");
-        worker.replace_client(client2.get_client().inner().clone());
+        worker
+            .replace_client(client2.get_client().inner().clone())
+            .unwrap();
         let act2 = worker.poll_workflow_activation().await.unwrap();
         assert_eq!(wf2.run_id, act2.run_id);
         worker.complete_execution(&act2.run_id).await;
@@ -334,12 +332,16 @@ async fn replace_client_works_after_polling_failure() {
     let (log_consumer, mut log_rx) = CoreLogStreamConsumer::new(100);
     let telem_opts = TelemetryOptionsBuilder::default()
         .logging(Logger::Push {
-            filter: "OFF,temporal_client=DEBUG".into(),
+            filter: "OFF,temporalio_client=DEBUG".into(),
             consumer: Arc::new(log_consumer),
         })
         .build()
         .unwrap();
-    let rt = Arc::new(CoreRuntime::new_assume_tokio(telem_opts).unwrap());
+    let runtime_opts = RuntimeOptionsBuilder::default()
+        .telemetry_options(telem_opts)
+        .build()
+        .unwrap();
+    let rt = Arc::new(CoreRuntime::new_assume_tokio(runtime_opts).unwrap());
 
     // Spawning background task to read logs and notify the test when polling failure occurs.
     let look_for_poll_failure_log = Arc::new(AtomicBool::new(false));
@@ -390,13 +392,12 @@ async fn replace_client_works_after_polling_failure() {
                 "http://{}",
                 initial_server.lock().unwrap().as_ref().unwrap().target
             );
-            let client_for_initial_server = ClientOptionsBuilder::default()
+            let client_for_initial_server = ClientOptions::builder()
                 .identity("client_for_initial_server".to_string())
                 .target_url(Url::parse(&initial_server_target).unwrap())
                 .client_name(INTEG_CLIENT_NAME.to_string())
                 .client_version(INTEG_CLIENT_VERSION.to_string())
                 .build()
-                .unwrap()
                 .connect(NAMESPACE, rt.telemetry().get_temporal_metric_meter())
                 .await
                 .unwrap();
@@ -477,7 +478,7 @@ async fn replace_client_works_after_polling_failure() {
 
             // Switch worker over to the main integration server.
             // The polling started on the initial server should complete with a task from the new server.
-            worker.replace_client(client_for_integ_server);
+            worker.replace_client(client_for_integ_server).unwrap();
             let act_2 = tokio::time::timeout(Duration::from_secs(60), poll_join_handle)
                 .await
                 .unwrap()

package/sdk-core/{tests → crates/sdk-core/tests}/integ_tests/queries_tests.rs

@@ -2,18 +2,20 @@ use crate::common::{CoreWfStarter, init_core_and_create_wf};
 use assert_matches::assert_matches;
 use futures_util::{FutureExt, StreamExt, future::join_all, stream::FuturesUnordered};
 use std::time::{Duration, Instant};
-use temporal_client::WorkflowClientTrait;
-use temporal_sdk_core::test_help::{WorkerTestHelpers, drain_pollers_and_shutdown};
-use temporal_sdk_core_protos::{
-    coresdk::{
-        workflow_activation::{WorkflowActivationJob, workflow_activation_job},
-        workflow_commands::{QueryResult, QuerySuccess, StartTimer},
-        workflow_completion::WorkflowActivationCompletion,
-    },
+use temporalio_client::WorkflowClientTrait;
+use temporalio_common::{
     prost_dur,
-    temporal::api::{failure::v1::Failure, query::v1::WorkflowQuery},
-    test_utils::start_timer_cmd,
+    protos::{
+        coresdk::{
+            workflow_activation::{WorkflowActivationJob, workflow_activation_job},
+            workflow_commands::{QueryResult, QuerySuccess, StartTimer},
+            workflow_completion::WorkflowActivationCompletion,
+        },
+        temporal::api::{failure::v1::Failure, query::v1::WorkflowQuery},
+        test_utils::start_timer_cmd,
+    },
 };
+use temporalio_sdk_core::test_help::{WorkerTestHelpers, drain_pollers_and_shutdown};
 use tokio::join;
 
 #[tokio::test]

package/sdk-core/{tests → crates/sdk-core/tests}/integ_tests/update_tests.rs

@@ -11,35 +11,37 @@ use std::{
     },
     time::Duration,
 };
-use temporal_client::{
+use temporalio_client::{
     Client, NamespacedClient, RetryClient, WorkflowClientTrait, WorkflowService,
 };
-use temporal_sdk::{ActContext, ActivityOptions, LocalActivityOptions, UpdateContext, WfContext};
-use temporal_sdk_core::{
-    replay::HistoryForReplay,
-    test_help::{WorkerTestHelpers, drain_pollers_and_shutdown},
-};
-use temporal_sdk_core_api::Worker;
-use temporal_sdk_core_protos::{
-    coresdk::{
-        ActivityTaskCompletion, AsJsonPayloadExt, IntoPayloadsExt,
-        activity_result::ActivityExecutionResult,
-        workflow_activation::{
-            WorkflowActivationJob, remove_from_cache::EvictionReason, workflow_activation_job,
+use temporalio_common::{
+    Worker, prost_dur,
+    protos::{
+        coresdk::{
+            ActivityTaskCompletion, AsJsonPayloadExt, IntoPayloadsExt,
+            activity_result::ActivityExecutionResult,
+            workflow_activation::{
+                WorkflowActivationJob, remove_from_cache::EvictionReason, workflow_activation_job,
+            },
+            workflow_commands::{
+                CompleteWorkflowExecution, ScheduleLocalActivity, UpdateResponse, update_response,
+            },
+            workflow_completion::WorkflowActivationCompletion,
         },
-        workflow_commands::{
-            CompleteWorkflowExecution, ScheduleLocalActivity, UpdateResponse, update_response,
+        temporal::api::{
+            common::v1::WorkflowExecution,
+            enums::v1::{EventType, ResetReapplyType, UpdateWorkflowExecutionLifecycleStage},
+            update::{self, v1::WaitPolicy},
+            workflowservice::v1::ResetWorkflowExecutionRequest,
         },
-        workflow_completion::WorkflowActivationCompletion,
+        test_utils::start_timer_cmd,
     },
-    prost_dur,
-    temporal::api::{
-        common::v1::WorkflowExecution,
-        enums::v1::{EventType, ResetReapplyType, UpdateWorkflowExecutionLifecycleStage},
-        update::{self, v1::WaitPolicy},
-        workflowservice::v1::ResetWorkflowExecutionRequest,
-    },
-    test_utils::start_timer_cmd,
+    worker::WorkerTaskTypes,
+};
+use temporalio_sdk::{ActContext, ActivityOptions, LocalActivityOptions, UpdateContext, WfContext};
+use temporalio_sdk_core::{
+    replay::HistoryForReplay,
+    test_help::{WorkerTestHelpers, drain_pollers_and_shutdown},
 };
 use tokio::{join, sync::Barrier};
 use tonic::IntoRequest;
@@ -722,7 +724,9 @@ 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.no_remote_activities(true);
+    starter
+        .worker_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 {
@@ -766,7 +770,9 @@ 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.no_remote_activities(true);
+    starter
+        .worker_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 {
@@ -810,7 +816,9 @@ 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.no_remote_activities(true);
+    starter
+        .worker_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 {
@@ -858,7 +866,9 @@ 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.no_remote_activities(true);
+    starter
+        .worker_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;
@@ -919,7 +929,9 @@ 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.no_remote_activities(true);
+    starter
+        .worker_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;