@temporalio/core-bridge 1.13.2 → 1.14.0

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

@@ -3,23 +3,26 @@ use std::{
     sync::atomic::{AtomicBool, AtomicUsize, Ordering},
     time::Duration,
 };
-use temporal_client::WorkflowOptions;
-use temporal_sdk::{
+use temporalio_client::WorkflowOptions;
+use temporalio_common::{
+    protos::{
+        DEFAULT_ACTIVITY_TYPE, TestHistoryBuilder, canned_histories,
+        coresdk::AsJsonPayloadExt,
+        temporal::api::{
+            enums::v1::{EventType, WorkflowTaskFailedCause},
+            failure::v1::Failure,
+        },
+    },
+    worker::WorkerTaskTypes,
+};
+use temporalio_sdk::{
     ActContext, ActivityOptions, ChildWorkflowOptions, LocalActivityOptions, WfContext,
     WorkflowResult,
 };
-use temporal_sdk_core::{
+use temporalio_sdk_core::{
     replay::DEFAULT_WORKFLOW_TYPE,
     test_help::{CoreInternalFlags, MockPollCfg, ResponseType, mock_worker_client},
 };
-use temporal_sdk_core_protos::{
-    DEFAULT_ACTIVITY_TYPE, TestHistoryBuilder, canned_histories,
-    coresdk::AsJsonPayloadExt,
-    temporal::api::{
-        enums::v1::{EventType, WorkflowTaskFailedCause},
-        failure::v1::Failure,
-    },
-};
 
 static RUN_CT: AtomicUsize = AtomicUsize::new(1);
 
@@ -52,7 +55,9 @@ pub(crate) async fn timer_wf_nondeterministic(ctx: WfContext) -> WorkflowResult<
 async fn test_determinism_error_then_recovers() {
     let wf_name = "test_determinism_error_then_recovers";
     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_nondeterministic);
@@ -121,11 +126,15 @@ async fn test_panic_wf_task_rejected_properly() {
     let t = canned_histories::workflow_fails_with_failure_after_timer("1");
     let mock = mock_worker_client();
     let mut mh = MockPollCfg::from_resp_batches(wf_id, t, [1, 2, 2], mock);
-    // We should see one wft failure which has unspecified cause, since panics don't have a defined
+    // We should see one wft failure which has the default cause, since panics don't have a defined
     // type.
     mh.num_expected_fails = 1;
-    mh.expect_fail_wft_matcher =
-        Box::new(|_, cause, _| matches!(cause, WorkflowTaskFailedCause::Unspecified));
+    mh.expect_fail_wft_matcher = Box::new(|_, cause, _| {
+        matches!(
+            cause,
+            WorkflowTaskFailedCause::WorkflowWorkerUnhandledFailure
+        )
+    });
     let mut worker = mock_sdk(mh);
 
     worker.register_wf(wf_type.to_owned(), timer_wf_fails_once);

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

@@ -1,7 +1,8 @@
 use crate::common::{CoreWfStarter, NAMESPACE, get_integ_server_options};
 use std::time::Duration;
-use temporal_client::WorkflowClientTrait;
-use temporal_sdk::{WfContext, WorkflowResult};
+use temporalio_client::WorkflowClientTrait;
+use temporalio_common::worker::WorkerTaskTypes;
+use temporalio_sdk::{WfContext, WorkflowResult};
 
 pub(crate) async fn eager_wf(_context: WfContext) -> WorkflowResult<()> {
     Ok(().into())
@@ -14,7 +15,9 @@ async fn eager_wf_start() {
     starter.workflow_options.enable_eager_workflow_start = true;
     // hang the test if eager task dispatch failed
     starter.workflow_options.task_timeout = Some(Duration::from_secs(1500));
-    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(), eager_wf);
     starter.eager_start_with_worker(wf_name, &mut worker).await;
@@ -28,7 +31,9 @@ async fn eager_wf_start_different_clients() {
     starter.workflow_options.enable_eager_workflow_start = true;
     // hang the test if wf task needs retry
     starter.workflow_options.task_timeout = Some(Duration::from_secs(1500));
-    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(), eager_wf);
 

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

@@ -16,13 +16,43 @@ use std::{
     },
     time::{Duration, Instant, SystemTime},
 };
-use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions};
-use temporal_sdk::{
+use temporalio_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions};
+use temporalio_common::{
+    Worker,
+    errors::PollError,
+    protos::{
+        DEFAULT_ACTIVITY_TYPE, canned_histories,
+        coresdk::{
+            ActivityTaskCompletion, AsJsonPayloadExt, FromJsonPayloadExt, IntoPayloadsExt,
+            activity_result::ActivityExecutionResult,
+            workflow_activation::{WorkflowActivationJob, workflow_activation_job},
+            workflow_commands::{
+                ActivityCancellationType, ScheduleLocalActivity, workflow_command::Variant,
+            },
+            workflow_completion,
+            workflow_completion::{WorkflowActivationCompletion, workflow_activation_completion},
+        },
+        temporal::api::{
+            command::v1::{RecordMarkerCommandAttributes, command},
+            common::v1::RetryPolicy,
+            enums::v1::{
+                CommandType, EventType, TimeoutType, UpdateWorkflowExecutionLifecycleStage,
+                WorkflowTaskFailedCause,
+            },
+            failure::v1::{Failure, failure::FailureInfo},
+            history::v1::history_event::Attributes::MarkerRecordedEventAttributes,
+            query::v1::WorkflowQuery,
+            update::v1::WaitPolicy,
+        },
+        test_utils::{query_ok, schedule_local_activity_cmd, start_timer_cmd},
+    },
+};
+use temporalio_sdk::{
     ActContext, ActivityError, ActivityOptions, CancellableFuture, LocalActivityOptions,
     UpdateContext, WfContext, WorkflowFunction, WorkflowResult,
     interceptors::{FailOnNondeterminismInterceptor, WorkerInterceptor},
 };
-use temporal_sdk_core::{
+use temporalio_sdk_core::{
     prost_dur,
     replay::{DEFAULT_WORKFLOW_TYPE, HistoryForReplay, TestHistoryBuilder, default_wes_attribs},
     test_help::{
@@ -31,33 +61,6 @@ use temporal_sdk_core::{
         single_hist_mock_sg,
     },
 };
-use temporal_sdk_core_api::{Worker, errors::PollError};
-use temporal_sdk_core_protos::{
-    DEFAULT_ACTIVITY_TYPE, canned_histories,
-    coresdk::{
-        ActivityTaskCompletion, AsJsonPayloadExt, FromJsonPayloadExt, IntoPayloadsExt,
-        activity_result::ActivityExecutionResult,
-        workflow_activation::{WorkflowActivationJob, workflow_activation_job},
-        workflow_commands::{
-            ActivityCancellationType, ScheduleLocalActivity, workflow_command::Variant,
-        },
-        workflow_completion,
-        workflow_completion::{WorkflowActivationCompletion, workflow_activation_completion},
-    },
-    temporal::api::{
-        command::v1::{RecordMarkerCommandAttributes, command},
-        common::v1::RetryPolicy,
-        enums::v1::{
-            CommandType, EventType, TimeoutType, UpdateWorkflowExecutionLifecycleStage,
-            WorkflowTaskFailedCause,
-        },
-        failure::v1::{Failure, failure::FailureInfo},
-        history::v1::history_event::Attributes::MarkerRecordedEventAttributes,
-        query::v1::WorkflowQuery,
-        update::v1::WaitPolicy,
-    },
-    test_utils::{query_ok, schedule_local_activity_cmd, start_timer_cmd},
-};
 use tokio::{join, select, sync::Barrier};
 use tokio_util::sync::CancellationToken;
 
@@ -301,7 +304,7 @@ impl WorkerInterceptor for LACancellerInterceptor {
             self.token.cancel();
         }
     }
-    fn on_shutdown(&self, _: &temporal_sdk::Worker) {
+    fn on_shutdown(&self, _: &temporalio_sdk::Worker) {
         if !self.cancel_on_workflow_completed {
             self.token.cancel()
         }
@@ -631,11 +634,10 @@ async fn repro_nondeterminism_with_timer_bug() {
 #[rstest::rstest]
 #[tokio::test]
 async fn weird_la_nondeterminism_repro(#[values(true, false)] fix_hist: bool) {
-    let mut hist = history_from_proto_binary(
-        "histories/evict_while_la_running_no_interference-85_history.bin",
-    )
-    .await
-    .unwrap();
+    let mut hist =
+        history_from_proto_binary("evict_while_la_running_no_interference-85_history.bin")
+            .await
+            .unwrap();
     if fix_hist {
         // Replace broken ending with accurate ending
         hist.events.truncate(20);
@@ -659,11 +661,10 @@ async fn weird_la_nondeterminism_repro(#[values(true, false)] fix_hist: bool) {
 
 #[tokio::test]
 async fn second_weird_la_nondeterminism_repro() {
-    let mut hist = history_from_proto_binary(
-        "histories/evict_while_la_running_no_interference-23_history.bin",
-    )
-    .await
-    .unwrap();
+    let mut hist =
+        history_from_proto_binary("evict_while_la_running_no_interference-23_history.bin")
+            .await
+            .unwrap();
     // Chop off uninteresting ending
     hist.events.truncate(24);
     let mut thb = TestHistoryBuilder::from_history(hist.events);
@@ -684,11 +685,10 @@ async fn second_weird_la_nondeterminism_repro() {
 
 #[tokio::test]
 async fn third_weird_la_nondeterminism_repro() {
-    let mut hist = history_from_proto_binary(
-        "histories/evict_while_la_running_no_interference-16_history.bin",
-    )
-    .await
-    .unwrap();
+    let mut hist =
+        history_from_proto_binary("evict_while_la_running_no_interference-16_history.bin")
+            .await
+            .unwrap();
     let mut thb = TestHistoryBuilder::from_history(hist.events);
     thb.add_workflow_task_scheduled_and_started();
     hist = thb.get_full_history_info().unwrap().into();
@@ -871,7 +871,7 @@ async fn long_local_activity_with_update(
     let replay_worker = init_core_replay_preloaded(
         starter.get_task_queue(),
         [HistoryForReplay::new(
-            history_from_proto_binary(&format!("histories/{wf_name}_history.bin"))
+            history_from_proto_binary(&format!("{wf_name}_history.bin"))
                 .await
                 .unwrap(),
             "fake".to_owned(),

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

@@ -1,16 +1,19 @@
 use crate::common::{CoreWfStarter, build_fake_sdk};
-use temporal_client::WorkflowClientTrait;
-use temporal_sdk::{WfContext, 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_client::WorkflowClientTrait;
+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, WorkflowResult};
+use temporalio_sdk_core::test_help::MockPollCfg;
 use uuid::Uuid;
 
 static FIELD_A: &str = "cat_name";
@@ -29,7 +32,9 @@ async fn sends_modify_wf_props() {
     let wf_name = "can_upsert_memo";
     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, memo_upserter);

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

@@ -11,28 +11,31 @@ use std::{
     },
     time::Duration,
 };
-use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions};
-use temporal_sdk::{CancellableFuture, NexusOperationOptions, WfContext, WfExitValue};
-use temporal_sdk_core_api::errors::PollError;
-use temporal_sdk_core_protos::{
-    coresdk::{
-        FromJsonPayloadExt,
-        nexus::{
-            NexusOperationCancellationType, NexusOperationResult, NexusTaskCancelReason,
-            NexusTaskCompletion, nexus_operation_result, nexus_task, nexus_task_completion,
+use temporalio_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions};
+use temporalio_common::{
+    errors::PollError,
+    protos::{
+        coresdk::{
+            FromJsonPayloadExt,
+            nexus::{
+                NexusOperationCancellationType, NexusOperationResult, NexusTaskCancelReason,
+                NexusTaskCompletion, nexus_operation_result, nexus_task, nexus_task_completion,
+            },
         },
-    },
-    temporal::api::{
-        common::v1::{Callback, callback},
-        enums::v1::NexusHandlerErrorRetryBehavior,
-        failure::v1::{Failure, failure::FailureInfo},
-        nexus,
-        nexus::v1::{
-            CancelOperationResponse, HandlerError, StartOperationResponse, request,
-            start_operation_response, workflow_event_link_from_nexus,
+        temporal::api::{
+            common::v1::{Callback, callback},
+            enums::v1::NexusHandlerErrorRetryBehavior,
+            failure::v1::{Failure, failure::FailureInfo},
+            nexus,
+            nexus::v1::{
+                CancelOperationResponse, HandlerError, StartOperationResponse, request,
+                start_operation_response, workflow_event_link_from_nexus,
+            },
         },
     },
+    worker::WorkerTaskTypes,
 };
+use temporalio_sdk::{CancellableFuture, NexusOperationOptions, WfContext, WfExitValue};
 use tokio::{
     join,
     sync::{mpsc, watch},
@@ -55,7 +58,12 @@ async fn nexus_basic(
 ) {
     let wf_name = "nexus_basic";
     let mut starter = CoreWfStarter::new(wf_name);
-    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 mut worker = starter.worker().await;
     let core_worker = starter.get_worker().await;
 
@@ -200,7 +208,12 @@ async fn nexus_async(
 ) {
     let wf_name = "nexus_async";
     let mut starter = CoreWfStarter::new(wf_name);
-    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 mut worker = starter.worker().await;
     let core_worker = starter.get_worker().await;
 
@@ -427,7 +440,12 @@ async fn nexus_async(
 async fn nexus_cancel_before_start() {
     let wf_name = "nexus_cancel_before_start";
     let mut starter = CoreWfStarter::new(wf_name);
-    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 mut worker = starter.worker().await;
 
     let endpoint = mk_nexus_endpoint(&mut starter).await;
@@ -469,7 +487,12 @@ async fn nexus_cancel_before_start() {
 async fn nexus_must_complete_task_to_shutdown(#[values(true, false)] use_grace_period: bool) {
     let wf_name = "nexus_must_complete_task_to_shutdown";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.no_remote_activities(true);
+    starter.worker_config.task_types(WorkerTaskTypes {
+        enable_workflows: true,
+        enable_local_activities: false,
+        enable_remote_activities: false,
+        enable_nexus: true,
+    });
     if use_grace_period {
         starter
             .worker_config
@@ -569,7 +592,12 @@ async fn nexus_cancellation_types(
 ) {
     let wf_name = "nexus_cancellation_types";
     let mut starter = CoreWfStarter::new(wf_name);
-    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 mut worker = starter.worker().await;
     let core_worker = starter.get_worker().await;
 

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

@@ -7,10 +7,8 @@ use std::{
     },
     time::Duration,
 };
-use temporal_client::WorkflowClientTrait;
-use temporal_sdk::{ActivityOptions, WfContext, WorkflowResult};
-use temporal_sdk_core::test_help::{CoreInternalFlags, MockPollCfg, ResponseType};
-use temporal_sdk_core_protos::{
+use temporalio_client::WorkflowClientTrait;
+use temporalio_common::protos::{
     DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder, VERSION_SEARCH_ATTR_KEY,
     constants::PATCH_MARKER_NAME,
     coresdk::{
@@ -31,6 +29,10 @@ use temporal_sdk_core_protos::{
         },
     },
 };
+
+use temporalio_common::worker::WorkerTaskTypes;
+use temporalio_sdk::{ActivityOptions, WfContext, WorkflowResult};
+use temporalio_sdk_core::test_help::{CoreInternalFlags, MockPollCfg, ResponseType};
 use tokio::{join, sync::Notify};
 use tokio_stream::StreamExt;
 
@@ -55,7 +57,9 @@ pub(crate) async fn changes_wf(ctx: WfContext) -> WorkflowResult<()> {
 async fn writes_change_markers() {
     let wf_name = "writes_change_markers";
     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(), changes_wf);
 
@@ -89,7 +93,9 @@ pub(crate) async fn no_change_then_change_wf(ctx: WfContext) -> WorkflowResult<(
 async fn can_add_change_markers() {
     let wf_name = "can_add_change_markers";
     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(), no_change_then_change_wf);
 
@@ -113,7 +119,9 @@ pub(crate) async fn replay_with_change_marker_wf(ctx: WfContext) -> WorkflowResu
 async fn replaying_with_patch_marker() {
     let wf_name = "replaying_with_patch_marker";
     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(), replay_with_change_marker_wf);
 
@@ -132,7 +140,7 @@ async fn patched_on_second_workflow_task_is_deterministic() {
     starter
         .worker_config
         .max_cached_workflows(0_usize)
-        .no_remote_activities(true);
+        .task_types(WorkerTaskTypes::workflow_only());
     let mut worker = starter.worker().await;
     // Include a task failure as well to make sure that works
     static FAIL_ONCE: AtomicBool = AtomicBool::new(true);
@@ -155,7 +163,9 @@ async fn patched_on_second_workflow_task_is_deterministic() {
 async fn can_remove_deprecated_patch_near_other_patch() {
     let wf_name = "can_add_change_markers";
     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 did_die = Arc::new(AtomicBool::new(false));
     worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| {
@@ -186,7 +196,9 @@ async fn can_remove_deprecated_patch_near_other_patch() {
 async fn deprecated_patch_removal() {
     let wf_name = "deprecated_patch_removal";
     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;
     let wf_id = starter.get_task_queue().to_string();

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

@@ -8,22 +8,24 @@ use crate::{
 use assert_matches::assert_matches;
 use parking_lot::Mutex;
 use std::{collections::HashSet, sync::Arc, time::Duration};
-use temporal_sdk::{WfContext, Worker, WorkflowFunction, interceptors::WorkerInterceptor};
-use temporal_sdk_core::{
+use temporalio_common::{
+    errors::PollError,
+    prost_dur,
+    protos::{
+        DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder, canned_histories,
+        coresdk::{
+            workflow_activation::remove_from_cache::EvictionReason,
+            workflow_commands::{ScheduleActivity, StartTimer},
+            workflow_completion::WorkflowActivationCompletion,
+        },
+        temporal::api::enums::v1::EventType,
+    },
+};
+use temporalio_sdk::{WfContext, Worker, WorkflowFunction, interceptors::WorkerInterceptor};
+use temporalio_sdk_core::{
     replay::{HistoryFeeder, HistoryForReplay},
     test_help::{MockPollCfg, ResponseType, WorkerTestHelpers},
 };
-use temporal_sdk_core_api::errors::PollError;
-use temporal_sdk_core_protos::{
-    DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder, canned_histories,
-    coresdk::{
-        workflow_activation::remove_from_cache::EvictionReason,
-        workflow_commands::{ScheduleActivity, StartTimer},
-        workflow_completion::WorkflowActivationCompletion,
-    },
-    prost_dur,
-    temporal::api::enums::v1::EventType,
-};
 use tokio::join;
 
 fn test_hist_to_replay(t: TestHistoryBuilder) -> HistoryForReplay {
@@ -88,7 +90,7 @@ async fn timer_workflow_replay() {
     let core = init_core_replay_preloaded(
         "timer_workflow_replay",
         [HistoryForReplay::new(
-            history_from_proto_binary("histories/timer_workflow_history.bin")
+            history_from_proto_binary("timer_workflow_history.bin")
                 .await
                 .unwrap(),
             "fake".to_owned(),
@@ -145,7 +147,7 @@ async fn workflow_nondeterministic_replay() {
     let core = init_core_replay_preloaded(
         "timer_workflow_replay",
         [HistoryForReplay::new(
-            history_from_proto_binary("histories/timer_workflow_history.bin")
+            history_from_proto_binary("timer_workflow_history.bin")
                 .await
                 .unwrap(),
             "fake".to_owned(),
@@ -300,7 +302,7 @@ async fn multiple_histories_can_handle_dupe_run_ids() {
 #[tokio::test]
 async fn replay_old_patch_format() {
     let mut worker = replay_sdk_worker([HistoryForReplay::new(
-        history_from_proto_binary("histories/old_change_marker_format.bin")
+        history_from_proto_binary("old_change_marker_format.bin")
             .await
             .unwrap(),
         "fake".to_owned(),
@@ -314,7 +316,7 @@ async fn replay_ends_with_empty_wft() {
     let core = init_core_replay_preloaded(
         "SayHelloWorkflow",
         [HistoryForReplay::new(
-            history_from_proto_binary("histories/ends_empty_wft_complete.bin")
+            history_from_proto_binary("ends_empty_wft_complete.bin")
                 .await
                 .unwrap(),
             "fake".to_owned(),

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

@@ -10,14 +10,16 @@ use std::{
     },
     time::Duration,
 };
-use temporal_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions, WorkflowService};
-use temporal_sdk::{LocalActivityOptions, WfContext};
-use temporal_sdk_core_protos::{
+use temporalio_client::{WfClientExt, WorkflowClientTrait, WorkflowOptions, WorkflowService};
+use temporalio_common::protos::{
     coresdk::AsJsonPayloadExt,
     temporal::api::{
         common::v1::WorkflowExecution, workflowservice::v1::ResetWorkflowExecutionRequest,
     },
 };
+
+use temporalio_common::worker::WorkerTaskTypes;
+use temporalio_sdk::{LocalActivityOptions, WfContext};
 use tokio::sync::Notify;
 use tonic::IntoRequest;
 
@@ -27,7 +29,9 @@ const POST_RESET_SIG: &str = "post-reset";
 async fn reset_workflow() {
     let wf_name = "reset_me_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.fetch_results = false;
     let notify = Arc::new(Notify::new());
@@ -113,7 +117,12 @@ async fn reset_workflow() {
 async fn reset_randomseed() {
     let wf_name = "reset_randomseed";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.worker_config.no_remote_activities(true);
+    starter.worker_config.task_types(WorkerTaskTypes {
+        enable_workflows: true,
+        enable_local_activities: true,
+        enable_remote_activities: false,
+        enable_nexus: true,
+    });
     let mut worker = starter.worker().await;
     worker.fetch_results = false;
     let notify = Arc::new(Notify::new());