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

package/sdk-core/crates/sdk-core-c-bridge/src/tests/mod.rs

@@ -1,5 +1,5 @@
 use crate::{
-    ByteArrayRef,
+    ByteArrayRef, ByteArrayRefArray,
     client::{
         ClientGrpcOverrideRequest, ClientGrpcOverrideResponse, RpcService,
         temporal_core_client_grpc_override_request_headers,
@@ -9,12 +9,16 @@ use crate::{
         temporal_core_client_grpc_override_request_service,
     },
     tests::utils::{
-        OwnedRpcCallOptions, RpcCallError, default_client_options, default_server_config,
+        OwnedRpcCallOptions, RpcCallError, default_connection_options, default_server_config,
     },
 };
+use base64::{Engine, engine::general_purpose::STANDARD_NO_PAD};
 use context::Context;
 use prost::Message;
-use std::sync::{Arc, LazyLock, Mutex};
+use std::{
+    collections::HashMap,
+    sync::{Arc, LazyLock, Mutex},
+};
 use temporalio_common::protos::temporal::api::{
     failure::v1::Failure,
     workflowservice::v1::{
@@ -34,7 +38,7 @@ fn test_get_system_info() {
             .start_dev_server(Box::new(default_server_config()))
             .unwrap();
         context
-            .client_connect(Box::new(default_client_options(
+            .client_connect(Box::new(default_connection_options(
                 &context.ephemeral_server_target().unwrap().unwrap(),
             )))
             .unwrap();
@@ -46,6 +50,7 @@ fn test_get_system_info() {
                     req: GetSystemInfoRequest {}.encode_to_vec(),
                     retry: false,
                     metadata: None,
+                    binary_metadata: None,
                     timeout_millis: 0,
                     cancellation_token: None,
                 }))
@@ -62,6 +67,7 @@ fn rpc_call_exists(context: &Arc<Context>, service: RpcService, rpc: &str) -> bo
         req: Vec::new(),
         retry: false,
         metadata: None,
+        binary_metadata: None,
         timeout_millis: 0,
         cancellation_token: None,
     }));
@@ -82,7 +88,7 @@ fn test_missing_rpc_call_has_expected_error_message() {
             .start_dev_server(Box::new(default_server_config()))
             .unwrap();
         context
-            .client_connect(Box::new(default_client_options(
+            .client_connect(Box::new(default_connection_options(
                 &context.ephemeral_server_target().unwrap().unwrap(),
             )))
             .unwrap();
@@ -146,7 +152,7 @@ fn test_all_rpc_calls_exist() {
             .start_dev_server(Box::new(default_server_config()))
             .unwrap();
         context
-            .client_connect(Box::new(default_client_options(
+            .client_connect(Box::new(default_connection_options(
                 &context.ephemeral_server_target().unwrap().unwrap(),
             )))
             .unwrap();
@@ -215,9 +221,8 @@ unsafe extern "C" fn callback_override(
     let mut calls = CALLBACK_OVERRIDE_CALLS.lock().unwrap();
 
     // Simple header check to confirm headers are working
-    let headers =
-        temporal_core_client_grpc_override_request_headers(req).to_string_map_on_newlines();
-    assert!(headers.get("content-type").unwrap().as_str() == "application/grpc");
+    let headers = temporal_core_client_grpc_override_request_headers(req).to_vec_map_on_newlines();
+    assert_ascii_header_value(&headers, "content-type", "application/grpc");
 
     // Confirm user data is as we expect
     let user_data: &String = unsafe { &*(user_data as *const String) };
@@ -265,14 +270,14 @@ unsafe extern "C" fn callback_override(
     let resp = match &resp_raw {
         Ok(bytes) => ClientGrpcOverrideResponse {
             status_code: 0,
-            headers: ByteArrayRef::empty(),
+            headers: ByteArrayRefArray::empty(),
             success_proto: bytes.as_slice().into(),
             fail_message: ByteArrayRef::empty(),
             fail_details: ByteArrayRef::empty(),
         },
         Err(err) => ClientGrpcOverrideResponse {
             status_code: tonic::Code::Internal.into(),
-            headers: ByteArrayRef::empty(),
+            headers: ByteArrayRefArray::empty(),
             success_proto: ByteArrayRef::empty(),
             fail_message: err.message.as_str().into(),
             fail_details: if let Some(details) = &err.details {
@@ -294,7 +299,7 @@ fn test_simple_callback_override() {
         // Create client which will invoke GetSystemInfo
         context
             .client_connect_with_override(
-                Box::new(default_client_options("127.0.0.1:4567")),
+                Box::new(default_connection_options("127.0.0.1:4567")),
                 Some(callback_override),
                 &mut user_data as *mut String as *mut libc::c_void,
             )
@@ -312,6 +317,7 @@ fn test_simple_callback_override() {
                 .encode_to_vec(),
                 retry: false,
                 metadata: None,
+                binary_metadata: None,
                 timeout_millis: 0,
                 cancellation_token: None,
             }))
@@ -330,6 +336,7 @@ fn test_simple_callback_override() {
                 req: QueryWorkflowRequest::default().encode_to_vec(),
                 retry: false,
                 metadata: None,
+                binary_metadata: None,
                 timeout_millis: 0,
                 cancellation_token: None,
             }))
@@ -356,3 +363,92 @@ fn test_simple_callback_override() {
         );
     });
 }
+
+unsafe extern "C" fn headers_callback_override(
+    req: *mut ClientGrpcOverrideRequest,
+    _user_data: *mut libc::c_void,
+) {
+    // Check headers
+    let headers = temporal_core_client_grpc_override_request_headers(req).to_vec_map_on_newlines();
+    assert_ascii_header_value(&headers, "content-type", "application/grpc");
+    assert_ascii_header_value(&headers, "x-test", "client-ascii");
+    assert_binary_header_value(&headers, "x-test-bin", b"client-binary");
+
+    // Return minimal response
+    let resp_raw: Vec<u8> = GetSystemInfoResponse::default().encode_to_vec();
+    let resp = ClientGrpcOverrideResponse {
+        status_code: 0,
+        headers: ByteArrayRefArray::empty(),
+        success_proto: resp_raw.as_slice().into(),
+        fail_message: ByteArrayRef::empty(),
+        fail_details: ByteArrayRef::empty(),
+    };
+    temporal_core_client_grpc_override_request_respond(req, resp);
+}
+
+#[test]
+fn test_callback_override_with_headers() {
+    Context::with(|context| {
+        context.runtime_new().unwrap();
+
+        // Prepare client options with headers
+        let mut client_options = default_connection_options("127.0.0.1:4567");
+        client_options.headers = Some(HashMap::from([(
+            "x-test".to_owned(),
+            "client-ascii".to_owned(),
+        )]));
+        client_options.binary_headers = Some(HashMap::from([(
+            "x-test-bin".to_owned(),
+            b"client-binary".to_vec(),
+        )]));
+
+        // Create client which will invoke GetSystemInfo
+        context
+            .client_connect_with_override(
+                Box::new(client_options),
+                Some(headers_callback_override),
+                std::ptr::null_mut(),
+            )
+            .unwrap();
+
+        // Invoke start workflow
+        let _ = context
+            .rpc_call(Box::new(OwnedRpcCallOptions {
+                service: RpcService::Workflow,
+                rpc: "StartWorkflowExecution".into(),
+                req: StartWorkflowExecutionRequest {
+                    workflow_id: "my-workflow-id".into(),
+                    ..Default::default()
+                }
+                .encode_to_vec(),
+                retry: false,
+                metadata: None,
+                binary_metadata: None,
+                timeout_millis: 0,
+                cancellation_token: None,
+            }))
+            .unwrap();
+    });
+}
+
+fn assert_ascii_header_value(headers: &HashMap<String, Vec<u8>>, key: &str, expected_value: &str) {
+    let value = headers.get(key);
+    assert!(value.is_some());
+    assert_eq!(
+        expected_value,
+        String::from_utf8(value.unwrap().to_vec()).unwrap(),
+    );
+}
+
+fn assert_binary_header_value(
+    headers: &HashMap<String, Vec<u8>>,
+    key: &str,
+    expected_value: &[u8],
+) {
+    let value = headers.get(key);
+    assert!(value.is_some());
+    let decode_result = STANDARD_NO_PAD.decode(value.unwrap());
+    assert!(decode_result.is_ok());
+    let decoded = decode_result.ok().unwrap();
+    assert_eq!(expected_value, decoded);
+}

package/sdk-core/crates/sdk-core-c-bridge/src/tests/utils.rs

@@ -1,13 +1,11 @@
 use crate::{
     ByteArray, CancellationToken,
-    client::RpcService,
+    client::{GrpcMetadataHolder, RpcService},
     runtime::{Runtime, temporal_core_byte_array_free},
 };
-use std::{collections::HashMap, ops::Deref};
-use temporalio_client::ClientOptions;
-use temporalio_sdk_core::ephemeral_server::{
-    TemporalDevServerConfig, TemporalDevServerConfigBuilder, default_cached_download,
-};
+use std::ops::Deref;
+use temporalio_client::ConnectionOptions;
+use temporalio_sdk_core::ephemeral_server::{TemporalDevServerConfig, default_cached_download};
 use url::Url;
 
 pub fn byte_array_to_vec(runtime: *mut Runtime, byte_array: *const ByteArray) -> Option<Vec<u8>> {
@@ -31,15 +29,13 @@ pub fn pointer_or_null<T>(x: Option<impl Deref<Target = T>>) -> *const T {
 }
 
 pub fn default_server_config() -> TemporalDevServerConfig {
-    TemporalDevServerConfigBuilder::default()
+    TemporalDevServerConfig::builder()
         .exe(default_cached_download())
         .build()
-        .unwrap()
 }
 
-pub fn default_client_options(target: &str) -> ClientOptions {
-    ClientOptions::builder()
-        .target_url(Url::parse(&format!("http://{target}")).unwrap())
+pub fn default_connection_options(target: &str) -> ConnectionOptions {
+    ConnectionOptions::new(Url::parse(&format!("http://{target}")).unwrap())
         .client_name("core-c-bridge-tests".to_owned())
         .client_version("0.1.0".to_owned())
         .build()
@@ -50,7 +46,8 @@ pub struct OwnedRpcCallOptions {
     pub rpc: String,
     pub req: Vec<u8>,
     pub retry: bool,
-    pub metadata: Option<MetadataMap>,
+    pub metadata: Option<GrpcMetadataHolder>,
+    pub binary_metadata: Option<GrpcMetadataHolder>,
     pub timeout_millis: u32,
     pub cancellation_token: Option<*mut CancellationToken>,
 }
@@ -58,46 +55,6 @@ pub struct OwnedRpcCallOptions {
 unsafe impl Send for OwnedRpcCallOptions {}
 unsafe impl Sync for OwnedRpcCallOptions {}
 
-#[derive(Clone, Debug)]
-pub enum MetadataMap {
-    Deserialized(HashMap<String, String>),
-    Serialized(String),
-}
-
-impl From<HashMap<String, String>> for MetadataMap {
-    fn from(value: HashMap<String, String>) -> Self {
-        Self::Deserialized(value)
-    }
-}
-
-#[allow(dead_code)]
-impl MetadataMap {
-    pub fn serialize_from_map(map: &HashMap<String, String>) -> String {
-        map.iter().map(|(k, v)| format!("{k}\n{v}\n")).collect()
-    }
-
-    pub fn serialize(&self) -> String {
-        match self {
-            Self::Deserialized(map) => Self::serialize_from_map(map),
-            Self::Serialized(s) => s.clone(),
-        }
-    }
-
-    pub fn serialize_in_place(&mut self) {
-        if let Self::Deserialized(map) = self {
-            *self = Self::Serialized(Self::serialize_from_map(map));
-        }
-    }
-
-    pub fn as_str(&mut self) -> &str {
-        self.serialize_in_place();
-        let Self::Serialized(s) = self else {
-            unreachable!();
-        };
-        s
-    }
-}
-
 #[derive(thiserror::Error, Debug)]
 #[error("{message} (status code {status_code})")]
 pub struct RpcCallError {

package/sdk-core/crates/sdk-core-c-bridge/src/worker.rs

@@ -1,5 +1,6 @@
 use crate::{
-    ByteArray, ByteArrayRef, ByteArrayRefArray, UserDataHandle, client::Client, runtime::Runtime,
+    ByteArray, ByteArrayRef, ByteArrayRefArray, UserDataHandle, client::Connection,
+    runtime::Runtime,
 };
 use anyhow::{Context, bail};
 use crossbeam_utils::atomic::AtomicCell;
@@ -10,23 +11,16 @@ use std::{
     sync::Arc,
     time::Duration,
 };
-use temporalio_common::{
-    Worker as CoreWorker,
-    errors::{PollError, WorkflowErrorType},
-    protos::{
-        coresdk::{
-            ActivityHeartbeat, ActivityTaskCompletion, nexus::NexusTaskCompletion,
-            workflow_completion::WorkflowActivationCompletion,
-        },
-        temporal::api::history::v1::History,
-    },
-    worker::{
-        SlotInfoTrait, SlotKind, SlotMarkUsedContext, SlotReleaseContext, SlotReservationContext,
-        SlotSupplierPermit,
+use temporalio_common::protos::{
+    coresdk::{
+        ActivityHeartbeat, ActivityTaskCompletion, nexus::NexusTaskCompletion,
+        workflow_completion::WorkflowActivationCompletion,
     },
+    temporal::api::history::v1::History,
 };
 use temporalio_sdk_core::{
-    WorkerConfigBuilder,
+    PollError, SlotInfoTrait, SlotKind, SlotMarkUsedContext, SlotReleaseContext,
+    SlotReservationContext, SlotSupplierPermit, WorkerConfig, WorkflowErrorType,
     replay::{HistoryForReplay, ReplayWorkerInput},
 };
 use tokio::sync::{
@@ -97,18 +91,18 @@ pub struct PollerBehavior {
     pub autoscaling: *const PollerBehaviorAutoscaling,
 }
 
-impl TryFrom<&PollerBehavior> for temporalio_common::worker::PollerBehavior {
+impl TryFrom<&PollerBehavior> for temporalio_sdk_core::PollerBehavior {
     type Error = anyhow::Error;
     fn try_from(value: &PollerBehavior) -> Result<Self, Self::Error> {
         if !value.simple_maximum.is_null() && !value.autoscaling.is_null() {
             bail!("simple_maximum and autoscaling cannot both be non-null values");
         }
         if let Some(value) = unsafe { value.simple_maximum.as_ref() } {
-            return Ok(temporalio_common::worker::PollerBehavior::SimpleMaximum(
+            return Ok(temporalio_sdk_core::PollerBehavior::SimpleMaximum(
                 value.simple_maximum,
             ));
         } else if let Some(value) = unsafe { value.autoscaling.as_ref() } {
-            return Ok(temporalio_common::worker::PollerBehavior::Autoscaling {
+            return Ok(temporalio_sdk_core::PollerBehavior::Autoscaling {
                 minimum: value.minimum,
                 maximum: value.maximum,
                 initial: value.initial,
@@ -237,7 +231,7 @@ pub struct CustomSlotSupplierCallbacks {
     /// is arbitrary, but must be unique among live reservations as it's later used for [`mark_used`](Self::mark_used)
     /// and [`release`](Self::release) callbacks.
     pub try_reserve: CustomSlotSupplierTryReserveCallback,
-    /// Called after successful reservation to mark slot as used. See [`SlotSupplier`](temporalio_common::worker::SlotSupplier)
+    /// Called after successful reservation to mark slot as used. See [`SlotSupplier`](temporalio_sdk_core::SlotSupplier)
     /// trait for details.
     pub mark_used: CustomSlotSupplierMarkUsedCallback,
     /// Called to free a previously reserved slot.
@@ -258,8 +252,7 @@ pub struct CustomSlotSupplierCallbacks {
 impl CustomSlotSupplierCallbacksImpl {
     fn into_ss<SK: SlotKind + Send + Sync + 'static>(
         self,
-    ) -> Arc<dyn temporalio_common::worker::SlotSupplier<SlotKind = SK> + Send + Sync + 'static>
-    {
+    ) -> Arc<dyn temporalio_sdk_core::SlotSupplier<SlotKind = SK> + Send + Sync + 'static> {
         Arc::new(CustomSlotSupplier {
             inner: self,
             _pd: Default::default(),
@@ -376,9 +369,7 @@ impl<'a, SK: SlotKind + Send + Sync> Drop for CancelReserveGuard<'a, SK> {
 }
 
 #[async_trait::async_trait]
-impl<SK: SlotKind + Send + Sync> temporalio_common::worker::SlotSupplier
-    for CustomSlotSupplier<SK>
-{
+impl<SK: SlotKind + Send + Sync> temporalio_sdk_core::SlotSupplier for CustomSlotSupplier<SK> {
     type SlotKind = SK;
 
     async fn reserve_slot(&self, ctx: &dyn SlotReservationContext) -> SlotSupplierPermit {
@@ -467,16 +458,12 @@ impl<SK: SlotKind + Send + Sync> CustomSlotSupplier<SK> {
     fn convert_reserve_ctx(ctx: &dyn SlotReservationContext) -> SlotReserveCtx {
         SlotReserveCtx {
             slot_type: match SK::kind() {
-                temporalio_common::worker::SlotKindType::Workflow => {
-                    SlotKindType::WorkflowSlotKindType
-                }
-                temporalio_common::worker::SlotKindType::Activity => {
-                    SlotKindType::ActivitySlotKindType
-                }
-                temporalio_common::worker::SlotKindType::LocalActivity => {
+                temporalio_sdk_core::SlotKindType::Workflow => SlotKindType::WorkflowSlotKindType,
+                temporalio_sdk_core::SlotKindType::Activity => SlotKindType::ActivitySlotKindType,
+                temporalio_sdk_core::SlotKindType::LocalActivity => {
                     SlotKindType::LocalActivitySlotKindType
                 }
-                temporalio_common::worker::SlotKindType::Nexus => SlotKindType::NexusSlotKindType,
+                temporalio_sdk_core::SlotKindType::Nexus => SlotKindType::NexusSlotKindType,
             },
             task_queue: ctx.task_queue().into(),
             worker_identity: ctx.worker_identity().into(),
@@ -489,21 +476,19 @@ impl<SK: SlotKind + Send + Sync> CustomSlotSupplier<SK> {
         }
     }
 
-    fn convert_slot_info(info: temporalio_common::worker::SlotInfo) -> SlotInfo {
+    fn convert_slot_info(info: temporalio_sdk_core::SlotInfo) -> SlotInfo {
         match info {
-            temporalio_common::worker::SlotInfo::Workflow(w) => SlotInfo::WorkflowSlotInfo {
+            temporalio_sdk_core::SlotInfo::Workflow(w) => SlotInfo::WorkflowSlotInfo {
                 workflow_type: w.workflow_type.as_str().into(),
                 is_sticky: w.is_sticky,
             },
-            temporalio_common::worker::SlotInfo::Activity(a) => SlotInfo::ActivitySlotInfo {
+            temporalio_sdk_core::SlotInfo::Activity(a) => SlotInfo::ActivitySlotInfo {
                 activity_type: a.activity_type.as_str().into(),
             },
-            temporalio_common::worker::SlotInfo::LocalActivity(a) => {
-                SlotInfo::LocalActivitySlotInfo {
-                    activity_type: a.activity_type.as_str().into(),
-                }
-            }
-            temporalio_common::worker::SlotInfo::Nexus(n) => SlotInfo::NexusSlotInfo {
+            temporalio_sdk_core::SlotInfo::LocalActivity(a) => SlotInfo::LocalActivitySlotInfo {
+                activity_type: a.activity_type.as_str().into(),
+            },
+            temporalio_sdk_core::SlotInfo::Nexus(n) => SlotInfo::NexusSlotInfo {
                 operation: n.operation.as_str().into(),
                 service: n.service.as_str().into(),
             },
@@ -563,43 +548,45 @@ macro_rules! enter_sync {
 
 #[unsafe(no_mangle)]
 pub extern "C" fn temporal_core_worker_new(
-    client: *mut Client,
+    connection: *mut Connection,
     options: *const WorkerOptions,
 ) -> WorkerOrFail {
-    let client = unsafe { &mut *client };
-    enter_sync!(client.runtime);
+    let connection = unsafe { &mut *connection };
+    enter_sync!(connection.runtime);
     let options = unsafe { &*options };
 
     let (worker, fail) = match options.try_into() {
         Err(err) => (
             std::ptr::null_mut(),
-            client
+            connection
                 .runtime
                 .alloc_utf8(&format!("Invalid options: {err}"))
                 .into_raw()
                 .cast_const(),
         ),
-        Ok(config) => match temporalio_sdk_core::init_worker(
-            &client.runtime.core,
-            config,
-            client.core.clone().into_inner(),
-        ) {
-            Err(err) => (
-                std::ptr::null_mut(),
-                client
-                    .runtime
-                    .alloc_utf8(&format!("Worker start failed: {err}"))
-                    .into_raw()
-                    .cast_const(),
-            ),
-            Ok(worker) => (
-                Box::into_raw(Box::new(Worker {
-                    worker: Some(Arc::new(worker)),
-                    runtime: client.runtime.clone(),
-                })),
-                std::ptr::null(),
-            ),
-        },
+        Ok(config) => {
+            match temporalio_sdk_core::init_worker(
+                &connection.runtime.core,
+                config,
+                connection.core.clone(),
+            ) {
+                Err(err) => (
+                    std::ptr::null_mut(),
+                    connection
+                        .runtime
+                        .alloc_utf8(&format!("Worker start failed: {err}"))
+                        .into_raw()
+                        .cast_const(),
+                ),
+                Ok(worker) => (
+                    Box::into_raw(Box::new(Worker {
+                        worker: Some(Arc::new(worker)),
+                        runtime: connection.runtime.clone(),
+                    })),
+                    std::ptr::null(),
+                ),
+            }
+        }
     };
     WorkerOrFail { worker, fail }
 }
@@ -646,14 +633,14 @@ pub extern "C" fn temporal_core_worker_validate(
 #[unsafe(no_mangle)]
 pub extern "C" fn temporal_core_worker_replace_client(
     worker: *mut Worker,
-    new_client: *mut Client,
+    new_connection: *mut Connection,
 ) -> *const ByteArray {
     let worker = unsafe { &*worker };
     enter_sync!(worker.runtime);
     let core_worker = worker.worker.as_ref().expect("missing worker").clone();
-    let client = unsafe { &*new_client };
+    let client = unsafe { &*new_connection };
 
-    match core_worker.replace_client(client.core.get_client().clone()) {
+    match core_worker.replace_client(client.core.clone()) {
         Ok(()) => std::ptr::null(),
         Err(err) => worker
             .runtime
@@ -1164,13 +1151,13 @@ impl TryFrom<&WorkerOptions> for temporalio_sdk_core::WorkerConfig {
 
     fn try_from(opt: &WorkerOptions) -> anyhow::Result<Self> {
         let converted_tuner: temporalio_sdk_core::TunerHolder = (&opt.tuner).try_into()?;
-        WorkerConfigBuilder::default()
+        WorkerConfig::builder()
             .namespace(opt.namespace.to_str())
             .task_queue(opt.task_queue.to_str())
             .versioning_strategy({
                 match &opt.versioning_strategy {
                     WorkerVersioningStrategy::None(n) => {
-                        temporalio_common::worker::WorkerVersioningStrategy::None {
+                        temporalio_sdk_core::WorkerVersioningStrategy::None {
                             build_id: n.build_id.to_string(),
                         }
                     }
@@ -1183,7 +1170,7 @@ impl TryFrom<&WorkerOptions> for temporalio_sdk_core::WorkerConfig {
                                 dopts.default_versioning_behavior
                             )
                         };
-                        temporalio_common::worker::WorkerVersioningStrategy::WorkerDeploymentBased(
+                        temporalio_sdk_core::WorkerVersioningStrategy::WorkerDeploymentBased(
                             temporalio_common::worker::WorkerDeploymentOptions {
                                 version: temporalio_common::worker::WorkerDeploymentVersion {
                                     deployment_name: dopts.version.deployment_name.to_string(),
@@ -1195,13 +1182,13 @@ impl TryFrom<&WorkerOptions> for temporalio_sdk_core::WorkerConfig {
                         )
                     }
                     WorkerVersioningStrategy::LegacyBuildIdBased(l) => {
-                        temporalio_common::worker::WorkerVersioningStrategy::LegacyBuildIdBased {
+                        temporalio_sdk_core::WorkerVersioningStrategy::LegacyBuildIdBased {
                             build_id: l.build_id.to_string(),
                         }
                     }
                 }
             })
-            .client_identity_override(opt.identity_override.to_option_string())
+            .maybe_client_identity_override(opt.identity_override.to_option_string())
             .max_cached_workflows(opt.max_cached_workflows as usize)
             .tuner(Arc::new(converted_tuner))
             .task_types(temporalio_common::worker::WorkerTaskTypes::from(
@@ -1216,12 +1203,12 @@ impl TryFrom<&WorkerOptions> for temporalio_sdk_core::WorkerConfig {
             .default_heartbeat_throttle_interval(Duration::from_millis(
                 opt.default_heartbeat_throttle_interval_millis,
             ))
-            .max_worker_activities_per_second(if opt.max_activities_per_second == 0.0 {
+            .maybe_max_worker_activities_per_second(if opt.max_activities_per_second == 0.0 {
                 None
             } else {
                 Some(opt.max_activities_per_second)
             })
-            .max_task_queue_activities_per_second(
+            .maybe_max_task_queue_activities_per_second(
                 if opt.max_task_queue_activities_per_second == 0.0 {
                     None
                 } else {
@@ -1232,14 +1219,14 @@ impl TryFrom<&WorkerOptions> for temporalio_sdk_core::WorkerConfig {
             // auto-cancel-activity behavior or shutdown will not occur, so we
             // always set it even if 0.
             .graceful_shutdown_period(Duration::from_millis(opt.graceful_shutdown_period_millis))
-            .workflow_task_poller_behavior(temporalio_common::worker::PollerBehavior::try_from(
+            .workflow_task_poller_behavior(temporalio_sdk_core::PollerBehavior::try_from(
                 &opt.workflow_task_poller_behavior,
             )?)
             .nonsticky_to_sticky_poll_ratio(opt.nonsticky_to_sticky_poll_ratio)
-            .activity_task_poller_behavior(temporalio_common::worker::PollerBehavior::try_from(
+            .activity_task_poller_behavior(temporalio_sdk_core::PollerBehavior::try_from(
                 &opt.activity_task_poller_behavior,
             )?)
-            .nexus_task_poller_behavior(temporalio_common::worker::PollerBehavior::try_from(
+            .nexus_task_poller_behavior(temporalio_sdk_core::PollerBehavior::try_from(
                 &opt.nexus_task_poller_behavior,
             )?)
             .workflow_failure_errors(if opt.nondeterminism_as_workflow_fail {
@@ -1324,23 +1311,19 @@ impl TryFrom<&TunerHolder> for temporalio_sdk_core::TunerHolder {
             bail!("All resource-based slot suppliers must have the same ResourceBasedTunerOptions",);
         }
 
-        let mut options = temporalio_sdk_core::TunerHolderOptionsBuilder::default();
-        if let Some(first) = first {
-            options.resource_based_options(
-                temporalio_sdk_core::ResourceBasedSlotsOptionsBuilder::default()
-                    .target_mem_usage(first.target_memory_usage)
-                    .target_cpu_usage(first.target_cpu_usage)
-                    .build()
-                    .expect("Building ResourceBasedSlotsOptions is infallible"),
-            );
-        };
-        options
+        temporalio_sdk_core::TunerHolderOptions::builder()
             .workflow_slot_options(holder.workflow_slot_supplier.try_into()?)
             .activity_slot_options(holder.activity_slot_supplier.try_into()?)
             .local_activity_slot_options(holder.local_activity_slot_supplier.try_into()?)
             .nexus_slot_options(holder.nexus_task_slot_supplier.try_into()?)
+            .maybe_resource_based_options(first.map(|f| {
+                temporalio_sdk_core::ResourceBasedSlotsOptions::builder()
+                    .target_mem_usage(f.target_memory_usage)
+                    .target_cpu_usage(f.target_cpu_usage)
+                    .build()
+            }))
             .build()
-            .context("Invalid tuner holder options")?
+            .map_err(|e| anyhow::anyhow!("Failed building tuner holder options: {}", e))?
             .build_tuner_holder()
             .context("Failed building tuner holder")
     }

package/sdk-core/rustfmt.toml

@@ -1 +1,2 @@
-imports_granularity="Crate"
+imports_granularity="Crate"
+format_code_in_doc_comments=true