@temporalio/core-bridge 1.13.2 → 1.14.0

package/sdk-core/{core-api → crates/common}/src/worker.rs

@@ -1,4 +1,16 @@
-use crate::{errors::WorkflowErrorType, telemetry::metrics::TemporalMeter};
+//! Contains types that are needed by both the client and the sdk when configuring / interacting
+//! with workers.
+
+use crate::{
+    errors::WorkflowErrorType,
+    protos::{
+        coresdk,
+        coresdk::{ActivitySlotInfo, LocalActivitySlotInfo, NexusSlotInfo, WorkflowSlotInfo},
+        temporal,
+        temporal::api::{enums::v1::VersioningBehavior, worker::v1::PluginInfo},
+    },
+    telemetry::metrics::TemporalMeter,
+};
 use std::{
     any::Any,
     collections::{HashMap, HashSet},
@@ -6,12 +18,74 @@ use std::{
     sync::Arc,
     time::Duration,
 };
-use temporal_sdk_core_protos::{
-    coresdk,
-    coresdk::{ActivitySlotInfo, LocalActivitySlotInfo, NexusSlotInfo, WorkflowSlotInfo},
-    temporal,
-    temporal::api::enums::v1::VersioningBehavior,
-};
+
+/// Specifies which task types a worker will poll for.
+///
+/// Workers can be configured to handle any combination of workflows, activities, and nexus operations.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct WorkerTaskTypes {
+    pub enable_workflows: bool,
+    pub enable_local_activities: bool,
+    pub enable_remote_activities: bool,
+    pub enable_nexus: bool,
+}
+
+impl WorkerTaskTypes {
+    /// Check if no task types are enabled
+    pub fn is_empty(&self) -> bool {
+        !self.enable_workflows
+            && !self.enable_local_activities
+            && !self.enable_remote_activities
+            && !self.enable_nexus
+    }
+
+    /// Create a config with all task types enabled
+    pub fn all() -> WorkerTaskTypes {
+        WorkerTaskTypes {
+            enable_workflows: true,
+            enable_local_activities: true,
+            enable_remote_activities: true,
+            enable_nexus: true,
+        }
+    }
+
+    /// Create a config with only workflow tasks enabled
+    pub fn workflow_only() -> WorkerTaskTypes {
+        WorkerTaskTypes {
+            enable_workflows: true,
+            enable_local_activities: false,
+            enable_remote_activities: false,
+            enable_nexus: false,
+        }
+    }
+
+    /// Create a config with only activity tasks enabled
+    pub fn activity_only() -> WorkerTaskTypes {
+        WorkerTaskTypes {
+            enable_workflows: false,
+            enable_local_activities: false,
+            enable_remote_activities: true,
+            enable_nexus: false,
+        }
+    }
+
+    /// Create a config with only nexus tasks enabled
+    pub fn nexus_only() -> WorkerTaskTypes {
+        WorkerTaskTypes {
+            enable_workflows: false,
+            enable_local_activities: false,
+            enable_remote_activities: false,
+            enable_nexus: true,
+        }
+    }
+
+    pub fn overlaps_with(&self, other: &WorkerTaskTypes) -> bool {
+        (self.enable_workflows && other.enable_workflows)
+            || (self.enable_local_activities && other.enable_local_activities)
+            || (self.enable_remote_activities && other.enable_remote_activities)
+            || (self.enable_nexus && other.enable_nexus)
+    }
+}
 
 /// Defines per-worker configuration options
 #[derive(Clone, derive_builder::Builder)]
