@temporalio/core-bridge 1.14.2-canary-release-testing.0 → 1.16.0

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

@@ -1,17 +1,15 @@
 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::{
     Stream, StreamExt, stream,
     stream::{BoxStream, PollNext},
 };
+use prost_types::Timestamp;
 use std::{
     collections::HashMap,
     sync::{
@@ -20,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,
@@ -124,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"
@@ -163,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)
                 }
             };
 
@@ -264,6 +379,7 @@ where
 
                             let tt = TaskToken(t.resp.task_token.clone());
                             let mut timeout_task = None;
+                            let mut request_deadline: Option<Timestamp> = None;
                             if let Some(timeout_str) = t
                                 .resp
                                 .request
@@ -271,6 +387,7 @@ where
                                 .and_then(|r| r.header.get(REQUEST_TIMEOUT_HEADER))
                             {
                                 if let Ok(timeout_dur) = parse_request_timeout(timeout_str) {
+                                    request_deadline = Some((SystemTime::now() + timeout_dur).into());
                                     let tt_clone = tt.clone();
                                     let cancels_tx = self.cancels_tx.clone();
                                     timeout_task = Some(tokio::task::spawn(async move {
@@ -314,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 {
@@ -327,16 +450,19 @@ where
                                         .and_then(|t| t.try_into().ok()),
                                     start_time: Instant::now(),
                                     _permit: t.permit.into_used(NexusSlotInfo { service, operation }),
+                                    capabilities,
                                 },
                             );
                             Some(Ok(NexusTask {
                                 variant: Some(nexus_task::Variant::Task(t.resp)),
+                                request_deadline,
                             }))
                         },
                         Err(e) => Some(Err(PollError::TonicError(e)))
                     },
                     TaskStreamInput::Cancel(c) => Some(Ok(NexusTask {
                         variant: Some(nexus_task::Variant::CancelTask(c)),
+                        request_deadline: None,
                     })),
                     TaskStreamInput::SourceComplete => {
                         source_done.cancel();
@@ -382,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
@@ -43,11 +41,10 @@ impl ResourceBasedTuner<RealSysInfo> {
     /// Create an instance attempting to target the provided memory and cpu thresholds as values
     /// between 0 and 1.
     pub fn new(target_mem_usage: f64, target_cpu_usage: f64) -> Self {
-        let opts = ResourceBasedSlotsOptionsBuilder::default()
+        let opts = ResourceBasedSlotsOptions::builder()
             .target_mem_usage(target_mem_usage)
             .target_cpu_usage(target_cpu_usage)
-            .build()
-            .expect("default resource based slot options can't fail to build");
+            .build();
         let controller = ResourceController::new_with_sysinfo(opts, Arc::new(RealSysInfo::new()));
         Self::new_from_controller(controller)
     }
@@ -163,7 +160,7 @@ pub(crate) struct ResourceBasedSlotsForType<MI, SK> {
     _slot_kind: PhantomData<SK>,
 }
 /// Allows for the full customization of the PID options for a resource based tuner
-#[derive(Clone, Debug, derive_builder::Builder)]
+#[derive(Clone, Debug, bon::Builder)]
 #[non_exhaustive]
 pub struct ResourceBasedSlotsOptions {
     /// A value in the range [0.0, 1.0] representing the target memory usage.
@@ -172,30 +169,30 @@ pub struct ResourceBasedSlotsOptions {
     pub target_cpu_usage: f64,
 
     /// See [pid::Pid::p]
-    #[builder(default = "5.0")]
+    #[builder(default = 5.0)]
     pub mem_p_gain: f64,
     /// See [pid::Pid::i]
-    #[builder(default = "0.0")]
+    #[builder(default = 0.0)]
     pub mem_i_gain: f64,
     /// See [pid::Pid::d]
-    #[builder(default = "1.0")]
+    #[builder(default = 1.0)]
     pub mem_d_gain: f64,
     /// If the mem PID controller outputs a value higher than this, we say the mem half of things
     /// will allow a slot
-    #[builder(default = "0.25")]
+    #[builder(default = 0.25)]
     pub mem_output_threshold: f64,
     /// See [pid::Pid::d]
-    #[builder(default = "5.0")]
+    #[builder(default = 5.0)]
     pub cpu_p_gain: f64,
     /// See [pid::Pid::i]
-    #[builder(default = "0.0")]
+    #[builder(default = 0.0)]
     pub cpu_i_gain: f64,
     /// See [pid::Pid::d]
-    #[builder(default = "1.0")]
+    #[builder(default = 1.0)]
     pub cpu_d_gain: f64,
     /// If the CPU PID controller outputs a value higher than this, we say the CPU half of things
     /// will allow a slot
-    #[builder(default = "0.05")]
+    #[builder(default = 0.05)]
     pub cpu_output_threshold: f64,
 }
 struct PidControllers {
@@ -237,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,
@@ -727,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,
@@ -739,7 +739,6 @@ mod tests {
         },
         thread::sleep,
     };
-    use temporalio_common::worker::WorkflowSlotKind;
 
     struct FakeMIS {
         used: Arc<AtomicU64>,
@@ -765,11 +764,10 @@ mod tests {
     }
 
     fn test_options() -> ResourceBasedSlotsOptions {
-        ResourceBasedSlotsOptionsBuilder::default()
+        ResourceBasedSlotsOptions::builder()
             .target_mem_usage(0.8)
             .target_cpu_usage(1.0)
             .build()
-            .expect("default resource based slot options can't fail to build")
     }
 
     #[test]

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,27 +26,39 @@ 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, derive_builder::Builder)]
-#[builder(build_fn(validate = "Self::validate"))]
+#[derive(Clone, Debug, bon::Builder)]
+#[builder(finish_fn(vis = "", name = build_internal))]
 #[non_exhaustive]
 pub struct TunerHolderOptions {
     /// Options for workflow slots
-    #[builder(default, setter(strip_option))]
     pub workflow_slot_options: Option<SlotSupplierOptions<WorkflowSlotKind>>,
     /// Options for activity slots
-    #[builder(default, setter(strip_option))]
     pub activity_slot_options: Option<SlotSupplierOptions<ActivitySlotKind>>,
     /// Options for local activity slots
-    #[builder(default, setter(strip_option))]
     pub local_activity_slot_options: Option<SlotSupplierOptions<LocalActivitySlotKind>>,
     /// Options for nexus slots
-    #[builder(default, setter(strip_option))]
     pub nexus_slot_options: Option<SlotSupplierOptions<NexusSlotKind>>,
     /// Options that will apply to all resource based slot suppliers. Must be set if any slot
     /// options are [SlotSupplierOptions::ResourceBased]
-    #[builder(default, setter(strip_option))]
     pub resource_based_options: Option<ResourceBasedSlotsOptions>,
 }
 
@@ -150,35 +165,42 @@ pub enum SlotSupplierOptions<SK: SlotKind> {
     Custom(Arc<dyn SlotSupplier<SlotKind = SK> + Send + Sync>),
 }
 
-impl TunerHolderOptionsBuilder {
+impl<State: tuner_holder_options_builder::IsComplete> TunerHolderOptionsBuilder<State> {
+    /// Build the [TunerHolderOptions] with validation
+    pub fn build(self) -> Result<TunerHolderOptions, String> {
+        let options = self.build_internal();
+        validate_tuner_holder_options(&options)?;
+        Ok(options)
+    }
+
     /// Create a [TunerHolder] from this builder
     pub fn build_tuner_holder(self) -> Result<TunerHolder, anyhow::Error> {
-        let s = self.build()?;
+        let s = self.build().map_err(|e: String| anyhow::anyhow!(e))?;
         s.build_tuner_holder()
     }
+}
 
-    fn validate(&self) -> Result<(), String> {
-        let any_is_resource_based = matches!(
-            self.workflow_slot_options,
-            Some(Some(SlotSupplierOptions::ResourceBased(_)))
-        ) || matches!(
-            self.activity_slot_options,
-            Some(Some(SlotSupplierOptions::ResourceBased(_)))
-        ) || matches!(
-            self.local_activity_slot_options,
-            Some(Some(SlotSupplierOptions::ResourceBased(_)))
-        ) || matches!(
-            self.nexus_slot_options,
-            Some(Some(SlotSupplierOptions::ResourceBased(_)))
+fn validate_tuner_holder_options(options: &TunerHolderOptions) -> Result<(), String> {
+    let any_is_resource_based = matches!(
+        options.workflow_slot_options,
+        Some(SlotSupplierOptions::ResourceBased(_))
+    ) || matches!(
+        options.activity_slot_options,
+        Some(SlotSupplierOptions::ResourceBased(_))
+    ) || matches!(
+        options.local_activity_slot_options,
+        Some(SlotSupplierOptions::ResourceBased(_))
+    ) || matches!(
+        options.nexus_slot_options,
+        Some(SlotSupplierOptions::ResourceBased(_))
+    );
+    if any_is_resource_based && options.resource_based_options.is_none() {
+        return Err(
+            "`resource_based_options` must be set if any slot options are ResourceBased"
+                .to_string(),
         );
-        if any_is_resource_based && matches!(self.resource_based_options, None | Some(None)) {
-            return Err(
-                "`resource_based_options` must be set if any slot options are ResourceBased"
-                    .to_string(),
-            );
-        }
-        Ok(())
     }
+    Ok(())
 }
 
 /// Can be used to construct a `TunerHolder` from individual slot suppliers. Any supplier which is
@@ -260,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
@@ -312,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]
@@ -348,11 +370,10 @@ mod tests {
 
     #[test]
     fn tuner_holder_options_nexus_resource_based() {
-        let resource_opts = ResourceBasedSlotsOptionsBuilder::default()
+        let resource_opts = ResourceBasedSlotsOptions::builder()
             .target_mem_usage(0.8)
             .target_cpu_usage(0.9)
-            .build()
-            .unwrap();
+            .build();
 
         let options = TunerHolderOptions {
             workflow_slot_options: None,
@@ -403,7 +424,7 @@ mod tests {
     #[test]
     fn tuner_holder_options_builder_validates_resource_based_requirements() {
         // Should fail when nexus uses ResourceBased but resource_based_options is not set
-        let result = TunerHolderOptionsBuilder::default()
+        let result = TunerHolderOptions::builder()
             .nexus_slot_options(SlotSupplierOptions::ResourceBased(
                 ResourceSlotOptions::new(5, 100, Duration::from_millis(100)),
             ))
@@ -420,11 +441,10 @@ mod tests {
 
     #[test]
     fn tuner_holder_options_all_slot_types() {
-        let resource_opts = ResourceBasedSlotsOptionsBuilder::default()
+        let resource_opts = ResourceBasedSlotsOptions::builder()
             .target_mem_usage(0.8)
             .target_cpu_usage(0.9)
-            .build()
-            .unwrap();
+            .build();
 
         let options = TunerHolderOptions {
             workflow_slot_options: Some(SlotSupplierOptions::FixedSize { slots: 10 }),

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