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

package/src/runtime.rs

@@ -9,10 +9,8 @@ use temporalio_common::telemetry::{
     CoreLog, OtelCollectorOptions as CoreOtelCollectorOptions,
     PrometheusExporterOptions as CorePrometheusExporterOptions, metrics::CoreMeter,
 };
-use temporalio_sdk_core::{
-    CoreRuntime, RuntimeOptionsBuilder, TokioRuntimeBuilder,
-    telemetry::{build_otlp_metric_exporter, start_prometheus_metric_exporter},
-};
+use temporalio_common::telemetry::{build_otlp_metric_exporter, start_prometheus_metric_exporter};
+use temporalio_sdk_core::{CoreRuntime, TokioRuntimeBuilder};
 
 use bridge_macros::js_function;
 use tokio_stream::StreamExt as _;
@@ -20,6 +18,7 @@ use tokio_stream::StreamExt as _;
 use crate::{
     helpers::{handles::MutableFinalize, *},
     logs::LogEntry,
+    metrics::{BufferedMetricUpdate, MetricsCallBuffer},
 };
 
 #[macro_export]
@@ -36,6 +35,10 @@ macro_rules! enter_sync {
 pub fn init(cx: &mut neon::prelude::ModuleContext) -> neon::prelude::NeonResult<()> {
     cx.export_function("newRuntime", runtime_new)?;
     cx.export_function("runtimeShutdown", runtime_shutdown)?;
+    cx.export_function(
+        "runtimeRetrieveBufferedMetrics",
+        runtime_retrieve_buffered_metrics,
+    )?;
 
     Ok(())
 }
@@ -51,6 +54,9 @@ pub struct Runtime {
     // For some unknown reason, the otel metrics exporter will go crazy on shutdown in some
     // scenarios if we don't hold on to the `CoreOtelMeter` till the `Runtime` finally gets dropped.
     _otel_metrics_exporter: Option<Arc<dyn CoreMeter + 'static>>,
+
+    // Buffered metrics call buffer, if buffered metrics are enabled
+    pub(crate) metrics_call_buffer: Option<MetricsCallBuffer>,
 }
 
 /// Initialize Core global telemetry and create the tokio runtime required to run Core.
@@ -63,41 +69,58 @@ pub fn runtime_new(
         bridge_options.try_into()?;
 
     // Create core runtime which starts tokio multi-thread runtime
-    let runtime_options = RuntimeOptionsBuilder::default()
+    let runtime_options = temporalio_sdk_core::RuntimeOptions::builder()
         .telemetry_options(telemetry_options)
         .heartbeat_interval(worker_heartbeat_interval_millis.map(Duration::from_millis))
         .build()
-        .context("Failed to build runtime options")?;
+        .map_err(|err| BridgeError::TypeError {
+            message: format!("Failed to build runtime options: {err}"),
+            field: None,
+        })?;
     let mut core_runtime = CoreRuntime::new(runtime_options, TokioRuntimeBuilder::default())
         .context("Failed to initialize Core Runtime")?;
 
     enter_sync!(core_runtime);
 
     // Run the metrics exporter task, if needed. Created after Runtime since it needs Tokio handle
-    let (prom_metrics_exporter_task, otel_metrics_exporter) = match metrics_options {
-        Some(BridgeMetricsExporter::Prometheus(prom_opts)) => {
-            let exporter = start_prometheus_metric_exporter(prom_opts)
-                .context("Failed to start prometheus metrics exporter")?;
+    let (prom_metrics_exporter_task, otel_metrics_exporter, metrics_call_buffer) =
+        match metrics_options {
+            Some(BridgeMetricsExporter::Prometheus(prom_opts)) => {
+                let exporter = start_prometheus_metric_exporter(prom_opts)
+                    .context("Failed to start prometheus metrics exporter")?;
 
-            core_runtime
-                .telemetry_mut()
-                .attach_late_init_metrics(exporter.meter);
+                core_runtime
+                    .telemetry_mut()
+                    .attach_late_init_metrics(exporter.meter);
 
-            (Some(exporter.abort_handle), None)
-        }
-        Some(BridgeMetricsExporter::Otel(otel_opts)) => {
-            let exporter = build_otlp_metric_exporter(otel_opts)
-                .context("Failed to start OTel metrics exporter")?;
+                (Some(exporter.abort_handle), None, None)
+            }
+            Some(BridgeMetricsExporter::Otel(otel_opts)) => {
+                let exporter = build_otlp_metric_exporter(otel_opts)
+                    .context("Failed to start OTel metrics exporter")?;
 
-            let exporter: Arc<dyn CoreMeter + 'static> = Arc::new(exporter);
-            core_runtime
-                .telemetry_mut()
-                .attach_late_init_metrics(exporter.clone());
+                let exporter: Arc<dyn CoreMeter + 'static> = Arc::new(exporter);
+                core_runtime
+                    .telemetry_mut()
+                    .attach_late_init_metrics(exporter.clone());
 
-            (None, Some(exporter))
-        }
-        None => (None, None),
-    };
+                (None, Some(exporter), None)
+            }
+            Some(BridgeMetricsExporter::Buffer {
+                max_buffer_size,
+                use_seconds_for_durations,
+            }) => {
+                let metrics_call_buffer =
+                    MetricsCallBuffer::new(max_buffer_size, use_seconds_for_durations);
+
+                core_runtime
+                    .telemetry_mut()
+                    .attach_late_init_metrics(metrics_call_buffer.core_buffer.clone());
+
+                (None, None, Some(metrics_call_buffer))
+            }
+            None => (None, None, None),
+        };
 
     // Run the log exporter task, if needed. Created after Runtime since it needs Tokio handle.
     let log_exporter_task = if let BridgeLogExporter::Push { stream, receiver } = logging_options {
@@ -127,6 +150,7 @@ pub fn runtime_new(
         log_exporter_task,
         metrics_exporter_task: prom_metrics_exporter_task.map(Arc::new),
         _otel_metrics_exporter: otel_metrics_exporter,
+        metrics_call_buffer,
     }))
 }
 