@@ -61,10 +135,10 @@ pub struct WorkerConfig {
     /// worker's task queue
     #[builder(default = "PollerBehavior::SimpleMaximum(5)")]
     pub nexus_task_poller_behavior: PollerBehavior,
-    /// If set to true this worker will only handle workflow tasks and local activities, it will not
-    /// poll for activity tasks.
-    #[builder(default = "false")]
-    pub no_remote_activities: bool,
+    /// Specifies which task types this worker will poll for.
+    ///
+    /// Note: At least one task type must be specified or the worker will fail validation.
+    pub task_types: WorkerTaskTypes,
     /// How long a workflow task is allowed to sit on the sticky queue before it is timed out
     /// and moved to the non-sticky queue where it may be picked up by any worker.
     #[builder(default = "Duration::from_secs(10)")]
@@ -141,19 +215,19 @@ pub struct WorkerConfig {
     /// Mutually exclusive with `tuner`
     #[builder(setter(into, strip_option), default)]
     pub max_outstanding_workflow_tasks: Option<usize>,
-    /// The maximum number of activity tasks that will ever be given to this worker concurrently
+    /// The maximum number of activity tasks that will ever be given to this worker concurrently.
     ///
     /// Mutually exclusive with `tuner`
     #[builder(setter(into, strip_option), default)]
     pub max_outstanding_activities: Option<usize>,
     /// The maximum number of local activity tasks that will ever be given to this worker
-    /// concurrently
+    /// concurrently.
     ///
     /// Mutually exclusive with `tuner`
     #[builder(setter(into, strip_option), default)]
     pub max_outstanding_local_activities: Option<usize>,
     /// The maximum number of nexus tasks that will ever be given to this worker
-    /// concurrently
+    /// concurrently.
     ///
     /// Mutually exclusive with `tuner`
     #[builder(setter(into, strip_option), default)]
@@ -162,11 +236,13 @@ pub struct WorkerConfig {
     /// A versioning strategy for this worker.
     pub versioning_strategy: WorkerVersioningStrategy,
 
-    /// The interval within which the worker will send a heartbeat.
-    /// The timer is reset on each existing RPC call that also happens to send this data, like
-    /// `PollWorkflowTaskQueueRequest`.
+    /// List of plugins used by lang.
     #[builder(default)]
-    pub heartbeat_interval: Option<Duration>,
+    pub plugins: HashSet<PluginInfo>,
+
+    /// Skips the single worker+client+namespace+task_queue check
+    #[builder(default = "false")]
+    pub skip_client_worker_set_check: bool,
 }
 
 impl WorkerConfig {
@@ -213,6 +289,18 @@ impl WorkerConfigBuilder {
     }
 
     fn validate(&self) -> Result<(), String> {
+        let task_types = self
+            .task_types
+            .as_ref()
+            .cloned()
+            .unwrap_or_else(WorkerTaskTypes::all);
+        if task_types.is_empty() {
+            return Err("At least one task type must be enabled in `task_types`".to_owned());
+        }
+        if !task_types.enable_workflows && task_types.enable_local_activities {
+            return Err("`task_types` cannot enable local activities without workflows".to_owned());
+        }
+
         if let Some(b) = self.workflow_task_poller_behavior.as_ref() {
             b.validate()?
         }
@@ -363,6 +451,12 @@ pub trait SlotSupplier {
     fn available_slots(&self) -> Option<usize> {
         None
     }
+
+    /// Returns a human-friendly identifier describing this supplier implementation for
+    /// diagnostics and telemetry.
+    fn slot_supplier_kind(&self) -> String {
+        "Custom".to_string()
+    }
 }
 
 pub trait SlotReservationContext: Send + Sync {

package/sdk-core/crates/common/tests/worker_task_types_test.rs

@@ -0,0 +1,129 @@
+use temporalio_common::worker::{WorkerConfigBuilder, WorkerTaskTypes, WorkerVersioningStrategy};
+
+fn default_versioning_strategy() -> WorkerVersioningStrategy {
+    WorkerVersioningStrategy::None {
+        build_id: String::new(),
+    }
+}
+
+#[test]
+fn test_default_configuration_polls_all_types() {
+    let config = WorkerConfigBuilder::default()
+        .namespace("default")
+        .task_queue("test-queue")
+        .versioning_strategy(default_versioning_strategy())
+        .task_types(WorkerTaskTypes::all())
+        .build()
+        .expect("Failed to build default config");
+
+    let effective = &config.task_types;
+    assert!(
+        effective.enable_workflows,
+        "Should poll workflows by default"
+    );
+    assert!(
+        effective.enable_local_activities,
+        "should poll local activities by default"
+    );
+    assert!(
+        effective.enable_remote_activities,
+        "Should poll remote activities by default"
+    );
+    assert!(effective.enable_nexus, "Should poll nexus by default");
+}
+
+#[test]
+fn test_invalid_task_types_fails_validation() {
+    // empty task types
+    let result = WorkerConfigBuilder::default()
+        .namespace("default")
+        .task_queue("test-queue")
+        .versioning_strategy(default_versioning_strategy())
+        .task_types(WorkerTaskTypes {
+            enable_workflows: false,
+            enable_local_activities: false,
+            enable_remote_activities: false,
+            enable_nexus: false,
+        })
+        .build();
+
+    assert!(result.is_err(), "Empty task_types should fail validation");
+    let err = result.err().unwrap().to_string();
+    assert!(
+        err.contains("At least one task type"),
+        "Error should mention task types: {err}",
+    );
+
+    // local activities with no workflows
+    let result = WorkerConfigBuilder::default()
+        .namespace("default")
+        .task_queue("test-queue")
+        .versioning_strategy(default_versioning_strategy())
+        .task_types(WorkerTaskTypes {
+            enable_workflows: false,
+            enable_local_activities: true,
+            enable_remote_activities: false,
+            enable_nexus: false,
+        })
+        .build();
+
+    assert!(result.is_err(), "Empty task_types should fail validation");
+    let err = result.err().unwrap().to_string();
+    assert!(
+        err.contains("cannot enable local activities without workflows"),
+        "Error should mention task types: {err}",
+    );
+}
+
+#[test]
+fn test_all_combinations() {
+    let combinations = [
+        (WorkerTaskTypes::workflow_only(), "workflows only"),
+        (WorkerTaskTypes::activity_only(), "activities only"),
+        (WorkerTaskTypes::nexus_only(), "nexus only"),
+        (
+            WorkerTaskTypes {
+                enable_workflows: true,
+                enable_local_activities: true,
+                enable_remote_activities: true,
+                enable_nexus: false,
+            },
+            "workflows + activities",
+        ),
+        (
+            WorkerTaskTypes {
+                enable_workflows: true,
+                enable_local_activities: true,
+                enable_remote_activities: false,
+                enable_nexus: true,
+            },
+            "workflows + nexus",
+        ),
+        (
+            WorkerTaskTypes {
+                enable_workflows: false,
+                enable_local_activities: false,
+                enable_remote_activities: true,
+                enable_nexus: true,
+            },
+            "activities + nexus",
+        ),
+        (WorkerTaskTypes::all(), "all types"),
+    ];
+
+    for (task_types, description) in combinations {
+        let config = WorkerConfigBuilder::default()
+            .namespace("default")
+            .task_queue("test-queue")
+            .versioning_strategy(default_versioning_strategy())
+            .task_types(task_types)
+            .build()
+            .unwrap_or_else(|e| panic!("Failed to build config for {description}: {e:?}"));
+
+        let effective = config.task_types;
+        assert_eq!(
+            effective, task_types,
+            "Effective types should match for {description}",
+        );
+    }
+}

package/sdk-core/crates/macros/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "temporalio-macros"
+version = "0.1.0"
+edition = "2024"
+authors = ["Temporal Technologies Inc. <sdk@temporal.io>"]
+license-file = { workspace = true }
+description = "Procmacros used in Temporal Core & Rust SDKs"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+derive_more = { workspace = true }
+proc-macro2 = "1.0"
+syn = { version = "2.0", features = ["default", "extra-traits"] }
+quote = "1.0"
+
+[dev-dependencies]
+# This is to enable doctests for the macros
+temporalio-common = { path = "../common" }
+
+[package.metadata.workspaces]
+independent = true

package/sdk-core/{fsm/rustfsm_procmacro → crates/macros}/src/lib.rs

@@ -13,10 +13,9 @@ use syn::{
 ///
 /// An example state machine definition of a card reader for unlocking a door:
 /// ```
-/// # extern crate rustfsm_trait as rustfsm;
-/// use rustfsm_procmacro::fsm;
+/// use temporalio_macros::fsm;
 /// use std::convert::Infallible;
-/// use rustfsm_trait::{StateMachine, TransitionResult};
+/// use temporalio_common::fsm_trait::{StateMachine, TransitionResult};
 ///
 /// fsm! {
 ///     name CardReader; command Commands; error Infallible; shared_state SharedState;
@@ -543,7 +542,7 @@ impl StateMachineDefinition {
                     quote! { _ => {
                         // Restore state in event the transition doesn't match
                         self.state = #occupied_current_state;
-                        return Err(::rustfsm::MachineError::InvalidTransition)
+                        return Err(::temporalio_common::fsm_trait::MachineError::InvalidTransition)
                     } },
                 ));
             quote! {
@@ -553,14 +552,14 @@ impl StateMachineDefinition {
             }
         }).chain(std::iter::once(
             quote! {
-                None => Err(::rustfsm::MachineError::InvalidTransition)
+                None => Err(::temporalio_common::fsm_trait::MachineError::InvalidTransition)
             }
         )).collect();
 
         let viz_str = self.visualize();
 
         let trait_impl = quote! {
-            impl ::rustfsm::StateMachine for #name {
+            impl ::temporalio_common::fsm_trait::StateMachine for #name {
                 type Error = #err_type;
                 type State = #state_enum_name;
                 type SharedState = #shared_state_type;
@@ -573,7 +572,7 @@ impl StateMachineDefinition {
 
                 fn on_event(&mut self, event: #events_enum_name)
                   -> ::core::result::Result<::std::vec::Vec<Self::Command>,
-                                            ::rustfsm::MachineError<Self::Error>> {
+                                            ::temporalio_common::fsm_trait::MachineError<Self::Error>> {
                     let taken_state = self.state.take();
                     match taken_state {
                         #(#state_branches),*
@@ -584,10 +583,6 @@ impl StateMachineDefinition {
                     self.state.as_ref().unwrap()
                 }
 
-                fn set_state(&mut self, new: Self::State) {
-                    self.state = Some(new)
-                }
-
                 fn shared_state(&self) -> &Self::SharedState{
                     &self.shared_state
                 }

package/sdk-core/{sdk → crates/sdk}/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "temporal-sdk"
+name = "temporalio-sdk"
 version = "0.1.0-alpha.1"
 edition = "2024"
 authors = ["Spencer Judge <spencer@temporal.io>"]
@@ -29,22 +29,22 @@ tokio-util = { version = "0.7" }
 tokio-stream = "0.1"
 tracing = "0.1"
 
-[dependencies.temporal-sdk-core]
-path = "../core"
+[dependencies.temporalio-sdk-core]
+path = "../sdk-core"
 version = "0.1"
 default-features = false
 
-[dependencies.temporal-sdk-core-protos]
-path = "../sdk-core-protos"
+[dependencies.temporalio-common]
+path = "../common"
 version = "0.1"
 
-[dependencies.temporal-sdk-core-api]
-path = "../core-api"
-version = "0.1"
-
-[dependencies.temporal-client]
+[dependencies.temporalio-client]
 path = "../client"
 version = "0.1"
 
+[features]
+default = []
+antithesis_assertions = ["temporalio-sdk-core/antithesis_assertions"]
+
 [lints]
 workspace = true

package/sdk-core/{sdk → crates/sdk}/src/activity_context.rs

@@ -6,12 +6,14 @@ use std::{
     sync::Arc,
     time::{Duration as StdDuration, SystemTime},
 };
-use temporal_client::Priority;
-use temporal_sdk_core_api::Worker;
-use temporal_sdk_core_protos::{
-    coresdk::{ActivityHeartbeat, activity_task},
-    temporal::api::common::v1::{Payload, RetryPolicy, WorkflowExecution},
-    utilities::TryIntoOrNone,
+use temporalio_client::Priority;
+use temporalio_common::{
+    Worker,
+    protos::{
+        coresdk::{ActivityHeartbeat, activity_task},
+        temporal::api::common::v1::{Payload, RetryPolicy, WorkflowExecution},
+        utilities::TryIntoOrNone,
+    },
 };
 use tokio_util::sync::CancellationToken;
 

package/sdk-core/{sdk → crates/sdk}/src/interceptors.rs

@@ -3,7 +3,7 @@
 use crate::Worker;
 use anyhow::bail;
 use std::sync::{Arc, OnceLock};
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     coresdk::{
         workflow_activation::{WorkflowActivation, remove_from_cache::EvictionReason},
         workflow_completion::WorkflowActivationCompletion,

package/sdk-core/{sdk → crates/sdk}/src/lib.rs

@@ -9,21 +9,22 @@
 //! An example of running an activity worker:
 //! ```no_run
 //! use std::{str::FromStr, sync::Arc};
-//! use temporal_sdk::{sdk_client_options, ActContext, Worker};
-//! use temporal_sdk_core::{init_worker, Url, CoreRuntime};
-//! use temporal_sdk_core_api::{
+//! use temporalio_sdk::{sdk_client_options, ActContext, Worker};
+//! use temporalio_sdk_core::{init_worker, Url, CoreRuntime, RuntimeOptionsBuilder};
+//! use temporalio_common::{
 //!     worker::{WorkerConfigBuilder, WorkerVersioningStrategy},
 //!     telemetry::TelemetryOptionsBuilder
 //! };
 //!
 //! #[tokio::main]
 //! async fn main() -> Result<(), Box<dyn std::error::Error>> {
-//!     let server_options = sdk_client_options(Url::from_str("http://localhost:7233")?).build()?;
-//!
-//!     let client = server_options.connect("default", None).await?;
+//!     let server_options = sdk_client_options(Url::from_str("http://localhost:7233")?).build();
 //!
 //!     let telemetry_options = TelemetryOptionsBuilder::default().build()?;
-//!     let runtime = CoreRuntime::new_assume_tokio(telemetry_options)?;
+//!     let runtime_options = RuntimeOptionsBuilder::default().telemetry_options(telemetry_options).build().unwrap();
+//!     let runtime = CoreRuntime::new_assume_tokio(runtime_options)?;
+//!
+//!     let client = server_options.connect("default", None).await?;
 //!
 //!     let worker_config = WorkerConfigBuilder::default()
 //!         .namespace("default")
@@ -55,7 +56,7 @@ mod workflow_context;
 mod workflow_future;
 
 pub use activity_context::ActContext;
-pub use temporal_client::Namespace;
+pub use temporalio_client::Namespace;
 use tracing::{Instrument, Span, field};
 pub use workflow_context::{
     ActivityOptions, CancellableFuture, ChildWorkflow, ChildWorkflowOptions, LocalActivityOptions,
@@ -81,32 +82,37 @@ use std::{
     sync::Arc,
     time::Duration,
 };
-use temporal_client::ClientOptionsBuilder;
-use temporal_sdk_core::Url;
-use temporal_sdk_core_api::{Worker as CoreWorker, errors::PollError};
-use temporal_sdk_core_protos::{
-    TaskToken,
-    coresdk::{
-        ActivityTaskCompletion, AsJsonPayloadExt, FromJsonPayloadExt,
-        activity_result::{ActivityExecutionResult, ActivityResolution},
-        activity_task::{ActivityTask, activity_task},
-        child_workflow::ChildWorkflowResult,
-        common::NamespacedWorkflowExecution,
-        nexus::NexusOperationResult,
-        workflow_activation::{
-            WorkflowActivation,
-            resolve_child_workflow_execution_start::Status as ChildWorkflowStartStatus,
-            resolve_nexus_operation_start, workflow_activation_job::Variant,
+use temporalio_client::{ClientOptions, ClientOptionsBuilder, client_options_builder};
+use temporalio_common::{
+    Worker as CoreWorker,
+    errors::PollError,
+    protos::{
+        TaskToken,
+        coresdk::{
+            ActivityTaskCompletion, AsJsonPayloadExt, FromJsonPayloadExt,
+            activity_result::{ActivityExecutionResult, ActivityResolution},
+            activity_task::{ActivityTask, activity_task},
+            child_workflow::ChildWorkflowResult,
+            common::NamespacedWorkflowExecution,
+            nexus::NexusOperationResult,
+            workflow_activation::{
+                WorkflowActivation,
+                resolve_child_workflow_execution_start::Status as ChildWorkflowStartStatus,
+                resolve_nexus_operation_start, workflow_activation_job::Variant,
+            },
+            workflow_commands::{
+                ContinueAsNewWorkflowExecution, WorkflowCommand, workflow_command,
+            },
+            workflow_completion::WorkflowActivationCompletion,
+        },
+        temporal::api::{
+            common::v1::Payload,
+            enums::v1::WorkflowTaskFailedCause,
+            failure::v1::{Failure, failure},
         },
-        workflow_commands::{ContinueAsNewWorkflowExecution, WorkflowCommand, workflow_command},
-        workflow_completion::WorkflowActivationCompletion,
-    },
-    temporal::api::{
-        common::v1::Payload,
-        enums::v1::WorkflowTaskFailedCause,
-        failure::v1::{Failure, failure},
     },
 };
+use temporalio_sdk_core::Url;
 use tokio::{
     sync::{
         Notify,
@@ -122,14 +128,13 @@ const VERSION: &str = env!("CARGO_PKG_VERSION");
 
 /// Returns a [ClientOptionsBuilder] with required fields set to appropriate values
 /// for the Rust SDK.
-pub fn sdk_client_options(url: impl Into<Url>) -> ClientOptionsBuilder {
-    let mut builder = ClientOptionsBuilder::default();
-    builder
+pub fn sdk_client_options(
+    url: impl Into<Url>,
+) -> ClientOptionsBuilder<impl client_options_builder::IsComplete> {
+    ClientOptions::builder()
         .target_url(url)
         .client_name("temporal-rust".to_string())
-        .client_version(VERSION.to_string());
-
-    builder
+        .client_version(VERSION.to_string())
 }
 
 /// A worker that can poll for and respond to workflow tasks by using [WorkflowFunction]s,

package/sdk-core/{sdk → crates/sdk}/src/workflow_context/options.rs

@@ -1,7 +1,7 @@
 use std::{collections::HashMap, time::Duration};
 
-use temporal_client::{Priority, WorkflowOptions};
-use temporal_sdk_core_protos::{
+use temporalio_client::{Priority, WorkflowOptions};
+use temporalio_common::protos::{
     coresdk::{
         AsJsonPayloadExt,
         child_workflow::ChildWorkflowCancellationType,

package/sdk-core/{sdk → crates/sdk}/src/workflow_context.rs

@@ -28,28 +28,30 @@ use std::{
     task::Poll,
     time::{Duration, SystemTime},
 };
-use temporal_sdk_core_api::worker::WorkerDeploymentVersion;
-use temporal_sdk_core_protos::{
-    coresdk::{
-        activity_result::{ActivityResolution, activity_resolution},
-        child_workflow::ChildWorkflowResult,
-        common::NamespacedWorkflowExecution,
-        nexus::NexusOperationResult,
-        workflow_activation::{
-            InitializeWorkflow,
-            resolve_child_workflow_execution_start::Status as ChildWorkflowStartStatus,
+use temporalio_common::{
+    protos::{
+        coresdk::{
+            activity_result::{ActivityResolution, activity_resolution},
+            child_workflow::ChildWorkflowResult,
+            common::NamespacedWorkflowExecution,
+            nexus::NexusOperationResult,
+            workflow_activation::{
+                InitializeWorkflow,
+                resolve_child_workflow_execution_start::Status as ChildWorkflowStartStatus,
+            },
+            workflow_commands::{
+                CancelChildWorkflowExecution, ModifyWorkflowProperties,
+                RequestCancelExternalWorkflowExecution, SetPatchMarker,
+                SignalExternalWorkflowExecution, StartTimer, UpsertWorkflowSearchAttributes,
+                WorkflowCommand, signal_external_workflow_execution as sig_we, workflow_command,
+            },
         },
-        workflow_commands::{
-            CancelChildWorkflowExecution, ModifyWorkflowProperties,
-            RequestCancelExternalWorkflowExecution, SetPatchMarker,
-            SignalExternalWorkflowExecution, StartTimer, UpsertWorkflowSearchAttributes,
-            WorkflowCommand, signal_external_workflow_execution as sig_we, workflow_command,
+        temporal::api::{
+            common::v1::{Memo, Payload, SearchAttributes},
+            sdk::v1::UserMetadata,
         },
     },
-    temporal::api::{
-        common::v1::{Memo, Payload, SearchAttributes},
-        sdk::v1::UserMetadata,
-    },
+    worker::WorkerDeploymentVersion,
 };
 use tokio::sync::{mpsc, oneshot, watch};
 use tokio_stream::wrappers::UnboundedReceiverStream;

package/sdk-core/{sdk → crates/sdk}/src/workflow_future.rs

@@ -14,7 +14,7 @@ use std::{
     sync::mpsc::Receiver,
     task::{Context, Poll},
 };
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     coresdk::{
         workflow_activation::{
             FireTimer, InitializeWorkflow, NotifyHasPatch, ResolveActivity,