@temporalio/core-bridge 1.13.2 → 1.14.0

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

@@ -1,13 +1,8 @@
 use crate::common::{ActivationAssertionsInterceptor, CoreWfStarter, build_fake_sdk};
 use futures_util::StreamExt;
 use std::collections::HashMap;
-use temporal_client::{SignalWithStartOptions, WorkflowClientTrait, WorkflowOptions};
-use temporal_sdk::{
-    CancellableFuture, ChildWorkflowOptions, Signal, SignalWorkflowOptions, WfContext,
-    WorkflowResult,
-};
-use temporal_sdk_core::test_help::MockPollCfg;
-use temporal_sdk_core_protos::{
+use temporalio_client::{SignalWithStartOptions, WorkflowClientTrait, WorkflowOptions};
+use temporalio_common::protos::{
     DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder,
     coresdk::{
         IntoPayloadsExt,
@@ -21,6 +16,13 @@ use temporal_sdk_core_protos::{
         enums::v1::{CommandType, EventType},
     },
 };
+
+use temporalio_common::worker::WorkerTaskTypes;
+use temporalio_sdk::{
+    CancellableFuture, ChildWorkflowOptions, Signal, SignalWorkflowOptions, WfContext,
+    WorkflowResult,
+};
+use temporalio_sdk_core::test_help::MockPollCfg;
 use uuid::Uuid;
 
 const SIGNAME: &str = "signame";
@@ -46,7 +48,9 @@ async fn signal_sender(ctx: WfContext) -> WorkflowResult<()> {
 async fn sends_signal_to_missing_wf() {
     let wf_name = "sends_signal_to_missing_wf";
     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;
     worker.register_wf(wf_name.to_owned(), signal_sender);
 
@@ -85,7 +89,9 @@ async fn signal_with_create_wf_receiver(ctx: WfContext) -> WorkflowResult<()> {
 #[tokio::test]
 async fn sends_signal_to_other_wf() {
     let mut starter = CoreWfStarter::new("sends_signal_to_other_wf");
-    starter.worker_config.no_remote_activities(true);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
     let mut worker = starter.worker().await;
     worker.register_wf("sender", signal_sender);
     worker.register_wf("receiver", signal_receiver);
@@ -114,7 +120,9 @@ async fn sends_signal_to_other_wf() {
 #[tokio::test]
 async fn sends_signal_with_create_wf() {
     let mut starter = CoreWfStarter::new("sends_signal_with_create_wf");
-    starter.worker_config.no_remote_activities(true);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
     let mut worker = starter.worker().await;
     worker.register_wf("receiver_signal", signal_with_create_wf_receiver);
 
@@ -126,10 +134,9 @@ async fn sends_signal_with_create_wf() {
         .workflow_id("sends_signal_with_create_wf")
         .workflow_type("receiver_signal")
         .signal_name(SIGNAME)
-        .signal_input(vec![b"tada".into()].into_payloads())
-        .signal_header(header.into())
-        .build()
-        .unwrap();
+        .maybe_signal_input(vec![b"tada".into()].into_payloads())
+        .maybe_signal_header(Some(header.into()))
+        .build();
     let res = client
         .signal_with_start_workflow_execution(options, WorkflowOptions::default())
         .await
@@ -160,7 +167,9 @@ async fn signals_child(ctx: WfContext) -> WorkflowResult<()> {
 #[tokio::test]
 async fn sends_signal_to_child() {
     let mut starter = CoreWfStarter::new("sends_signal_to_child");
-    starter.worker_config.no_remote_activities(true);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
     let mut worker = starter.worker().await;
     worker.register_wf("child_signaler", signals_child);
     worker.register_wf("child_receiver", signal_receiver);

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

@@ -3,9 +3,9 @@ use std::{
     sync::atomic::{AtomicBool, AtomicUsize, Ordering},
     time::Duration,
 };
-use temporal_client::WorkflowOptions;
-use temporal_sdk::{WfContext, WorkflowResult};
-use temporal_sdk_core_api::worker::PollerBehavior;
+use temporalio_client::WorkflowOptions;
+use temporalio_common::worker::{PollerBehavior, WorkerTaskTypes};
+use temporalio_sdk::{WfContext, WorkflowResult};
 use tokio::sync::Barrier;
 
 #[tokio::test]
@@ -14,7 +14,7 @@ async fn timer_workflow_not_sticky() {
     let mut starter = CoreWfStarter::new(wf_name);
     starter
         .worker_config
-        .no_remote_activities(true)
+        .task_types(WorkerTaskTypes::workflow_only())
         .max_cached_workflows(0_usize);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), timer_wf);
@@ -42,7 +42,9 @@ async fn timer_workflow_timeout_on_sticky() {
     // on a not-sticky queue
     let wf_name = "timer_workflow_timeout_on_sticky";
     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(2));
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), timer_timeout_wf);
@@ -59,7 +61,7 @@ async fn cache_miss_ok() {
     let mut starter = CoreWfStarter::new(wf_name);
     starter
         .worker_config
-        .no_remote_activities(true)
+        .task_types(WorkerTaskTypes::workflow_only())
         .max_outstanding_workflow_tasks(2_usize)
         .max_cached_workflows(0_usize)
         .workflow_task_poller_behavior(PollerBehavior::SimpleMaximum(1_usize));

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

@@ -1,21 +1,23 @@
-use std::time::Duration;
-
 use crate::common::{CoreWfStarter, build_fake_sdk, init_core_and_create_wf};
-use temporal_sdk::{CancellableFuture, WfContext, WorkflowResult};
-use temporal_sdk_core::test_help::{MockPollCfg, WorkerTestHelpers, drain_pollers_and_shutdown};
-use temporal_sdk_core_protos::{
-    DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder, canned_histories,
-    coresdk::{
-        workflow_commands::{CancelTimer, CompleteWorkflowExecution, StartTimer},
-        workflow_completion::WorkflowActivationCompletion,
-    },
+use std::time::Duration;
+use temporalio_common::{
     prost_dur,
-    temporal::api::{
-        enums::v1::{CommandType, EventType, WorkflowTaskFailedCause},
-        failure::v1::Failure,
+    protos::{
+        DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder, canned_histories,
+        coresdk::{
+            workflow_commands::{CancelTimer, CompleteWorkflowExecution, StartTimer},
+            workflow_completion::WorkflowActivationCompletion,
+        },
+        temporal::api::{
+            enums::v1::{CommandType, EventType, WorkflowTaskFailedCause},
+            failure::v1::Failure,
+        },
+        test_utils::start_timer_cmd,
     },
-    test_utils::start_timer_cmd,
+    worker::WorkerTaskTypes,
 };
+use temporalio_sdk::{CancellableFuture, WfContext, WorkflowResult};
+use temporalio_sdk_core::test_help::{MockPollCfg, WorkerTestHelpers, drain_pollers_and_shutdown};
 
 pub(crate) async fn timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
     command_sink.timer(Duration::from_secs(1)).await;
@@ -26,7 +28,9 @@ pub(crate) async fn timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
 async fn timer_workflow_workflow_driver() {
     let wf_name = "timer_wf_new";
     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;
     worker.register_wf(wf_name.to_owned(), timer_wf);
 
@@ -38,7 +42,9 @@ async fn timer_workflow_workflow_driver() {
 async fn timer_workflow_manual() {
     let mut starter = init_core_and_create_wf("timer_workflow").await;
     let core = starter.get_worker().await;
-    starter.worker_config.no_remote_activities(true);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         task.run_id,
@@ -62,7 +68,9 @@ async fn timer_workflow_manual() {
 async fn timer_cancel_workflow() {
     let mut starter = init_core_and_create_wf("timer_cancel_workflow").await;
     let core = starter.get_worker().await;
-    starter.worker_config.no_remote_activities(true);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         task.run_id,
@@ -121,7 +129,9 @@ async fn parallel_timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
 async fn parallel_timers() {
     let wf_name = "parallel_timers";
     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;
     worker.register_wf(wf_name.to_owned(), parallel_timer_wf);
 

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

@@ -1,21 +1,24 @@
 use crate::common::{CoreWfStarter, SEARCH_ATTR_INT, SEARCH_ATTR_TXT, build_fake_sdk};
 use assert_matches::assert_matches;
 use std::{collections::HashMap, time::Duration};
-use temporal_client::{
-    GetWorkflowResultOpts, WfClientExt, WorkflowClientTrait, WorkflowExecutionResult,
+use temporalio_client::{
+    GetWorkflowResultOptions, WfClientExt, WorkflowClientTrait, WorkflowExecutionResult,
     WorkflowOptions,
 };
-use temporal_sdk::{WfContext, WfExitValue, WorkflowResult};
-use temporal_sdk_core::test_help::MockPollCfg;
-use temporal_sdk_core_protos::{
-    DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder,
-    coresdk::{AsJsonPayloadExt, FromJsonPayloadExt},
-    temporal::api::{
-        command::v1::{Command, command},
-        common::v1::Payload,
-        enums::v1::EventType,
+use temporalio_common::{
+    protos::{
+        DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder,
+        coresdk::{AsJsonPayloadExt, FromJsonPayloadExt},
+        temporal::api::{
+            command::v1::{Command, command},
+            common::v1::Payload,
+            enums::v1::EventType,
+        },
     },
+    worker::WorkerTaskTypes,
 };
+use temporalio_sdk::{WfContext, WfExitValue, WorkflowResult};
+use temporalio_sdk_core::test_help::MockPollCfg;
 use uuid::Uuid;
 
 async fn search_attr_updater(ctx: WfContext) -> WorkflowResult<()> {
@@ -44,7 +47,9 @@ async fn sends_upsert() {
     let wf_name = "sends_upsert_search_attrs";
     let wf_id = Uuid::new_v4();
     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;
 
     worker.register_wf(wf_name, search_attr_updater);
@@ -91,7 +96,7 @@ async fn sends_upsert() {
     assert_eq!(3, usize::from_json_payload(int_attr_payload).unwrap());
     let handle = client.get_untyped_workflow_handle(wf_id.to_string(), "");
     let res = handle
-        .get_workflow_result(GetWorkflowResultOpts::default())
+        .get_workflow_result(GetWorkflowResultOptions::default())
         .await
         .unwrap();
     assert_matches!(res, WorkflowExecutionResult::Succeeded(_));

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

@@ -20,8 +20,8 @@ mod upsert_search_attrs;
 
 use crate::{
     common::{
-        CoreWfStarter, history_from_proto_binary, init_core_and_create_wf,
-        init_core_replay_preloaded, mock_sdk_cfg, prom_metrics,
+        CoreWfStarter, get_integ_runtime_options, history_from_proto_binary,
+        init_core_and_create_wf, init_core_replay_preloaded, mock_sdk_cfg, prom_metrics,
     },
     integ_tests::{activity_functions::echo, metrics_tests},
 };
@@ -30,44 +30,47 @@ use std::{
     collections::{HashMap, HashSet},
     time::Duration,
 };
-use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowExecutionResult, WorkflowOptions};
-use temporal_sdk::{
-    ActivityOptions, LocalActivityOptions, TimerOptions, WfContext, interceptors::WorkerInterceptor,
+use temporalio_client::{
+    WfClientExt, WorkflowClientTrait, WorkflowExecutionResult, WorkflowOptions,
 };
-use temporal_sdk_core::{
-    CoreRuntime,
-    replay::HistoryForReplay,
-    test_help::{MockPollCfg, WorkerTestHelpers, drain_pollers_and_shutdown},
-};
-use temporal_sdk_core_api::{
+use temporalio_common::{
     errors::{PollError, WorkflowErrorType},
-    worker::{
-        PollerBehavior, WorkerDeploymentOptions, WorkerDeploymentVersion, WorkerVersioningStrategy,
-    },
-};
-use temporal_sdk_core_protos::{
-    DEFAULT_WORKFLOW_TYPE, canned_histories,
-    coresdk::{
-        ActivityTaskCompletion, AsJsonPayloadExt, IntoCompletion,
-        activity_result::ActivityExecutionResult,
-        workflow_activation::{WorkflowActivationJob, workflow_activation_job},
-        workflow_commands::{
-            ActivityCancellationType, FailWorkflowExecution, QueryResult, QuerySuccess, StartTimer,
+    prost_dur,
+    protos::{
+        DEFAULT_WORKFLOW_TYPE, canned_histories,
+        coresdk::{
+            ActivityTaskCompletion, AsJsonPayloadExt, IntoCompletion,
+            activity_result::ActivityExecutionResult,
+            workflow_activation::{WorkflowActivationJob, workflow_activation_job},
+            workflow_commands::{
+                ActivityCancellationType, FailWorkflowExecution, QueryResult, QuerySuccess,
+                StartTimer,
+            },
+            workflow_completion::WorkflowActivationCompletion,
         },
-        workflow_completion::WorkflowActivationCompletion,
+        temporal::api::{
+            enums::v1::{CommandType, EventType},
+            failure::v1::Failure,
+            history::v1::history_event,
+            query::v1::WorkflowQuery,
+            sdk::v1::UserMetadata,
+        },
+        test_utils::schedule_activity_cmd,
     },
-    prost_dur,
-    temporal::api::{
-        enums::v1::{CommandType, EventType},
-        failure::v1::Failure,
-        history::v1::history_event,
-        query::v1::WorkflowQuery,
-        sdk::v1::UserMetadata,
+    worker::{
+        PollerBehavior, WorkerDeploymentOptions, WorkerDeploymentVersion, WorkerTaskTypes,
+        WorkerVersioningStrategy,
     },
-    test_utils::schedule_activity_cmd,
+};
+use temporalio_sdk::{
+    ActivityOptions, LocalActivityOptions, TimerOptions, WfContext, interceptors::WorkerInterceptor,
+};
+use temporalio_sdk_core::{
+    CoreRuntime,
+    replay::HistoryForReplay,
+    test_help::{MockPollCfg, WorkerTestHelpers, drain_pollers_and_shutdown},
 };
 use tokio::{join, sync::Notify, time::sleep};
-
 // TODO: We should get expected histories for these tests and confirm that the history at the end
 //  matches.
 
@@ -75,7 +78,9 @@ use tokio::{join, sync::Notify, time::sleep};
 async fn parallel_workflows_same_queue() {
     let wf_name = "parallel_workflows_same_queue";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.no_remote_activities(true);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
     let mut core = starter.worker().await;
 
     core.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
@@ -126,9 +131,7 @@ async fn shutdown_aborts_actively_blocked_poll() {
 async fn fail_wf_task(#[values(true, false)] replay: bool) {
     let core = if replay {
         // We need to send the history twice, since we fail it the first time.
-        let mut hist_proto = history_from_proto_binary("histories/fail_wf_task.bin")
-            .await
-            .unwrap();
+        let mut hist_proto = history_from_proto_binary("fail_wf_task.bin").await.unwrap();
         let hist = HistoryForReplay::new(hist_proto.clone(), "fake".to_string());
         if let Some(history_event::Attributes::WorkflowExecutionStartedEventAttributes(
             ref mut attrs,
@@ -514,7 +517,7 @@ async fn slow_completes_with_small_cache() {
             // They don't need to be much slower
             tokio::time::sleep(Duration::from_millis(100)).await;
         }
-        fn on_shutdown(&self, _: &temporal_sdk::Worker) {}
+        fn on_shutdown(&self, _: &temporalio_sdk::Worker) {}
     }
     worker
         .run_until_done_intercepted(Some(SlowCompleter {}))
@@ -544,7 +547,7 @@ async fn deployment_version_correct_in_wf_info(#[values(true, false)] use_only_b
     starter
         .worker_config
         .versioning_strategy(version_strat)
-        .no_remote_activities(true);
+        .task_types(WorkerTaskTypes::workflow_only());
     let core = starter.get_worker().await;
     starter.start_wf().await;
     let client = starter.get_client().await;
@@ -764,10 +767,12 @@ async fn nondeterminism_errors_fail_workflow_when_configured_to(
     #[values(true, false)] whole_worker: bool,
 ) {
     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 = "nondeterminism_errors_fail_workflow_when_configured_to";
     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 typeset = HashSet::from([WorkflowErrorType::Nondeterminism]);
     if whole_worker {
         starter.worker_config.workflow_failure_errors(typeset);

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

@@ -22,22 +22,26 @@ mod integ_tests {
     mod queries_tests;
     mod update_tests;
     mod visibility_tests;
+    mod worker_heartbeat_tests;
     mod worker_tests;
     mod worker_versioning_tests;
     mod workflow_tests;
 
     use crate::common::{
-        CoreWfStarter, get_integ_server_options, get_integ_telem_options, rand_6_chars,
+        CoreWfStarter, get_integ_runtime_options, get_integ_server_options,
+        get_integ_telem_options, rand_6_chars,
     };
     use std::time::Duration;
-    use temporal_client::{NamespacedClient, WorkflowService};
-    use temporal_sdk_core::{CoreRuntime, init_worker};
-    use temporal_sdk_core_api::worker::WorkerConfigBuilder;
-    use temporal_sdk_core_protos::temporal::api::{
-        nexus::v1::{EndpointSpec, EndpointTarget, endpoint_target},
-        operatorservice::v1::CreateNexusEndpointRequest,
-        workflowservice::v1::ListNamespacesRequest,
+    use temporalio_client::{NamespacedClient, WorkflowService};
+    use temporalio_common::{
+        protos::temporal::api::{
+            nexus::v1::{EndpointSpec, EndpointTarget, endpoint_target},
+            operatorservice::v1::CreateNexusEndpointRequest,
+            workflowservice::v1::ListNamespacesRequest,
+        },
+        worker::WorkerConfigBuilder,
     };
+    use temporalio_sdk_core::{CoreRuntime, init_worker};
     use tonic::IntoRequest;
 
     // Create a worker like a bridge would (unwraps aside)
@@ -45,7 +49,9 @@ mod integ_tests {
     #[ignore] // Really a compile time check more than anything
     async fn lang_bridge_example() {
         let opts = get_integ_server_options();
-        let runtime = CoreRuntime::new_assume_tokio(get_integ_telem_options()).unwrap();
+        let runtime =
+            CoreRuntime::new_assume_tokio(get_integ_runtime_options(get_integ_telem_options()))
+                .unwrap();
         let mut retrying_client = opts
             .connect_no_namespace(runtime.telemetry().get_temporal_metric_meter())
             .await

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

@@ -5,6 +5,7 @@
 #[allow(dead_code)]
 mod common;
 
+use crate::common::get_integ_runtime_options;
 use common::{CoreWfStarter, prom_metrics, rand_6_chars};
 use futures_util::{
     StreamExt,
@@ -18,11 +19,16 @@ use std::{
     net::SocketAddr,
     time::{Duration, Instant},
 };
-use temporal_client::{GetWorkflowResultOpts, WfClientExt, WorkflowClientTrait, WorkflowOptions};
-use temporal_sdk::{ActContext, ActivityOptions, WfContext};
-use temporal_sdk_core::CoreRuntime;
-use temporal_sdk_core_api::{telemetry::PrometheusExporterOptionsBuilder, worker::PollerBehavior};
-use temporal_sdk_core_protos::coresdk::AsJsonPayloadExt;
+use temporalio_client::{
+    GetWorkflowResultOptions, WfClientExt, WorkflowClientTrait, WorkflowOptions,
+};
+use temporalio_common::{
+    protos::coresdk::AsJsonPayloadExt,
+    telemetry::PrometheusExporterOptionsBuilder,
+    worker::{PollerBehavior, WorkerTaskTypes},
+};
+use temporalio_sdk::{ActContext, ActivityOptions, WfContext};
+use temporalio_sdk_core::CoreRuntime;
 use tracing::info;
 
 #[tokio::test]
@@ -41,7 +47,7 @@ async fn poller_load_spiky() {
         } else {
             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("poller_load", rt);
     starter
         .worker_config
@@ -118,7 +124,7 @@ async fn poller_load_spiky() {
         stream::iter(mem::take(&mut workflow_handles))
             .for_each_concurrent(25, |handle| async move {
                 let _ = handle
-                    .get_workflow_result(GetWorkflowResultOpts::default())
+                    .get_workflow_result(GetWorkflowResultOptions::default())
                     .await;
             })
             .await;
@@ -147,7 +153,7 @@ async fn poller_load_spiky() {
         stream::iter(workflow_handles)
             .for_each_concurrent(25, |handle| async move {
                 let _ = handle
-                    .get_workflow_result(GetWorkflowResultOpts::default())
+                    .get_workflow_result(GetWorkflowResultOptions::default())
                     .await;
             })
             .await;
@@ -200,7 +206,7 @@ async fn poller_load_sustained() {
         } else {
             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("poller_load", rt);
     starter
         .worker_config
@@ -211,7 +217,7 @@ async fn poller_load_sustained() {
             maximum: 200,
             initial: 5,
         })
-        .no_remote_activities(true);
+        .task_types(WorkerTaskTypes::workflow_only());
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
         let sigchan = ctx.make_signal_channel(SIGNAME).map(Ok);
@@ -261,7 +267,7 @@ async fn poller_load_sustained() {
         stream::iter(mem::take(&mut workflow_handles))
             .for_each_concurrent(25, |handle| async move {
                 let _ = handle
-                    .get_workflow_result(GetWorkflowResultOpts::default())
+                    .get_workflow_result(GetWorkflowResultOptions::default())
                     .await;
             })
             .await;
@@ -291,7 +297,7 @@ async fn poller_load_spike_then_sustained() {
         } else {
             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("poller_load", rt);
     starter
         .worker_config
@@ -367,7 +373,7 @@ async fn poller_load_spike_then_sustained() {
         stream::iter(mem::take(&mut workflow_handles))
             .for_each_concurrent(25, |handle| async move {
                 let _ = handle
-                    .get_workflow_result(GetWorkflowResultOpts::default())
+                    .get_workflow_result(GetWorkflowResultOptions::default())
                     .await;
             })
             .await;
@@ -396,7 +402,7 @@ async fn poller_load_spike_then_sustained() {
         stream::iter(workflow_handles)
             .for_each_concurrent(25, |handle| async move {
                 let _ = handle
-                    .get_workflow_result(GetWorkflowResultOpts::default())
+                    .get_workflow_result(GetWorkflowResultOptions::default())
                     .await;
             })
             .await;

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

@@ -11,7 +11,7 @@ use std::{
     path::{Path, PathBuf},
     process::Stdio,
 };
-use temporal_sdk_core::ephemeral_server::{TestServerConfigBuilder, default_cached_download};
+use temporalio_sdk_core::ephemeral_server::{TestServerConfigBuilder, default_cached_download};
 use tokio::{self, process::Command};
 
 /// This env var is set (to any value) if temporal CLI dev server is in use
@@ -67,7 +67,7 @@ async fn main() -> Result<(), anyhow::Error> {
     let test_args_preamble = [
         "test",
         "--features",
-        "temporal-sdk-core-protos/serde_serialize",
+        "temporalio-common/serde_serialize",
         "--features",
         "test-utilities",
         "--features",

package/sdk-core/{tests → crates/sdk-core/tests}/shared_tests/mod.rs

@@ -2,11 +2,14 @@
 
 use crate::common::CoreWfStarter;
 use std::sync::atomic::{AtomicBool, Ordering::Relaxed};
-use temporal_sdk::WfContext;
-use temporal_sdk_core_protos::temporal::api::{
-    enums::v1::{EventType, WorkflowTaskFailedCause::GrpcMessageTooLarge},
-    history::v1::history_event::Attributes::WorkflowTaskFailedEventAttributes,
+use temporalio_common::{
+    protos::temporal::api::{
+        enums::v1::{EventType, WorkflowTaskFailedCause::GrpcMessageTooLarge},
+        history::v1::history_event::Attributes::WorkflowTaskFailedEventAttributes,
+    },
+    worker::WorkerTaskTypes,
 };
+use temporalio_sdk::WfContext;
 
 pub(crate) mod priority;
 
@@ -15,7 +18,9 @@ pub(crate) async fn grpc_message_too_large() {
     let mut starter = CoreWfStarter::new_cloud_or_local(wf_name, "")
         .await
         .unwrap();
-    starter.worker_config.no_remote_activities(true);
+    starter
+        .worker_config
+        .task_types(WorkerTaskTypes::workflow_only());
     let mut core = starter.worker().await;
 
     static OVERSIZE_GRPC_MESSAGE_RUN: AtomicBool = AtomicBool::new(false);

package/sdk-core/{tests → crates/sdk-core/tests}/shared_tests/priority.rs

@@ -1,13 +1,13 @@
 use crate::common::CoreWfStarter;
 use std::time::Duration;
-use temporal_client::{
-    GetWorkflowResultOpts, Priority, WfClientExt, WorkflowClientTrait, WorkflowOptions,
+use temporalio_client::{
+    GetWorkflowResultOptions, Priority, WfClientExt, WorkflowClientTrait, WorkflowOptions,
 };
-use temporal_sdk::{ActContext, ActivityOptions, ChildWorkflowOptions, WfContext};
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     coresdk::AsJsonPayloadExt,
     temporal::api::{common, history::v1::history_event::Attributes},
 };
+use temporalio_sdk::{ActContext, ActivityOptions, ChildWorkflowOptions, WfContext};
 
 pub(crate) async fn priority_values_sent_to_server() {
     let mut starter = if let Some(wfs) =
@@ -93,7 +93,7 @@ pub(crate) async fn priority_values_sent_to_server() {
     let client = starter.get_client().await;
     let handle = client.get_untyped_workflow_handle(starter.get_task_queue(), "");
     let res = handle
-        .get_workflow_result(GetWorkflowResultOpts::default())
+        .get_workflow_result(GetWorkflowResultOptions::default())
         .await
         .unwrap();
     // Expect workflow success