@temporalio/core-bridge 1.13.2 → 1.14.0

package/sdk-core/{core-c-bridge → crates/sdk-core-c-bridge}/Cargo.toml

@@ -1,10 +1,15 @@
 [package]
-name = "temporal-sdk-core-c-bridge"
+name = "temporalio-sdk-core-c-bridge"
 version = "0.1.0"
 edition = "2024"
+authors = ["Spencer Judge <spencer@temporal.io>"]
+license-file = { workspace = true }
+description = "C bridge for Temporal Core SDK"
+homepage = "https://temporal.io/"
+repository = "https://github.com/temporalio/sdk-core"
 
 [lib]
-name = "temporal_sdk_core_c_bridge"
+name = "temporalio_sdk_core_c_bridge"
 crate-type = ["cdylib"]
 
 [dependencies]
@@ -31,20 +36,17 @@ url = "2.5"
 # This is only needed as an explicit dependency so we can enable static as a feature
 xz2 = { version = "0.1" }
 
-[dependencies.temporal-client]
+[dependencies.temporalio-client]
 path = "../client"
 
-[dependencies.temporal-sdk-core]
-path = "../core"
+[dependencies.temporalio-sdk-core]
+path = "../sdk-core"
 features = ["ephemeral-server"]
 
-[dependencies.temporal-sdk-core-api]
-path = "../core-api"
+[dependencies.temporalio-common]
+path = "../common"
 features = ["envconfig"]
 
-[dependencies.temporal-sdk-core-protos]
-path = "../sdk-core-protos"
-
 [dev-dependencies]
 futures-util = "0.3"
 thiserror = { workspace = true }
@@ -53,4 +55,5 @@ thiserror = { workspace = true }
 cbindgen = { version = "0.29", default-features = false }
 
 [features]
+antithesis_assertions = ["temporalio-sdk-core/antithesis_assertions"]
 xz2-static = ["xz2/static"]

package/sdk-core/{core-c-bridge → crates/sdk-core-c-bridge}/include/temporal-sdk-core-c-bridge.h

@@ -5,13 +5,13 @@
 #include <stdint.h>
 #include <stdlib.h>
 
