@temporalio/core-bridge 1.15.0 → 1.16.0

package/sdk-core/crates/sdk-core/src/worker/nexus.rs

@@ -1,11 +1,8 @@
 use crate::{
     abstractions::UsedMeteredSemPermit,
     pollers::{BoxedNexusPoller, NexusPollItem, new_nexus_task_poller},
-    telemetry::{
-        metrics,
-        metrics::{FailureReason, MetricsContext},
-    },
-    worker::client::WorkerClient,
+    telemetry::metrics::{self, FailureReason, MetricsContext},
+    worker::{CompleteNexusError, NexusSlotKind, PollError, client::WorkerClient},
 };
 use anyhow::anyhow;
 use futures_util::{
@@ -21,24 +18,26 @@ use std::{
     },
     time::{Duration, Instant, SystemTime},
 };
-use temporalio_common::{
-    errors::{CompleteNexusError, PollError},
-    protos::{
-        TaskToken,
-        coresdk::{
-            NexusSlotInfo,
-            nexus::{
-                CancelNexusTask, NexusTask, NexusTaskCancelReason, nexus_task,
-                nexus_task_completion,
-            },
+use temporalio_common::protos::{
+    TaskToken,
+    coresdk::{
+        NexusSlotInfo,
+        nexus::{
+            CancelNexusTask, NexusOperationErrorState, NexusTask, NexusTaskCancelReason,
+            nexus_task, nexus_task_completion,
         },
-        temporal::api::nexus::{
+    },
+    temporal::api::{
+        failure::v1::failure::FailureInfo,
+        nexus::{
             self,
-            v1::{request::Variant, response, start_operation_response},
+            v1::{
+                NexusTaskFailure, UnsuccessfulOperationError, request::Variant, response,
+                start_operation_response,
+            },
         },
-        utilities::normalize_http_headers,
     },
-    worker::NexusSlotKind,
+    utilities::normalize_http_headers,
 };
 use tokio::{
     join,
@@ -125,20 +124,78 @@ impl NexusManager {
                 .nexus_task_execution_latency(task_info.start_time.elapsed());
             task_info.timeout_task.inspect(|jh| jh.abort());
             let (did_send, maybe_net_err) = match status {
-                nexus_task_completion::Status::Completed(c) => {
+                nexus_task_completion::Status::Completed(mut c) => {
                     // Server doesn't provide obvious errors for this validation, so it's done
                     // here to make life easier for lang implementors.
-                    match &c.variant {
+                    match &mut c.variant {
                         Some(response::Variant::StartOperation(so)) => {
+                            #[allow(deprecated)]
                             if let Some(start_operation_response::Variant::OperationError(oe)) =
                                 so.variant.as_ref()
                             {
+                                // Deprecated branch left for SDKs that have not yet started using Temporal failures
                                 self.metrics
                                     .with_new_attrs([metrics::failure_reason(
                                         FailureReason::NexusOperation(oe.operation_state.clone()),
                                     )])
                                     .nexus_task_execution_failed();
-                            };
+                            } else if let Some(start_operation_response::Variant::Failure(f)) =
+                                &mut so.variant
+                            {
+                                let operation_state = match &f.failure_info {
+                                    Some(FailureInfo::ApplicationFailureInfo(_)) => {
+                                        NexusOperationErrorState::Failed
+                                    }
+                                    Some(FailureInfo::CanceledFailureInfo(_)) => {
+                                        NexusOperationErrorState::Canceled
+                                    }
+                                    _ => {
+                                        return Err(CompleteNexusError::MalformedNexusCompletion {
+                                            reason: "Nexus StartOperationResponse with a failure must contain ApplicationFailureInfo or CanceledFailureInfo"
+                                                .to_string(),
+                                        });
+                                    }
+                                };
+
+                                let use_temporal_failures = task_info
+                                    .capabilities
+                                    .as_ref()
+                                    .map(|c| c.temporal_failure_responses)
+                                    .unwrap_or_default();
+
+                                if !use_temporal_failures {
+                                    // Take the failure from the StartOperationResponse variant
+                                    let failure = std::mem::take(f);
+
+                                    // Convert the failure to an UnsuccessfulOperationError
+                                    let failure =
+                                        nexus::v1::Failure::try_from(failure)
+                                        .map_err(|err| CompleteNexusError::MalformedNexusCompletion {
+                                            reason: format!(
+                                                "error converting temporal failure to nexus failure: {:?}",
+                                                err
+                                            ),
+                                        })?;
+
+                                    // Set StartOperationResponse variant to new UnsuccessfulOperationError
+                                    so.variant = Some(
+                                        #[allow(deprecated)]
+                                        start_operation_response::Variant::OperationError(
+                                            UnsuccessfulOperationError {
+                                                operation_state: operation_state.to_string(),
+                                                failure: Some(failure),
+                                            },
+                                        ),
+                                    )
+                                }
+
+                                self.metrics
+                                    .with_new_attrs([metrics::failure_reason(
+                                        FailureReason::NexusOperation(operation_state.to_string()),
+                                    )])
+                                    .nexus_task_execution_failed();
+                            }
+
                             if task_info.request_kind != RequestKind::Start {
                                 return Err(CompleteNexusError::MalformedNexusCompletion {
                                     reason: "Nexus response was StartOperation but request was not"
@@ -164,19 +221,76 @@ impl NexusManager {
                     }
                     (true, client.complete_nexus_task(tt, c).await.err())
                 }
+
                 nexus_task_completion::Status::AckCancel(_) => {
                     self.metrics
                         .with_new_attrs([metrics::failure_reason(FailureReason::Timeout)])
                         .nexus_task_execution_failed();
                     (false, None)
                 }
+
+                #[allow(deprecated)]
                 nexus_task_completion::Status::Error(e) => {
+                    // Deprecated branch left for SDKs that have not yet started using Temporal failures
                     self.metrics
                         .with_new_attrs([metrics::failure_reason(
                             FailureReason::NexusHandlerError(e.error_type.clone()),
                         )])
                         .nexus_task_execution_failed();
-                    (true, client.fail_nexus_task(tt, e).await.err())
+                    let maybe_net_err = client
+                        .fail_nexus_task(tt, NexusTaskFailure::Legacy(e))
+                        .await
+                        .err();
+                    (true, maybe_net_err)
+                }
+
+                nexus_task_completion::Status::Failure(f) => {
+                    let use_temporal_failures = task_info
+                        .capabilities
+                        .as_ref()
+                        .map(|c| c.temporal_failure_responses)
+                        .unwrap_or_default();
+
+                    let failure_info = match &f.failure_info {
+                        Some(FailureInfo::NexusHandlerFailureInfo(failure_info)) => {
+                            failure_info.clone()
+                        }
+                        _ => {
+                            return Err(CompleteNexusError::MalformedNexusCompletion {
+                            reason: "Nexus completions with a failure must contain a NexusHandlerFailureInfo".to_string(),
+                        });
+                        }
+                    };
+
+                    self.metrics
+                        .with_new_attrs([metrics::failure_reason(
+                            FailureReason::NexusHandlerError(failure_info.r#type.clone()),
+                        )])
+                        .nexus_task_execution_failed();
+
+                    let task_failure = if use_temporal_failures {
+                        NexusTaskFailure::Temporal(f)
+                    } else {
+                        let failure = nexus::v1::Failure::try_from(f).map_err(|err| {
+                            CompleteNexusError::MalformedNexusCompletion {
+                                reason: format!(
+                                    "error converting temporal failure to nexus failure: {:?}",
+                                    err
+                                ),
+                            }
+                        })?;
+
+                        let h = nexus::v1::HandlerError {
+                            error_type: failure_info.r#type,
+                            failure: Some(failure),
+                            //NexusHandlerFailureInfo and HandlerError both use enums::v1::NexusHandlerErrorRetryBehavior
+                            retry_behavior: failure_info.retry_behavior,
+                        };
+                        NexusTaskFailure::Legacy(h)
+                    };
+
+                    let maybe_net_err = client.fail_nexus_task(tt, task_failure).await.err();
+                    (true, maybe_net_err)
                 }
             };
 
@@ -317,6 +431,12 @@ where
                                     ),
                                 })
                                 .unwrap_or_default();
+
+                            let capabilities = t
+                                .resp
+                                .request
+                                .as_ref()
+                                .and_then(|r| r.capabilities);
                             self.outstanding_task_map.lock().insert(
                                 tt,
                                 NexusInFlightTask {
@@ -330,6 +450,7 @@ where
                                         .and_then(|t| t.try_into().ok()),
                                     start_time: Instant::now(),
                                     _permit: t.permit.into_used(NexusSlotInfo { service, operation }),
+                                    capabilities,
                                 },
                             );
                             Some(Ok(NexusTask {
@@ -387,6 +508,7 @@ struct NexusInFlightTask {
     scheduled_time: Option<SystemTime>,
     start_time: Instant,
     _permit: UsedMeteredSemPermit<NexusSlotKind>,
+    capabilities: Option<nexus::v1::request::Capabilities>,
 }
 
 #[derive(Eq, PartialEq, Copy, Clone, Default)]

package/sdk-core/crates/sdk-core/src/worker/slot_provider.rs

@@ -5,12 +5,12 @@
 use crate::{
     abstractions::{MeteredPermitDealer, OwnedMeteredSemPermit},
     protosext::ValidPollWFTQResponse,
-    worker::workflow::wft_poller::validate_wft,
+    worker::{WorkflowSlotKind, workflow::wft_poller::validate_wft},
 };
 use temporalio_client::worker::Slot as SlotTrait;
 use temporalio_common::{
     protos::temporal::api::workflowservice::v1::PollWorkflowTaskQueueResponse,
-    worker::{WorkerDeploymentOptions, WorkflowSlotKind},
+    worker::WorkerDeploymentOptions,
 };
 use tokio::sync::mpsc::UnboundedSender;
 use tonic::Status;

package/sdk-core/crates/sdk-core/src/worker/tuner/fixed_size.rs

@@ -1,8 +1,8 @@
-use std::{marker::PhantomData, sync::Arc};
-use temporalio_common::worker::{
+use crate::worker::{
     SlotKind, SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext, SlotSupplier,
     SlotSupplierPermit,
 };
+use std::{marker::PhantomData, sync::Arc};
 use tokio::sync::Semaphore;
 
 /// Implements [SlotSupplier] with a fixed number of slots

package/sdk-core/crates/sdk-core/src/worker/tuner/resource_based.rs

@@ -1,3 +1,8 @@
+use crate::worker::{
+    ActivitySlotKind, LocalActivitySlotKind, NexusSlotKind, SlotInfo, SlotInfoTrait, SlotKind,
+    SlotKindType, SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext, SlotSupplier,
+    SlotSupplierPermit, WorkerTuner, WorkflowSlotKind,
+};
 use crossbeam_utils::atomic::AtomicCell;
 use parking_lot::Mutex;
 use std::{
@@ -12,18 +17,11 @@ use std::{
     thread,
     time::{Duration, Instant},
 };
-use temporalio_common::{
-    telemetry::metrics::{CoreMeter, GaugeF64, MetricAttributes, TemporalMeter},
-    worker::{
-        ActivitySlotKind, LocalActivitySlotKind, NexusSlotKind, SlotInfo, SlotInfoTrait, SlotKind,
-        SlotKindType, SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext,
-        SlotSupplier, SlotSupplierPermit, WorkerTuner, WorkflowSlotKind,
-    },
-};
+use temporalio_common::telemetry::metrics::{GaugeF64, MetricAttributes, TemporalMeter};
 use tokio::{sync::watch, task::JoinHandle};
 
-/// Implements [WorkerTuner] and attempts to maintain certain levels of resource usage when
-/// under load.
+/// Implements [crate::worker::WorkerTuner] and attempts to maintain certain levels of resource
+/// usage when under load.
 ///
 /// It does so by using two PID controllers, one for memory and one for CPU, which are fed the
 /// current usage levels of their respective resource as measurements. The user specifies a target
@@ -236,7 +234,7 @@ impl MetricInstruments {
         let cpu_usage = meter.gauge_f64("resource_slots_cpu_usage".into());
         let mem_pid_output = meter.gauge_f64("resource_slots_mem_pid_output".into());
         let cpu_pid_output = meter.gauge_f64("resource_slots_cpu_pid_output".into());
-        let attribs = meter.inner.new_attributes(meter.default_attribs);
+        let attribs = meter.get_default_attributes().clone();
         Self {
             attribs,
             mem_usage,
@@ -726,7 +724,10 @@ impl CGroupCpuFileSystem for CgroupV2CpuFileSystem {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{abstractions::MeteredPermitDealer, telemetry::metrics::MetricsContext};
+    use crate::{
+        abstractions::MeteredPermitDealer, telemetry::metrics::MetricsContext,
+        worker::WorkflowSlotKind,
+    };
     use std::{
         cell::RefCell,
         env,
@@ -738,7 +739,6 @@ mod tests {
         },
         thread::sleep,
     };
-    use temporalio_common::worker::WorkflowSlotKind;
 
     struct FakeMIS {
         used: Arc<AtomicU64>,

package/sdk-core/crates/sdk-core/src/worker/tuner.rs

@@ -9,13 +9,16 @@ pub use resource_based::{
 
 pub(crate) use resource_based::{RealSysInfo, SystemResourceInfo};
 
-use std::sync::Arc;
-use temporalio_common::worker::{
-    ActivitySlotKind, LocalActivitySlotKind, NexusSlotKind, SlotKind, SlotSupplier, WorkerConfig,
-    WorkerTuner, WorkflowSlotKind,
+use crate::{
+    WorkerConfig,
+    worker::{
+        ActivitySlotKind, LocalActivitySlotKind, NexusSlotKind, SlotKind, SlotSupplier,
+        WorkerTuner, WorkflowSlotKind,
+    },
 };
+use std::sync::Arc;
 
-/// Allows for the composition of different slot suppliers into a [WorkerTuner]
+/// Allows for the composition of different slot suppliers into a [crate::WorkerTuner]
 pub struct TunerHolder {
     wft_supplier: Arc<dyn SlotSupplier<SlotKind = WorkflowSlotKind> + Send + Sync>,
     act_supplier: Arc<dyn SlotSupplier<SlotKind = ActivitySlotKind> + Send + Sync>,
@@ -23,6 +26,23 @@ pub struct TunerHolder {
     nexus_supplier: Arc<dyn SlotSupplier<SlotKind = NexusSlotKind> + Send + Sync>,
 }
 
+impl TunerHolder {
+    /// Create a tuner with fixed size slot suppliers for all slot kinds.
+    pub fn fixed_size(
+        workflow_slots: usize,
+        activity_slots: usize,
+        local_activity_slots: usize,
+        nexus_slots: usize,
+    ) -> Self {
+        Self {
+            wft_supplier: Arc::new(FixedSizeSlotSupplier::new(workflow_slots)),
+            act_supplier: Arc::new(FixedSizeSlotSupplier::new(activity_slots)),
+            la_supplier: Arc::new(FixedSizeSlotSupplier::new(local_activity_slots)),
+            nexus_supplier: Arc::new(FixedSizeSlotSupplier::new(nexus_slots)),
+        }
+    }
+}
+
 /// Can be used to construct a [TunerHolder] without needing to manually construct each
 /// [SlotSupplier]. Useful for lang bridges to allow more easily passing through user options.
 #[derive(Clone, Debug, bon::Builder)]
@@ -262,7 +282,7 @@ impl TunerBuilder {
         self.sys_info.clone()
     }
 
-    /// Build a [WorkerTuner] from the configured slot suppliers
+    /// Build a [crate::WorkerTuner] from the configured slot suppliers
     pub fn build(&mut self) -> TunerHolder {
         TunerHolder {
             wft_supplier: self
@@ -314,10 +334,10 @@ impl WorkerTuner for TunerHolder {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::time::Duration;
-    use temporalio_common::worker::{
+    use crate::worker::{
         SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext, SlotSupplierPermit,
     };
+    use std::time::Duration;
 
     struct TestSlotSupplier;
     #[async_trait::async_trait]

package/sdk-core/crates/sdk-core/src/worker/workflow/driven_workflow.rs

@@ -9,7 +9,10 @@ use std::{
 };
 use temporalio_common::protos::{
     coresdk::workflow_activation::{WorkflowActivationJob, start_workflow_from_attribs},
-    temporal::api::{common::v1::Payload, history::v1::WorkflowExecutionStartedEventAttributes},
+    temporal::api::{
+        common::v1::{Payload, SearchAttributes},
+        history::v1::WorkflowExecutionStartedEventAttributes,
+    },
     utilities::TryIntoOrNone,
 };
 
@@ -97,8 +100,11 @@ impl DrivenWorkflow {
     }
 
     /// Lang sent us an SA upsert command - use it to update our current view of search attributes.
-    pub(crate) fn search_attributes_update(&mut self, update: HashMap<String, Payload>) {
-        self.search_attribute_modifications.extend(update);
+    pub(crate) fn search_attributes_update(&mut self, update: Option<SearchAttributes>) {
+        if let Some(sa) = update {
+            self.search_attribute_modifications
+                .extend(sa.indexed_fields);
+        }
     }
 
     /// Return a view of the "current" state of search attributes. IE: The initial attributes

package/sdk-core/crates/sdk-core/src/worker/workflow/machines/upsert_search_attributes_state_machine.rs

@@ -50,11 +50,11 @@ pub(super) fn upsert_search_attrs(
     let has_flag = internal_flags
         .borrow_mut()
         .try_use(CoreInternalFlags::UpsertSearchAttributeOnPatch, !replaying);
-    if has_flag
-        && attribs
-            .search_attributes
-            .contains_key(VERSION_SEARCH_ATTR_KEY)
-    {
+    let contains_version_key = attribs
+        .search_attributes
+        .as_ref()
+        .is_some_and(|sa| sa.indexed_fields.contains_key(VERSION_SEARCH_ATTR_KEY));
+    if has_flag && contains_version_key {
         warn!(
             "Upserting the {VERSION_SEARCH_ATTR_KEY} search attribute directly from workflow code \
              is not permitted and has no effect!"
@@ -63,7 +63,7 @@ pub(super) fn upsert_search_attrs(
         // this.
         create_new(Default::default())
     } else {
-        create_new(attribs.search_attributes.into())
+        create_new(attribs.search_attributes.unwrap_or_default())
     }
 }
 
@@ -186,21 +186,18 @@ mod tests {
         worker::client::mocks::mock_worker_client,
     };
     use std::collections::HashMap;
-    use temporalio_common::{
-        Worker,
-        protos::{
-            coresdk::{
-                AsJsonPayloadExt,
-                workflow_activation::{WorkflowActivationJob, workflow_activation_job},
-                workflow_commands::SetPatchMarker,
-                workflow_completion::WorkflowActivationCompletion,
-            },
-            temporal::api::{
-                command::v1::command::Attributes,
-                common::v1::Payload,
-                enums::v1::EventType,
-                history::v1::{HistoryEvent, UpsertWorkflowSearchAttributesEventAttributes},
-            },
+    use temporalio_common::protos::{
+        coresdk::{
+            AsJsonPayloadExt,
+            workflow_activation::{WorkflowActivationJob, workflow_activation_job},
+            workflow_commands::SetPatchMarker,
+            workflow_completion::WorkflowActivationCompletion,
+        },
+        temporal::api::{
+            command::v1::command::Attributes,
+            common::v1::Payload,
+            enums::v1::EventType,
+            history::v1::{HistoryEvent, UpsertWorkflowSearchAttributesEventAttributes},
         },
     };
 
@@ -318,7 +315,9 @@ mod tests {
         };
         cmds.push(
             UpsertWorkflowSearchAttributes {
-                search_attributes: ver_upsert,
+                search_attributes: Some(SearchAttributes {
+                    indexed_fields: ver_upsert,
+                }),
             }
             .into(),
         );

package/sdk-core/crates/sdk-core/src/worker/workflow/machines/workflow_machines.rs

@@ -13,6 +13,7 @@ use super::{
     workflow_task_state_machine::WorkflowTaskMachine,
 };
 use crate::{
+    WorkerConfig,
     abstractions::dbg_panic,
     internal_flags::{CoreInternalFlags, InternalFlags},
     protosext::{
@@ -66,13 +67,14 @@ use temporalio_common::{
             command::v1::{
                 Command as ProtoCommand, CommandAttributesExt, command::Attributes as ProtoCmdAttrs,
             },
+            common::v1::SearchAttributes,
             enums::v1::EventType,
             history::v1::{HistoryEvent, history_event},
             protocol::v1::{Message as ProtocolMessage, message::SequencingId},
             sdk::v1::{UserMetadata, WorkflowTaskCompletedMetadata},
         },
     },
-    worker::{WorkerConfig, WorkerDeploymentVersion},
+    worker::WorkerDeploymentVersion,
 };
 
 type Result<T, E = WFMachinesError> = std::result::Result<T, E>;
@@ -128,6 +130,8 @@ pub(crate) struct WorkflowMachines {
     continue_as_new_suggested: bool,
     /// Set on each WFT started event
     suggest_continue_as_new_reasons: Vec<i32>,
+    /// Set on each WFT started event
+    target_worker_deployment_version_changed: bool,
     /// Set if the current WFT is already complete and that completion event had legacy build-id
     /// or a deployment version in it. Will use an empty deployment name if it's legacy build-id.
     current_wft_deployment_info: Option<WorkerDeploymentVersion>,
@@ -293,6 +297,7 @@ impl WorkflowMachines {
             history_size_bytes: 0,
             continue_as_new_suggested: false,
             suggest_continue_as_new_reasons: Default::default(),
+            target_worker_deployment_version_changed: false,
             current_wft_deployment_info: None,
             all_machines: Default::default(),
             machine_is_core_created: Default::default(),
@@ -475,6 +480,7 @@ impl WorkflowMachines {
                 .unwrap_or_default()
                 .to_owned(),
             suggest_continue_as_new_reasons: self.suggest_continue_as_new_reasons.clone(),
+            target_worker_deployment_version_changed: self.target_worker_deployment_version_changed,
         }
     }
 
@@ -896,6 +902,8 @@ impl WorkflowMachines {
             self.history_size_bytes = u64::try_from(attrs.history_size_bytes).unwrap_or_default();
             self.continue_as_new_suggested = attrs.suggest_continue_as_new;
             self.suggest_continue_as_new_reasons = attrs.suggest_continue_as_new_reasons.clone();
+            self.target_worker_deployment_version_changed =
+                attrs.target_worker_deployment_version_changed;
         }
 
         if let Some(initial_cmd_id) = event.get_initial_command_event_id() {
@@ -1648,8 +1656,13 @@ impl WorkflowMachines {
                 attrs.retry_policy.clone_from(&started_info.retry_policy);
             }
         }
-        if attrs.search_attributes.is_empty() {
-            attrs.search_attributes = self.drive_me.get_current_search_attributes();
+        if attrs.search_attributes.is_none() {
+            let current = self.drive_me.get_current_search_attributes();
+            if !current.is_empty() {
+                attrs.search_attributes = Some(SearchAttributes {
+                    indexed_fields: current,
+                });
+            }
         }
         attrs
     }

package/sdk-core/crates/sdk-core/src/worker/workflow/managed_run.rs

@@ -1,11 +1,11 @@
 use crate::{
-    MetricsContext,
+    MetricsContext, WorkerConfig,
     abstractions::dbg_panic,
     internal_flags::CoreInternalFlags,
     protosext::{WorkflowActivationExt, protocol_messages::IncomingProtocolMessage},
     telemetry::metrics,
     worker::{
-        LEGACY_QUERY_ID, LocalActRequest,
+        LEGACY_QUERY_ID, LocalActRequest, WorkflowErrorType,
         workflow::{
             ActivationAction, ActivationCompleteOutcome, ActivationCompleteResult,
             ActivationOrAuto, BufferedTasks, DrivenWorkflow, EvictionRequestResult,
@@ -28,24 +28,20 @@ use std::{
     sync::{Arc, mpsc::Sender},
     time::{Duration, Instant},
 };
-use temporalio_common::{
-    errors::WorkflowErrorType,
-    protos::{
-        TaskToken,
-        coresdk::{
-            workflow_activation::{
-                WorkflowActivation, create_evict_activation, query_to_job,
-                remove_from_cache::EvictionReason, workflow_activation_job,
-            },
-            workflow_commands::{FailWorkflowExecution, QueryResult},
-            workflow_completion,
-        },
-        temporal::api::{
-            enums::v1::{VersioningBehavior, WorkflowTaskFailedCause},
-            failure::v1::Failure,
+use temporalio_common::protos::{
+    TaskToken,
+    coresdk::{
+        workflow_activation::{
+            WorkflowActivation, create_evict_activation, query_to_job,
+            remove_from_cache::EvictionReason, workflow_activation_job,
         },
+        workflow_commands::{FailWorkflowExecution, QueryResult},
+        workflow_completion,
+    },
+    temporal::api::{
+        enums::v1::{VersioningBehavior, WorkflowTaskFailedCause},
+        failure::v1::Failure,
     },
-    worker::WorkerConfig,
 };
 use tokio::sync::oneshot;
 use tracing::Span;

package/sdk-core/crates/sdk-core/src/worker/workflow/mod.rs

@@ -15,7 +15,7 @@ pub(crate) use driven_workflow::DrivenWorkflow;
 pub(crate) use history_update::HistoryUpdate;
 
 use crate::{
-    MetricsContext,
+    MetricsContext, WorkerConfig,
     abstractions::{
         MeteredPermitDealer, TrackedOwnedMeteredSemPermit, UsedMeteredSemPermit, dbg_panic,
         take_cell::TakeCell,
@@ -26,11 +26,10 @@ use crate::{
     telemetry::{
         VecDisplayer,
         metrics::{self, FailureReason},
-        set_trace_subscriber_for_current_thread,
     },
     worker::{
-        LocalActRequest, LocalActivityExecutionResult, LocalActivityResolution,
-        PostActivateHookData,
+        ActivitySlotKind, CompleteWfError, LocalActRequest, LocalActivityExecutionResult,
+        LocalActivityResolution, PollError, PostActivateHookData, WorkflowSlotKind,
         activities::{ActivitiesFromWFTsHandle, LocalActivityManager},
         client::{LegacyQueryResult, WorkerClient, WorkflowTaskCompletion},
         workflow::{
@@ -61,7 +60,6 @@ use std::{
 };
 use temporalio_client::MESSAGE_TOO_LARGE_KEY;
 use temporalio_common::{
-    errors::{CompleteWfError, PollError},
     protos::{
         TaskToken,
         coresdk::{
@@ -88,7 +86,7 @@ use temporalio_common::{
             workflowservice::v1::{PollActivityTaskQueueResponse, get_system_info_response},
         },
     },
-    worker::{ActivitySlotKind, WorkerConfig, WorkflowSlotKind},
+    telemetry::set_trace_subscriber_for_current_thread,
 };
 use tokio::{
     sync::{