@@ -140,6 +164,24 @@ pub fn runtime_shutdown(runtime: OpaqueInboundHandle<Runtime>) -> BridgeResult<(
     Ok(())
 }
 
+/// Retrieve buffered metrics from the runtime.
+///
+/// This function drains the metrics buffer and returns all metric updates that have been
+/// accumulated since the last call to this function.
+#[js_function]
+pub fn runtime_retrieve_buffered_metrics(
+    runtime: OpaqueInboundHandle<Runtime>,
+) -> BridgeResult<Vec<BufferedMetricUpdate>> {
+    let runtime = runtime.borrow()?;
+    let buffer = runtime.metrics_call_buffer.as_ref().ok_or_else(|| {
+        BridgeError::UnexpectedError(
+            "Attempting to retrieve buffered metrics of a runtime without buffer".into(),
+        )
+    })?;
+
+    Ok(buffer.retrieve())
+}
+
 /// Drop will handle the cleanup
 impl MutableFinalize for Runtime {}
 
@@ -223,6 +265,10 @@ impl RuntimeExt for Arc<CoreRuntime> {
 pub enum BridgeMetricsExporter {
     Prometheus(CorePrometheusExporterOptions),
     Otel(CoreOtelCollectorOptions),
+    Buffer {
+        max_buffer_size: usize,
+        use_seconds_for_durations: bool,
+    },
 }
 
 pub enum BridgeLogExporter {
@@ -238,17 +284,15 @@ pub enum BridgeLogExporter {
 mod config {
     use std::{collections::HashMap, net::SocketAddr, sync::Arc, time::Duration};
 
-    use anyhow::Context as _;
-
     use neon::prelude::*;
+    use temporalio_common::telemetry::CoreLogStreamConsumer;
     use temporalio_common::telemetry::{
         HistogramBucketOverrides, Logger as CoreTelemetryLogger, MetricTemporality,
-        OtelCollectorOptions as CoreOtelCollectorOptions, OtelCollectorOptionsBuilder,
-        OtlpProtocol, PrometheusExporterOptions as CorePrometheusExporterOptions,
-        PrometheusExporterOptionsBuilder, TelemetryOptions as CoreTelemetryOptions,
-        TelemetryOptionsBuilder,
+        OtelCollectorOptions as CoreOtelCollectorOptions, OtlpProtocol,
+        PrometheusExporterOptions as CorePrometheusExporterOptions,
+        TelemetryOptions as CoreTelemetryOptions,
     };
-    use temporalio_sdk_core::{Url, telemetry::CoreLogStreamConsumer};
+    use temporalio_sdk_core::Url;
 
     use bridge_macros::TryFromJs;
 
@@ -291,6 +335,7 @@ mod config {
     pub(super) enum MetricsExporterOptions {
         Prometheus(PrometheusMetricsExporterConfig),
         Otel(OtelMetricsExporterConfig),
+        Buffer(BufferedMetricsExporterConfig),
     }
 
     #[derive(Debug, Clone, TryFromJs)]
@@ -315,6 +360,12 @@ mod config {
         protocol: StringEncoded<OtlpProtocol>,
     }
 
+    #[derive(Debug, Clone, TryFromJs)]
+    pub(super) struct BufferedMetricsExporterConfig {
+        max_buffer_size: usize,
+        use_seconds_for_durations: bool,
+    }
+
     /// A private newtype so that we can implement `TryFromJs` on simple externally defined enums
     #[derive(Debug, Clone)]
     struct StringEncoded<T>(T);
@@ -360,13 +411,11 @@ mod config {
                 }
             };
 
-            let mut telemetry_options = TelemetryOptionsBuilder::default();
-            let telemetry_options = telemetry_options
+            let telemetry_options = CoreTelemetryOptions::builder()
                 .logging(telemetry_logger)
                 .metric_prefix(telemetry.metric_prefix)
                 .attach_service_name(telemetry.attach_service_name)
-                .build()
-                .context("Failed to build telemetry options")?;
+                .build();
 
             let metrics_exporter = metrics_exporter
                 .map(std::convert::TryInto::try_into)
@@ -389,6 +438,10 @@ mod config {
                     Ok(super::BridgeMetricsExporter::Prometheus(prom.try_into()?))
                 }
                 Self::Otel(otel) => Ok(super::BridgeMetricsExporter::Otel(otel.try_into()?)),
+                Self::Buffer(buffered) => Ok(super::BridgeMetricsExporter::Buffer {
+                    max_buffer_size: buffered.max_buffer_size,
+                    use_seconds_for_durations: buffered.use_seconds_for_durations,
+                }),
             }
         }
     }
@@ -397,8 +450,7 @@ mod config {
         type Error = BridgeError;
 
         fn try_into(self) -> BridgeResult<CorePrometheusExporterOptions> {
-            let mut options = PrometheusExporterOptionsBuilder::default();
-            let options = options
+            let options = CorePrometheusExporterOptions::builder()
                 .socket_addr(self.socket_addr)
                 .counters_total_suffix(self.counters_total_suffix)
                 .unit_suffix(self.unit_suffix)
@@ -407,8 +459,7 @@ mod config {
                     overrides: self.histogram_bucket_overrides,
                 })
                 .global_tags(self.global_tags)
-                .build()
-                .context("Failed to build prometheus exporter options")?;
+                .build();
 
             Ok(options)
         }
@@ -418,8 +469,7 @@ mod config {
         type Error = BridgeError;
 
         fn try_into(self) -> BridgeResult<CoreOtelCollectorOptions> {
-            let mut options = OtelCollectorOptionsBuilder::default();
-            let options = options
+            let options = CoreOtelCollectorOptions::builder()
                 .url(self.url)
                 .protocol(*self.protocol)
                 .headers(self.headers)
@@ -430,8 +480,7 @@ mod config {
                     overrides: self.histogram_bucket_overrides,
                 })
                 .global_tags(self.global_tags)
-                .build()
-                .context("Failed to build otel exporter options")?;
+                .build();
 
             Ok(options)
         }

package/src/testing.rs

@@ -189,12 +189,9 @@ impl CoreEphemeralServerConfig {
 mod config {
     use std::time::Duration;
 
-    use anyhow::Context as _;
-
     use temporalio_sdk_core::ephemeral_server::{
         EphemeralExe, EphemeralExeVersion, TemporalDevServerConfig as CoreTemporalDevServerConfig,
-        TemporalDevServerConfigBuilder, TestServerConfig as CoreTestServerConfig,
-        TestServerConfigBuilder,
+        TestServerConfig as CoreTestServerConfig,
     };
 
     use bridge_macros::TryFromJs;
@@ -271,13 +268,11 @@ mod config {
         type Error = BridgeError;
 
         fn try_into(self) -> Result<CoreTestServerConfig, Self::Error> {
-            let mut config = TestServerConfigBuilder::default();
-            let config = config
+            let config = CoreTestServerConfig::builder()
                 .exe(self.exe.into())
-                .port(self.port)
+                .maybe_port(self.port)
                 .extra_args(self.extra_args)
-                .build()
-                .context("Invalid Test Server config")?;
+                .build();
 
             Ok(config)
         }
@@ -287,19 +282,17 @@ mod config {
         type Error = BridgeError;
 
         fn try_into(self) -> Result<CoreTemporalDevServerConfig, Self::Error> {
-            let mut config = TemporalDevServerConfigBuilder::default();
-            let config = config
+            let config = CoreTemporalDevServerConfig::builder()
                 .exe(self.exe.into())
                 .namespace(self.namespace)
                 .ip(self.ip)
-                .port(self.port)
-                .ui_port(self.ui_port)
-                .db_filename(self.db_filename)
+                .maybe_port(self.port)
+                .maybe_ui_port(self.ui_port)
+                .maybe_db_filename(self.db_filename)
                 .ui(self.ui)
                 .log((self.log.format, self.log.level))
                 .extra_args(self.extra_args)
-                .build()
-                .context("Invalid Dev Server config")?;
+                .build();
 
             Ok(config)
         }

package/src/worker.rs

@@ -6,10 +6,6 @@ use prost::Message;
 use tokio::sync::mpsc::{Sender, channel};
 use tokio_stream::wrappers::ReceiverStream;
 
-use temporalio_common::Worker as CoreWorkerTrait;
-use temporalio_common::errors::{
-    CompleteActivityError, CompleteNexusError, CompleteWfError, PollError,
-};
 use temporalio_common::protos::{
     coresdk::{
         ActivityHeartbeat, ActivityTaskCompletion, nexus::NexusTaskCompletion,
@@ -17,6 +13,7 @@ use temporalio_common::protos::{
     },
     temporal::api::history::v1::History,
 };
+use temporalio_sdk_core::{CompleteActivityError, CompleteNexusError, CompleteWfError, PollError};
 use temporalio_sdk_core::{
     CoreRuntime, init_replay_worker, init_worker,
     replay::{HistoryForReplay, ReplayWorkerInput},
@@ -34,6 +31,7 @@ use crate::{
 pub fn init(cx: &mut ModuleContext) -> NeonResult<()> {
     cx.export_function("newWorker", worker_new)?;
     cx.export_function("workerValidate", worker_validate)?;
+    cx.export_function("workerReplaceClient", worker_replace_client)?;
 
     cx.export_function(
         "workerPollWorkflowActivation",
@@ -78,16 +76,15 @@ pub fn worker_new(
     client: OpaqueInboundHandle<Client>,
     worker_options: config::BridgeWorkerOptions,
 ) -> BridgeResult<OpaqueOutboundHandle<Worker>> {
-    let config = worker_options
-        .into_core_config()
-        .context("Failed to convert WorkerOptions to CoreWorkerConfig")?;
+    let config = worker_options.into_core_config()?;
 
     let client_ref = client.borrow()?;
-    let client = client_ref.core_client.clone();
+    let connection = client_ref.core_connection.clone();
     let runtime = client_ref.core_runtime.clone();
 
     enter_sync!(runtime);
-    let worker = init_worker(&runtime, config, client).context("Failed to initialize worker")?;
+    let worker =
+        init_worker(&runtime, config, connection).context("Failed to initialize worker")?;
 
     Ok(OpaqueOutboundHandle::new(Worker {
         core_runtime: runtime,
@@ -97,19 +94,42 @@ pub fn worker_new(
 
 /// Validate a worker.
 #[js_function]
-pub fn worker_validate(worker: OpaqueInboundHandle<Worker>) -> BridgeResult<BridgeFuture<()>> {
+pub fn worker_validate(worker: OpaqueInboundHandle<Worker>) -> BridgeResult<BridgeFuture<Vec<u8>>> {
     let worker_ref = worker.borrow()?;
     let worker = worker_ref.core_worker.clone();
     let runtime = worker_ref.core_runtime.clone();
 
     runtime.future_to_promise(async move {
-        worker
-            .validate()
-            .await
-            .map_err(|err| BridgeError::TransportError(err.to_string()))
+        let result = worker.validate().await;
+
+        match result {
+            Ok(task) => Ok(task.encode_to_vec()),
+            Err(err) => Err(BridgeError::TransportError(err.to_string())),
+        }
     })
 }
 
+/// Replace the client used by the worker.
+/// This allows the worker to update client configuration without restarting the worker.
+#[js_function]
+pub fn worker_replace_client(
+    worker: OpaqueInboundHandle<Worker>,
+    client: OpaqueInboundHandle<Client>,
+) -> BridgeResult<()> {
+    let worker_ref = worker.borrow()?;
+    let client_ref = client.borrow()?;
+    let new_connection = client_ref.core_connection.clone();
+    let runtime = worker_ref.core_runtime.clone();
+
+    enter_sync!(runtime);
+    worker_ref
+        .core_worker
+        .replace_client(new_connection)
+        .map_err(|err| BridgeError::UnexpectedError(err.to_string()))?;
+
+    Ok(())
+}
+
 /// Initiate a single workflow activation poll request.
 /// There should be only one concurrent poll request for this type.
 #[js_function]
@@ -405,9 +425,7 @@ pub fn replay_worker_new(
     OpaqueOutboundHandle<Worker>,
     OpaqueOutboundHandle<HistoryForReplayTunnelHandle>,
 )> {
-    let config = config
-        .into_core_config()
-        .context("Failed to convert WorkerOptions to CoreWorkerConfig")?;
+    let config = config.into_core_config()?;
 
     let runtime = runtime.borrow()?.core_runtime.clone();
     enter_sync!(runtime);
@@ -474,24 +492,23 @@ mod config {
     use temporalio_common::protos::temporal::api::enums::v1::VersioningBehavior as CoreVersioningBehavior;
     use temporalio_common::protos::temporal::api::worker::v1::PluginInfo;
     use temporalio_common::worker::{
-        ActivitySlotKind, LocalActivitySlotKind, NexusSlotKind,
-        PollerBehavior as CorePollerBehavior, SlotKind, WorkerConfig, WorkerConfigBuilder,
-        WorkerConfigBuilderError, WorkerDeploymentOptions as CoreWorkerDeploymentOptions,
-        WorkerDeploymentVersion as CoreWorkerDeploymentVersion, WorkflowSlotKind,
+        WorkerDeploymentOptions as CoreWorkerDeploymentOptions,
+        WorkerDeploymentVersion as CoreWorkerDeploymentVersion,
     };
     use temporalio_sdk_core::{
-        ResourceBasedSlotsOptions, ResourceBasedSlotsOptionsBuilder, ResourceSlotOptions,
-        SlotSupplierOptions as CoreSlotSupplierOptions, TunerHolder, TunerHolderOptionsBuilder,
+        ActivitySlotKind, LocalActivitySlotKind, NexusSlotKind,
+        PollerBehavior as CorePollerBehavior, ResourceBasedSlotsOptions, ResourceSlotOptions,
+        SlotKind, SlotSupplierOptions as CoreSlotSupplierOptions, TunerHolder, TunerHolderOptions,
+        WorkerConfig, WorkerVersioningStrategy, WorkflowSlotKind,
     };
 
     use super::custom_slot_supplier::CustomSlotSupplierOptions;
-    use crate::helpers::TryIntoJs;
+    use crate::helpers::{BridgeError, TryIntoJs};
     use bridge_macros::TryFromJs;
     use neon::context::Context;
     use neon::object::Object;
     use neon::prelude::JsResult;
     use neon::types::JsObject;
-    use temporalio_common::worker::WorkerVersioningStrategy;
 
     #[derive(TryFromJs)]
     pub struct BridgeWorkerOptions {
@@ -533,7 +550,7 @@ mod config {
     pub struct WorkerDeploymentOptions {
         version: WorkerDeploymentVersion,
         use_worker_versioning: bool,
-        default_versioning_behavior: VersioningBehavior,
+        default_versioning_behavior: Option<VersioningBehavior>,
     }
 
     #[derive(TryFromJs)]
@@ -557,8 +574,8 @@ mod config {
         enable_nexus: bool,
     }
 
-    impl From<&WorkerTaskTypes> for temporalio_common::worker::WorkerTaskTypes {
-        fn from(t: &WorkerTaskTypes) -> Self {
+    impl From<WorkerTaskTypes> for temporalio_common::worker::WorkerTaskTypes {
+        fn from(t: WorkerTaskTypes) -> Self {
             Self {
                 enable_workflows: t.enable_workflows,
                 enable_local_activities: t.enable_local_activities,
@@ -569,11 +586,10 @@ mod config {
     }
 
     impl BridgeWorkerOptions {
-        pub(crate) fn into_core_config(self) -> Result<WorkerConfig, WorkerConfigBuilderError> {
+        pub(crate) fn into_core_config(self) -> Result<WorkerConfig, BridgeError> {
             // Set all other options
-            let mut builder = WorkerConfigBuilder::default();
-            builder
-                .client_identity_override(Some(self.identity))
+            WorkerConfig::builder()
+                .maybe_client_identity_override(Some(self.identity))
                 .versioning_strategy({
                     if let Some(dopts) = self.worker_deployment_options {
                         WorkerVersioningStrategy::WorkerDeploymentBased(dopts.into())
@@ -591,17 +607,19 @@ mod config {
                 .namespace(self.namespace)
                 .tuner(self.tuner.into_core_config()?)
                 .nonsticky_to_sticky_poll_ratio(self.non_sticky_to_sticky_poll_ratio)
-                .workflow_task_poller_behavior(self.workflow_task_poller_behavior)
-                .activity_task_poller_behavior(self.activity_task_poller_behavior)
-                .nexus_task_poller_behavior(self.nexus_task_poller_behavior)
-                .task_types(&self.task_types)
+                .workflow_task_poller_behavior(self.workflow_task_poller_behavior.into())
+                .activity_task_poller_behavior(self.activity_task_poller_behavior.into())
+                .nexus_task_poller_behavior(self.nexus_task_poller_behavior.into())
+                .task_types(self.task_types.into())
                 .sticky_queue_schedule_to_start_timeout(self.sticky_queue_schedule_to_start_timeout)
                 .max_cached_workflows(self.max_cached_workflows)
                 .max_heartbeat_throttle_interval(self.max_heartbeat_throttle_interval)
                 .default_heartbeat_throttle_interval(self.default_heartbeat_throttle_interval)
-                .max_task_queue_activities_per_second(self.max_task_queue_activities_per_second)
-                .max_worker_activities_per_second(self.max_activities_per_second)
-                .graceful_shutdown_period(self.shutdown_grace_time)
+                .maybe_max_task_queue_activities_per_second(
+                    self.max_task_queue_activities_per_second,
+                )
+                .maybe_max_worker_activities_per_second(self.max_activities_per_second)
+                .maybe_graceful_shutdown_period(self.shutdown_grace_time)
                 .plugins(
                     self.plugins
                         .into_iter()
@@ -612,6 +630,10 @@ mod config {
                         .collect::<HashSet<_>>(),
                 )
                 .build()
+                .map_err(|err| BridgeError::TypeError {
+                    message: format!("Failed to convert WorkerOptions to CoreWorkerConfig: {err}"),
+                    field: None,
+                })
         }
     }
 
@@ -637,7 +659,7 @@ mod config {
             Self {
                 version: val.version.into(),
                 use_worker_versioning: val.use_worker_versioning,
-                default_versioning_behavior: Some(val.default_versioning_behavior.into()),
+                default_versioning_behavior: val.default_versioning_behavior.map(Into::into),
             }
         }
     }
@@ -692,32 +714,29 @@ mod config {
     }
 
     impl WorkerTuner {
-        fn into_core_config(self) -> Result<Arc<TunerHolder>, String> {
-            let mut tuner_holder = TunerHolderOptionsBuilder::default();
+        fn into_core_config(self) -> Result<Arc<TunerHolder>, BridgeError> {
             let mut rbo = None;
-
-            tuner_holder.workflow_slot_options(
-                self.workflow_task_slot_supplier
-                    .into_slot_supplier(&mut rbo),
-            );
-            tuner_holder.activity_slot_options(
-                self.activity_task_slot_supplier
-                    .into_slot_supplier(&mut rbo),
-            );
-            tuner_holder.local_activity_slot_options(
-                self.local_activity_task_slot_supplier
-                    .into_slot_supplier(&mut rbo),
-            );
-            tuner_holder
-                .nexus_slot_options(self.nexus_task_slot_supplier.into_slot_supplier(&mut rbo));
-            if let Some(rbo) = rbo {
-                tuner_holder.resource_based_options(rbo);
-            }
-
-            tuner_holder
+            TunerHolderOptions::builder()
+                .workflow_slot_options(
+                    self.workflow_task_slot_supplier
+                        .into_slot_supplier(&mut rbo),
+                )
+                .activity_slot_options(
+                    self.activity_task_slot_supplier
+                        .into_slot_supplier(&mut rbo),
+                )
+                .local_activity_slot_options(
+                    self.local_activity_task_slot_supplier
+                        .into_slot_supplier(&mut rbo),
+                )
+                .nexus_slot_options(self.nexus_task_slot_supplier.into_slot_supplier(&mut rbo))
+                .maybe_resource_based_options(rbo)
                 .build_tuner_holder()
                 .map(Arc::new)
-                .map_err(|e| format!("Invalid tuner options: {e:?}"))
+                .map_err(|err| BridgeError::TypeError {
+                    message: format!("Invalid tuner options: {err}"),
+                    field: None,
+                })
         }
     }
 
@@ -758,11 +777,10 @@ mod config {
                 },
                 Self::ResourceBased(opts) => {
                     *rbo = Some(
-                        ResourceBasedSlotsOptionsBuilder::default()
+                        ResourceBasedSlotsOptions::builder()
                             .target_cpu_usage(opts.tuner_options.target_cpu_usage)
                             .target_mem_usage(opts.tuner_options.target_memory_usage)
-                            .build()
-                            .expect("Building ResourceBasedSlotsOptions can't fail"),
+                            .build(),
                     );
                     CoreSlotSupplierOptions::ResourceBased(ResourceSlotOptions::new(
                         opts.minimum_slots,
@@ -785,14 +803,14 @@ mod custom_slot_supplier {
 
     use neon::{context::Context, handle::Handle, prelude::*};
 
-    use temporalio_common::worker::{
+    use temporalio_sdk_core::{
         SlotInfo as CoreSlotInfo, SlotInfoTrait as _, SlotKind, SlotKindType as CoreSlotKindType,
         SlotMarkUsedContext as CoreSlotMarkUsedContext,
         SlotReleaseContext as CoreSlotReleaseContext,
         SlotReservationContext as CoreSlotReservationContext, SlotSupplier as CoreSlotSupplier,
+        SlotSupplierOptions as CoreSlotSupplierOptions,
         SlotSupplierPermit as CoreSlotSupplierPermit,
     };
-    use temporalio_sdk_core::SlotSupplierOptions as CoreSlotSupplierOptions;
 
     use bridge_macros::{TryFromJs, TryIntoJs};
     use tracing::warn;