-typedef enum TemporalCoreForwardedLogLevel {
-  Trace = 0,
-  Debug,
-  Info,
-  Warn,
-  Error,
-} TemporalCoreForwardedLogLevel;
+typedef enum TemporalCoreRpcService {
+  Workflow = 1,
+  Operator,
+  Cloud,
+  Test,
+  Health,
+} TemporalCoreRpcService;
 
 typedef enum TemporalCoreMetricAttributeValueType {
   String = 1,
@@ -29,6 +29,14 @@ typedef enum TemporalCoreMetricKind {
   GaugeFloat,
 } TemporalCoreMetricKind;
 
+typedef enum TemporalCoreForwardedLogLevel {
+  Trace = 0,
+  Debug,
+  Info,
+  Warn,
+  Error,
+} TemporalCoreForwardedLogLevel;
+
 typedef enum TemporalCoreOpenTelemetryMetricTemporality {
   Cumulative = 1,
   Delta,
@@ -39,14 +47,6 @@ typedef enum TemporalCoreOpenTelemetryProtocol {
   Http,
 } TemporalCoreOpenTelemetryProtocol;
 
-typedef enum TemporalCoreRpcService {
-  Workflow = 1,
-  Operator,
-  Cloud,
-  Test,
-  Health,
-} TemporalCoreRpcService;
-
 typedef enum TemporalCoreSlotKindType {
   WorkflowSlotKindType,
   ActivitySlotKindType,
@@ -93,7 +93,7 @@ typedef struct TemporalCoreByteArrayRef {
 } TemporalCoreByteArrayRef;
 
 /**
- * Metadata is <key1>\n<value1>\n<key2>\n<value2>. Metadata keys or
+ * Metadata is `<key1>\n<value1>\n<key2>\n<value2>`. Metadata keys or
  * values cannot contain a newline within.
  */
 typedef struct TemporalCoreByteArrayRef TemporalCoreMetadataRef;
@@ -193,7 +193,7 @@ typedef void (*TemporalCoreClientConnectCallback)(void *user_data,
  */
 typedef struct TemporalCoreClientGrpcOverrideResponse {
   /**
-   * Numeric gRPC status code, see https://grpc.io/docs/guides/status-codes/. 0 is success, non-0
+   * Numeric gRPC status code, see <https://grpc.io/docs/guides/status-codes/>. 0 is success, non-0
    * is failure.
    */
   int32_t status_code;
@@ -343,7 +343,7 @@ typedef struct TemporalCoreOpenTelemetryOptions {
   enum TemporalCoreOpenTelemetryProtocol protocol;
   /**
    * Histogram bucket overrides in form of
-   * <metric1>\n<float>,<float>,<float>\n<metric2>\n<float>,<float>,<float>
+   * `<metric1>\n<float>,<float>,<float>\n<metric2>\n<float>,<float>,<float>`
    */
   TemporalCoreMetadataRef histogram_bucket_overrides;
 } TemporalCoreOpenTelemetryOptions;
@@ -355,7 +355,7 @@ typedef struct TemporalCorePrometheusOptions {
   bool durations_as_seconds;
   /**
    * Histogram bucket overrides in form of
-   * <metric1>\n<float>,<float>,<float>\n<metric2>\n<float>,<float>,<float>
+   * `<metric1>\n<float>,<float>,<float>\n<metric2>\n<float>,<float>,<float>`
    */
   TemporalCoreMetadataRef histogram_bucket_overrides;
 } TemporalCorePrometheusOptions;
@@ -446,6 +446,7 @@ typedef struct TemporalCoreTelemetryOptions {
 
 typedef struct TemporalCoreRuntimeOptions {
   const struct TemporalCoreTelemetryOptions *telemetry;
+  uint64_t worker_heartbeat_interval_millis;
 } TemporalCoreRuntimeOptions;
 
 typedef struct TemporalCoreTestServerOptions {
@@ -678,7 +679,7 @@ typedef struct TemporalCoreCustomSlotSupplierCallbacks {
    */
   TemporalCoreCustomSlotSupplierTryReserveCallback try_reserve;
   /**
-   * Called after successful reservation to mark slot as used. See [`SlotSupplier`](temporal_sdk_core_api::worker::SlotSupplier)
+   * Called after successful reservation to mark slot as used. See [`SlotSupplier`](temporalio_common::worker::SlotSupplier)
    * trait for details.
    */
   TemporalCoreCustomSlotSupplierMarkUsedCallback mark_used;
@@ -737,6 +738,13 @@ typedef struct TemporalCoreTunerHolder {
   struct TemporalCoreSlotSupplier nexus_task_slot_supplier;
 } TemporalCoreTunerHolder;
 
+typedef struct TemporalCoreWorkerTaskTypes {
+  bool enable_workflows;
+  bool enable_local_activities;
+  bool enable_remote_activities;
+  bool enable_nexus;
+} TemporalCoreWorkerTaskTypes;
+
 typedef struct TemporalCorePollerBehaviorSimpleMaximum {
   uintptr_t simple_maximum;
 } TemporalCorePollerBehaviorSimpleMaximum;
@@ -764,7 +772,7 @@ typedef struct TemporalCoreWorkerOptions {
   struct TemporalCoreByteArrayRef identity_override;
   uint32_t max_cached_workflows;
   struct TemporalCoreTunerHolder tuner;
-  bool no_remote_activities;
+  struct TemporalCoreWorkerTaskTypes task_types;
   uint64_t sticky_queue_schedule_to_start_timeout_millis;
   uint64_t max_heartbeat_throttle_interval_millis;
   uint64_t default_heartbeat_throttle_interval_millis;
@@ -777,6 +785,7 @@ typedef struct TemporalCoreWorkerOptions {
   struct TemporalCorePollerBehavior nexus_task_poller_behavior;
   bool nondeterminism_as_workflow_fail;
   struct TemporalCoreByteArrayRefArray nondeterminism_as_workflow_fail_for_types;
+  struct TemporalCoreByteArrayRefArray plugins;
 } TemporalCoreWorkerOptions;
 
 /**
@@ -985,8 +994,8 @@ void temporal_core_worker_validate(struct TemporalCoreWorker *worker,
                                    void *user_data,
                                    TemporalCoreWorkerCallback callback);
 
-void temporal_core_worker_replace_client(struct TemporalCoreWorker *worker,
-                                         struct TemporalCoreClient *new_client);
+const struct TemporalCoreByteArray *temporal_core_worker_replace_client(struct TemporalCoreWorker *worker,
+                                                                        struct TemporalCoreClient *new_client);
 
 void temporal_core_worker_poll_workflow_activation(struct TemporalCoreWorker *worker,
                                                    void *user_data,

package/sdk-core/{core-c-bridge → crates/sdk-core-c-bridge}/src/client.rs

@@ -13,11 +13,11 @@ use std::{
     },
     time::Duration,
 };
-use temporal_client::{
-    ClientKeepAliveConfig, ClientOptions as CoreClientOptions, ClientOptionsBuilder,
-    ClientTlsConfig, CloudService, ConfiguredClient, HealthService, HttpConnectProxyOptions,
-    OperatorService, RetryClient, RetryConfig, TemporalServiceClient, TestService, TlsConfig,
-    WorkflowService, callback_based,
+use temporalio_client::{
+    ClientKeepAliveOptions as CoreClientKeepAliveOptions, ClientOptions as CoreClientOptions,
+    ClientTlsOptions as CoreClientTlsOptions, CloudService, ConfiguredClient, HealthService,
+    OperatorService, RetryClient, RetryOptions, TemporalServiceClient, TestService,
+    TlsOptions as CoreTlsOptions, WorkflowService, callback_based, proxy::HttpConnectProxyOptions,
 };
 use tokio::sync::oneshot;
 use tonic::metadata::MetadataKey;
@@ -290,7 +290,7 @@ unsafe impl Sync for ClientGrpcOverrideRequest {}
 /// inside here must live until that call returns.
 #[repr(C)]
 pub struct ClientGrpcOverrideResponse {
-    /// Numeric gRPC status code, see https://grpc.io/docs/guides/status-codes/. 0 is success, non-0
+    /// Numeric gRPC status code, see <https://grpc.io/docs/guides/status-codes/>. 0 is success, non-0
     /// is failure.
     pub status_code: i32,
 
@@ -1058,6 +1058,17 @@ async fn call_cloud_service(client: &CoreClient, call: &RpcCallOptions) -> anyho
         "DeleteConnectivityRule" => {
             rpc_call_on_trait!(client, call, CloudService, delete_connectivity_rule)
         }
+        "SetServiceAccountNamespaceAccess" => {
+            rpc_call_on_trait!(
+                client,
+                call,
+                CloudService,
+                set_service_account_namespace_access
+            )
+        }
+        "ValidateAccountAuditLogSink" => {
+            rpc_call_on_trait!(client, call, CloudService, validate_account_audit_log_sink)
+        }
         rpc => Err(anyhow::anyhow!("Unknown RPC call {rpc}")),
     }
 }
@@ -1122,45 +1133,57 @@ impl TryFrom<&ClientOptions> for CoreClientOptions {
     type Error = anyhow::Error;
 
     fn try_from(opts: &ClientOptions) -> anyhow::Result<Self> {
-        let mut opts_builder = ClientOptionsBuilder::default();
-        opts_builder
+        let tls_cfg = unsafe { opts.tls_options.as_ref() }
+            .map(|c| c.try_into())
+            .transpose()?;
+
+        let keep_alive = unsafe { opts.keep_alive_options.as_ref() }.map(|ka| {
+            let config: CoreClientKeepAliveOptions = ka.into();
+            config
+        });
+
+        let headers = if opts.metadata.size == 0 {
+            None
+        } else {
+            Some(opts.metadata.to_string_map_on_newlines())
+        };
+
+        let api_key = opts.api_key.to_option_string();
+
+        let http_connect_proxy =
+            unsafe { opts.http_connect_proxy_options.as_ref() }.map(Into::into);
+
+        Ok(CoreClientOptions::builder()
             .target_url(Url::parse(opts.target_url.to_str())?)
             .client_name(opts.client_name.to_string())
             .client_version(opts.client_version.to_string())
             .identity(opts.identity.to_string())
-            .retry_config(
-                unsafe { opts.retry_options.as_ref() }.map_or(RetryConfig::default(), |c| c.into()),
+            .retry_options(
+                unsafe { opts.retry_options.as_ref() }
+                    .map_or(RetryOptions::default(), |c| c.into()),
             )
-            .keep_alive(unsafe { opts.keep_alive_options.as_ref() }.map(Into::into))
-            .headers(if opts.metadata.size == 0 {
-                None
-            } else {
-                Some(opts.metadata.to_string_map_on_newlines())
-            })
-            .api_key(opts.api_key.to_option_string())
-            .http_connect_proxy(
-                unsafe { opts.http_connect_proxy_options.as_ref() }.map(Into::into),
-            );
-        if let Some(tls_config) = unsafe { opts.tls_options.as_ref() } {
-            opts_builder.tls_cfg(tls_config.try_into()?);
-        }
-        Ok(opts_builder.build()?)
+            .maybe_keep_alive(keep_alive.map(Some))
+            .maybe_headers(headers)
+            .maybe_api_key(api_key)
+            .maybe_http_connect_proxy(http_connect_proxy)
+            .maybe_tls_options(tls_cfg)
+            .build())
     }
 }
 
-impl TryFrom<&ClientTlsOptions> for TlsConfig {
+impl TryFrom<&ClientTlsOptions> for CoreTlsOptions {
     type Error = anyhow::Error;
 
     fn try_from(opts: &ClientTlsOptions) -> anyhow::Result<Self> {
-        Ok(TlsConfig {
+        Ok(CoreTlsOptions {
             server_root_ca_cert: opts.server_root_ca_cert.to_option_vec(),
             domain: opts.domain.to_option_string(),
-            client_tls_config: match (
+            client_tls_options: match (
                 opts.client_cert.to_option_vec(),
                 opts.client_private_key.to_option_vec(),
             ) {
                 (None, None) => None,
-                (Some(client_cert), Some(client_private_key)) => Some(ClientTlsConfig {
+                (Some(client_cert), Some(client_private_key)) => Some(CoreClientTlsOptions {
                     client_cert,
                     client_private_key,
                 }),
@@ -1174,9 +1197,9 @@ impl TryFrom<&ClientTlsOptions> for TlsConfig {
     }
 }
 
-impl From<&ClientRetryOptions> for RetryConfig {
+impl From<&ClientRetryOptions> for RetryOptions {
     fn from(opts: &ClientRetryOptions) -> Self {
-        RetryConfig {
+        RetryOptions {
             initial_interval: Duration::from_millis(opts.initial_interval_millis),
             randomization_factor: opts.randomization_factor,
             multiplier: opts.multiplier,
@@ -1191,9 +1214,9 @@ impl From<&ClientRetryOptions> for RetryConfig {
     }
 }
 
-impl From<&ClientKeepAliveOptions> for ClientKeepAliveConfig {
+impl From<&ClientKeepAliveOptions> for CoreClientKeepAliveOptions {
     fn from(opts: &ClientKeepAliveOptions) -> Self {
-        ClientKeepAliveConfig {
+        CoreClientKeepAliveOptions {
             interval: Duration::from_millis(opts.interval_millis),
             timeout: Duration::from_millis(opts.timeout_millis),
         }

package/sdk-core/{core-c-bridge → crates/sdk-core-c-bridge}/src/envconfig.rs

@@ -1,7 +1,7 @@
 use crate::{ByteArray, ByteArrayRef};
 use serde::Serialize;
 use std::collections::HashMap;
-use temporal_sdk_core_api::envconfig::{
+use temporalio_common::envconfig::{
     self, ClientConfig as CoreClientConfig, ClientConfigCodec as CoreClientConfigCodec,
     ClientConfigProfile as CoreClientConfigProfile, ClientConfigTLS as CoreClientConfigTLS,
     DataSource as CoreDataSource, LoadClientConfigOptions, LoadClientConfigProfileOptions,

package/sdk-core/{core-c-bridge → crates/sdk-core-c-bridge}/src/lib.rs

@@ -144,7 +144,7 @@ impl ByteArrayRefArray {
     }
 }
 
-/// Metadata is <key1>\n<value1>\n<key2>\n<value2>. Metadata keys or
+/// Metadata is `<key1>\n<value1>\n<key2>\n<value2>`. Metadata keys or
 /// values cannot contain a newline within.
 pub type MetadataRef = ByteArrayRef;
 

package/sdk-core/{core-c-bridge → crates/sdk-core-c-bridge}/src/metric.rs

@@ -1,6 +1,6 @@
 use crate::{ByteArrayRef, runtime::Runtime};
 use std::{any::Any, error::Error, sync::Arc, time::Duration};
-use temporal_sdk_core_api::telemetry::metrics;
+use temporalio_common::telemetry::metrics;
 
 pub struct MetricMeter {
     core: metrics::TemporalMeter,

package/sdk-core/{core-c-bridge → crates/sdk-core-c-bridge}/src/runtime.rs

@@ -15,21 +15,23 @@ use std::{
     },
     time::{Duration, UNIX_EPOCH},
 };
-use temporal_sdk_core::{
-    CoreRuntime, TokioRuntimeBuilder,
-    telemetry::{build_otlp_metric_exporter, start_prometheus_metric_exporter},
-};
-use temporal_sdk_core_api::telemetry::{
+use temporalio_common::telemetry::{
     CoreLog, CoreLogConsumer, HistogramBucketOverrides, Logger, MetricTemporality,
     OtelCollectorOptionsBuilder, PrometheusExporterOptionsBuilder,
     TelemetryOptions as CoreTelemetryOptions, TelemetryOptionsBuilder, metrics::CoreMeter,
 };
+use temporalio_sdk_core::{
+    CoreRuntime, RuntimeOptions as CoreRuntimeOptions,
+    RuntimeOptionsBuilder as CoreRuntimeOptionsBuilder, TokioRuntimeBuilder,
+    telemetry::{build_otlp_metric_exporter, start_prometheus_metric_exporter},
+};
 use tracing::Level;
 use url::Url;
 
 #[repr(C)]
 pub struct RuntimeOptions {
     pub telemetry: *const TelemetryOptions,
+    pub worker_heartbeat_interval_millis: u64,
 }
 
 #[repr(C)]
@@ -87,7 +89,7 @@ pub struct OpenTelemetryOptions {
     pub durations_as_seconds: bool,
     pub protocol: OpenTelemetryProtocol,
     /// Histogram bucket overrides in form of
-    /// <metric1>\n<float>,<float>,<float>\n<metric2>\n<float>,<float>,<float>
+    /// `<metric1>\n<float>,<float>,<float>\n<metric2>\n<float>,<float>,<float>`
     pub histogram_bucket_overrides: MetadataRef,
 }
 
@@ -110,7 +112,7 @@ pub struct PrometheusOptions {
     pub unit_suffix: bool,
     pub durations_as_seconds: bool,
     /// Histogram bucket overrides in form of
-    /// <metric1>\n<float>,<float>,<float>\n<metric2>\n<float>,<float>,<float>
+    /// `<metric1>\n<float>,<float>,<float>\n<metric2>\n<float>,<float>,<float>`
     pub histogram_bucket_overrides: MetadataRef,
 }
 
@@ -142,7 +144,7 @@ pub extern "C" fn temporal_core_runtime_new(options: *const RuntimeOptions) -> R
             let mut runtime = Runtime {
                 core: Arc::new(
                     CoreRuntime::new(
-                        CoreTelemetryOptions::default(),
+                        CoreRuntimeOptions::default(),
                         TokioRuntimeBuilder::default(),
                     )
                     .unwrap(),
@@ -238,8 +240,21 @@ impl Runtime {
             CoreTelemetryOptions::default()
         };
 
+        let heartbeat_interval = if options.worker_heartbeat_interval_millis == 0 {
+            None
+        } else {
+            Some(Duration::from_millis(
+                options.worker_heartbeat_interval_millis,
+            ))
+        };
+
+        let core_runtime_options = CoreRuntimeOptionsBuilder::default()
+            .telemetry_options(telemetry_options)
+            .heartbeat_interval(heartbeat_interval)
+            .build()?;
+
         // Build core runtime
-        let mut core = CoreRuntime::new(telemetry_options, TokioRuntimeBuilder::default())?;
+        let mut core = CoreRuntime::new(core_runtime_options, TokioRuntimeBuilder::default())?;
 
         // We late-bind the metrics after core runtime is created since it needs
         // the Tokio handle

package/sdk-core/{core-c-bridge → crates/sdk-core-c-bridge}/src/testing.rs

@@ -2,7 +2,7 @@ use std::time::Duration;
 
 use crate::{ByteArray, ByteArrayRef, UserDataHandle, runtime::Runtime};
 
-use temporal_sdk_core::ephemeral_server;
+use temporalio_sdk_core::ephemeral_server;
 
 pub struct EphemeralServer {
     runtime: Runtime,

package/sdk-core/{core-c-bridge → crates/sdk-core-c-bridge}/src/tests/context.rs

@@ -29,8 +29,8 @@ use std::{
     sync::{Arc, Condvar, Mutex, MutexGuard, PoisonError, Weak},
     time::Duration,
 };
-use temporal_client::ClientOptions;
-use temporal_sdk_core::ephemeral_server::{
+use temporalio_client::ClientOptions;
+use temporalio_sdk_core::ephemeral_server::{
     EphemeralExe, EphemeralExeVersion, TemporalDevServerConfig,
 };
 
@@ -153,6 +153,7 @@ impl Context {
 
         let RuntimeOrFail { runtime, fail } = temporal_core_runtime_new(&RuntimeOptions {
             telemetry: std::ptr::null(),
+            worker_heartbeat_interval_millis: 0,
         });
 
         if let Some(fail) = byte_array_to_string(runtime, fail) {
@@ -293,8 +294,8 @@ impl Context {
             .as_ref()
             .map(MetadataMap::serialize_from_map);
 
-        let tls_options = options.tls_cfg.as_ref().map(|tls_cfg| {
-            let client_tls_cfg = tls_cfg.client_tls_config.as_ref();
+        let tls_options = options.tls_options.as_ref().map(|tls_cfg| {
+            let client_tls_cfg = tls_cfg.client_tls_options.as_ref();
             Box::new(ClientTlsOptions {
                 server_root_ca_cert: tls_cfg.server_root_ca_cert.as_deref().into(),
                 domain: tls_cfg.domain.as_deref().into(),
@@ -306,17 +307,17 @@ impl Context {
         });
 
         let retry_options = Box::new(ClientRetryOptions {
-            initial_interval_millis: options.retry_config.initial_interval.as_millis() as u64,
-            randomization_factor: options.retry_config.randomization_factor,
-            multiplier: options.retry_config.multiplier,
-            max_interval_millis: options.retry_config.max_interval.as_millis() as u64,
+            initial_interval_millis: options.retry_options.initial_interval.as_millis() as u64,
+            randomization_factor: options.retry_options.randomization_factor,
+            multiplier: options.retry_options.multiplier,
+            max_interval_millis: options.retry_options.max_interval.as_millis() as u64,
             max_elapsed_time_millis: options
-                .retry_config
+                .retry_options
                 .max_elapsed_time
                 .as_ref()
                 .map(Duration::as_millis)
                 .unwrap_or(0) as u64,
-            max_retries: options.retry_config.max_retries,
+            max_retries: options.retry_options.max_retries,
         });
 
         let keep_alive_options = options.keep_alive.as_ref().map(|keep_alive| {

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

@@ -15,7 +15,7 @@ use crate::{
 use context::Context;
 use prost::Message;
 use std::sync::{Arc, LazyLock, Mutex};
-use temporal_sdk_core_protos::temporal::api::{
+use temporalio_common::protos::temporal::api::{
     failure::v1::Failure,
     workflowservice::v1::{
         GetSystemInfoRequest, GetSystemInfoResponse, QueryWorkflowRequest,
@@ -155,7 +155,7 @@ fn test_all_rpc_calls_exist() {
             context,
             RpcService::Workflow,
             include_str!(
-                "../../../sdk-core-protos/protos/api_upstream/temporal/api/workflowservice/v1/service.proto"
+                "../../../common/protos/api_upstream/temporal/api/workflowservice/v1/service.proto"
             ),
         ));
 
@@ -163,7 +163,7 @@ fn test_all_rpc_calls_exist() {
             context,
             RpcService::Operator,
             include_str!(
-                "../../../sdk-core-protos/protos/api_upstream/temporal/api/operatorservice/v1/service.proto"
+                "../../../common/protos/api_upstream/temporal/api/operatorservice/v1/service.proto"
             ),
         ));
 
@@ -171,7 +171,7 @@ fn test_all_rpc_calls_exist() {
             context,
             RpcService::Cloud,
             include_str!(
-                "../../../sdk-core-protos/protos/api_cloud_upstream/temporal/api/cloud/cloudservice/v1/service.proto"
+                "../../../common/protos/api_cloud_upstream/temporal/api/cloud/cloudservice/v1/service.proto"
             ),
         ));
 
@@ -179,14 +179,14 @@ fn test_all_rpc_calls_exist() {
             context,
             RpcService::Test,
             include_str!(
-                "../../../sdk-core-protos/protos/testsrv_upstream/temporal/api/testservice/v1/service.proto"
+                "../../../common/protos/testsrv_upstream/temporal/api/testservice/v1/service.proto"
             ),
         ));
 
         assert!(all_rpc_calls_exist(
             context,
             RpcService::Health,
-            include_str!("../../../sdk-core-protos/protos/grpc/health/v1/health.proto"),
+            include_str!("../../../common/protos/grpc/health/v1/health.proto"),
         ));
     });
 }
@@ -320,7 +320,7 @@ fn test_simple_callback_override() {
         assert_eq!(start_resp.run_id, "run-id for my-workflow-id");
 
         // Try a query where a query failure will actually be delivered as failure details.
-        // However, we don't currently have temporal_sdk_core_protos::google::rpc::Status in
+        // However, we don't currently have temporalio_common::protos::google::rpc::Status in
         // the crate, so we'll just use the details directly even though a proper gRPC
         // implementation will only provide a google.rpc.Status proto.
         let query_err = context

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

@@ -4,8 +4,8 @@ use crate::{
     runtime::{Runtime, temporal_core_byte_array_free},
 };
 use std::{collections::HashMap, ops::Deref};
-use temporal_client::{ClientOptions, ClientOptionsBuilder};
-use temporal_sdk_core::ephemeral_server::{
+use temporalio_client::ClientOptions;
+use temporalio_sdk_core::ephemeral_server::{
     TemporalDevServerConfig, TemporalDevServerConfigBuilder, default_cached_download,
 };
 use url::Url;
@@ -38,12 +38,11 @@ pub fn default_server_config() -> TemporalDevServerConfig {
 }
 
 pub fn default_client_options(target: &str) -> ClientOptions {
-    ClientOptionsBuilder::default()
+    ClientOptions::builder()
         .target_url(Url::parse(&format!("http://{target}")).unwrap())
         .client_name("core-c-bridge-tests".to_owned())
         .client_version("0.1.0".to_owned())
         .build()
-        .unwrap()
 }
 
 pub struct OwnedRpcCallOptions {