Update core

temporalio/bridge/src/client.rs

@@ -8,9 +8,8 @@ use temporalio_client::tonic::{
     metadata::{AsciiMetadataKey, AsciiMetadataValue, BinaryMetadataKey, BinaryMetadataValue},
 };
 use temporalio_client::{
-    ClientKeepAliveConfig as CoreClientKeepAliveConfig, ClientOptions, ClientOptionsBuilder,
-    ConfiguredClient, HttpConnectProxyOptions, RetryClient, RetryConfig, TemporalServiceClient,
-    TlsConfig,
+    ClientKeepAliveOptions as CoreClientKeepAliveConfig, ClientOptions, ConfiguredClient,
+    HttpConnectProxyOptions, RetryClient, RetryOptions, TemporalServiceClient,
 };
 use url::Url;
 
@@ -229,47 +228,44 @@ impl TryFrom<ClientConfig> for ClientOptions {
     type Error = PyErr;
 
     fn try_from(opts: ClientConfig) -> PyResult<Self> {
-        let mut gateway_opts = ClientOptionsBuilder::default();
         let (ascii_headers, binary_headers) = partition_headers(opts.metadata);
-        gateway_opts
+        let gateway_opts = ClientOptions::builder()
             .target_url(
                 Url::parse(&opts.target_url)
                     .map_err(|err| PyValueError::new_err(format!("invalid target URL: {err}")))?,
             )
             .client_name(opts.client_name)
             .client_version(opts.client_version)
             .identity(opts.identity)
-            .retry_config(
+            .retry_options(
                 opts.retry_config
-                    .map_or(RetryConfig::default(), |c| c.into()),
+                    .map_or(RetryOptions::default(), |c| c.into()),
             )
             .keep_alive(opts.keep_alive_config.map(Into::into))
-            .http_connect_proxy(opts.http_connect_proxy_config.map(Into::into))
-            .headers(Some(ascii_headers))
-            .binary_headers(Some(binary_headers))
-            .api_key(opts.api_key);
-        // Builder does not allow us to set option here, so we have to make
-        // a conditional to even call it
-        if let Some(tls_config) = opts.tls_config {
-            gateway_opts.tls_cfg(tls_config.try_into()?);
-        }
-        gateway_opts
-            .build()
-            .map_err(|err| PyValueError::new_err(format!("Invalid client config: {err}")))
+            .maybe_http_connect_proxy(opts.http_connect_proxy_config.map(Into::into))
+            .headers(ascii_headers)
+            .binary_headers(binary_headers)
+            .maybe_api_key(opts.api_key)
+            .maybe_tls_options(if let Some(tls_config) = opts.tls_config {
+                Some(tls_config.try_into()?)
+            } else {
+                None
+            });
+        Ok(gateway_opts.build())
     }
 }
 
-impl TryFrom<ClientTlsConfig> for temporalio_client::TlsConfig {
+impl TryFrom<ClientTlsConfig> for temporalio_client::TlsOptions {
     type Error = PyErr;
 
     fn try_from(conf: ClientTlsConfig) -> PyResult<Self> {
-        Ok(TlsConfig {
+        Ok(temporalio_client::TlsOptions {
             server_root_ca_cert: conf.server_root_ca_cert,
             domain: conf.domain,
-            client_tls_config: match (conf.client_cert, conf.client_private_key) {
+            client_tls_options: match (conf.client_cert, conf.client_private_key) {
                 (None, None) => None,
                 (Some(client_cert), Some(client_private_key)) => {
-                    Some(temporalio_client::ClientTlsConfig {
+                    Some(temporalio_client::ClientTlsOptions {
                         client_cert,
                         client_private_key,
                     })
@@ -284,9 +280,9 @@ impl TryFrom<ClientTlsConfig> for temporalio_client::TlsConfig {
     }
 }
 
-impl From<ClientRetryConfig> for RetryConfig {
+impl From<ClientRetryConfig> for RetryOptions {
     fn from(conf: ClientRetryConfig) -> Self {
-        RetryConfig {
+        RetryOptions {
             initial_interval: Duration::from_millis(conf.initial_interval_millis),
             randomization_factor: conf.randomization_factor,
             multiplier: conf.multiplier,

temporalio/bridge/src/metric.rs

@@ -207,16 +207,11 @@ fn build_metric_parameters(
     description: Option<String>,
     unit: Option<String>,
 ) -> metrics::MetricParameters {
-    let mut build = metrics::MetricParametersBuilder::default();
-    build.name(name);
-    if let Some(description) = description {
-        build.description(description);
-    }
-    if let Some(unit) = unit {
-        build.unit(unit);
-    }
-    // Should be nothing that would fail validation here
-    build.build().unwrap()
+    metrics::MetricParameters::builder()
+        .name(name)
+        .maybe_description(description)
+        .maybe_unit(unit)
+        .build()
 }
 
 #[pymethods]