@temporalio/core-bridge 1.15.0 → 1.16.1

package/sdk-core/crates/sdk-core/tests/shared_tests/mod.rs

@@ -1,7 +1,10 @@
 //! Shared tests that are meant to be run against both local dev server and cloud
 
 use crate::common::CoreWfStarter;
-use std::sync::atomic::{AtomicBool, Ordering::Relaxed};
+use std::sync::{
+    Arc,
+    atomic::{AtomicBool, Ordering::Relaxed},
+};
 use temporalio_common::{
     protos::temporal::api::{
         enums::v1::{EventType, WorkflowTaskFailedCause::GrpcMessageTooLarge},
@@ -11,53 +14,81 @@ use temporalio_common::{
     },
     worker::WorkerTaskTypes,
 };
-use temporalio_sdk::WfContext;
+use temporalio_macros::{workflow, workflow_methods};
+use temporalio_sdk::{WorkflowContext, WorkflowResult};
 
 pub(crate) mod priority;
 
+#[workflow]
+struct OversizeGrpcMessageWf {
+    run_flag: Arc<AtomicBool>,
+}
+
+#[workflow_methods(factory_only)]
+impl OversizeGrpcMessageWf {
+    #[run]
+    async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<Vec<u8>> {
+        if ctx.state(|wf| wf.run_flag.load(Relaxed)) {
+            Ok(vec![])
+        } else {
+            ctx.state(|wf| wf.run_flag.store(true, Relaxed));
+            let result: Vec<u8> = vec![0; 5000000];
+            Ok(result)
+        }
+    }
+}
+
 pub(crate) async fn grpc_message_too_large() {
+    let run_flag = Arc::new(AtomicBool::new(false));
+    let run_flag_clone = run_flag.clone();
+
     let wf_name = "oversize_grpc_message";
     let mut starter = CoreWfStarter::new_cloud_or_local(wf_name, "")
         .await
         .unwrap();
-    starter.worker_config.task_types = WorkerTaskTypes::workflow_only();
-    let mut core = starter.worker().await;
+    starter.sdk_config.task_types = WorkerTaskTypes::workflow_only();
+    starter
+        .sdk_config
+        .register_workflow_with_factory(move || OversizeGrpcMessageWf {
+            run_flag: run_flag_clone.clone(),
+        });
 
-    static OVERSIZE_GRPC_MESSAGE_RUN: AtomicBool = AtomicBool::new(false);
-    core.register_wf(wf_name.to_owned(), |_ctx: WfContext| async move {
-        if OVERSIZE_GRPC_MESSAGE_RUN.load(Relaxed) {
-            Ok(vec![].into())
-        } else {
-            OVERSIZE_GRPC_MESSAGE_RUN.store(true, Relaxed);
-            let result: Vec<u8> = vec![0; 5000000];
-            Ok(result.into())
-        }
-    });
-    starter.start_with_worker(wf_name, &mut core).await;
-    core.run_until_done().await.unwrap();
+    let mut sdk = starter.worker().await;
+    sdk.submit_workflow(
+        OversizeGrpcMessageWf::run,
+        (),
+        starter.workflow_options.clone(),
+    )
+    .await
+    .unwrap();
+    sdk.run_until_done().await.unwrap();
 
     let events = starter.get_history().await.events;
     // Depending on the version of server, it may terminate the workflow, or simply be a task
     // failure
     assert!(
-        events.iter().any(|e| {
-            // Task failure
-            e.event_type == EventType::WorkflowTaskFailed as i32
-                && if let WorkflowTaskFailedEventAttributes(attr) = e.attributes.as_ref().unwrap() {
-                    attr.cause == GrpcMessageTooLarge as i32
-                        && attr.failure.as_ref().unwrap().message == "GRPC Message too large"
-                } else {
-                    false
-                }
-            // Workflow terminated
-            ||
-            e.event_type == EventType::WorkflowExecutionTerminated as i32
-                && if let WorkflowExecutionTerminatedEventAttributes(attr) = e.attributes.as_ref().unwrap() {
-                    attr.reason == "GrpcMessageTooLarge"
-                } else {
-                    false
-                }
-        }),
+        events.iter().any(is_oversize_grpc_event),
         "Expected workflow task failure or termination b/c grpc message too large: {events:?}",
     );
 }
+
+pub(crate) fn is_oversize_grpc_event(
+    e: &temporalio_common::protos::temporal::api::history::v1::HistoryEvent,
+) -> bool {
+    // Task failure
+    e.event_type == EventType::WorkflowTaskFailed as i32
+        && if let WorkflowTaskFailedEventAttributes(attr) = e.attributes.as_ref().unwrap() {
+            attr.cause == GrpcMessageTooLarge as i32
+                && attr.failure.as_ref().unwrap().message == "GRPC Message too large"
+        } else {
+            false
+        }
+    // Workflow terminated
+    ||
+    e.event_type == EventType::WorkflowExecutionTerminated as i32
+        && if let WorkflowExecutionTerminatedEventAttributes(attr) = e.attributes.as_ref().unwrap() {
+            attr.reason == "GrpcMessageTooLarge"
+        } else {
+            false
+        }
+}

package/sdk-core/crates/sdk-core/tests/shared_tests/priority.rs

@@ -1,13 +1,12 @@
 use crate::common::CoreWfStarter;
 use std::time::Duration;
-use temporalio_client::{
-    GetWorkflowResultOptions, Priority, WfClientExt, WorkflowClientTrait, WorkflowOptions,
+use temporalio_client::{Priority, UntypedWorkflow, WorkflowGetResultOptions};
+use temporalio_common::protos::temporal::api::{common, history::v1::history_event::Attributes};
+use temporalio_macros::{activities, workflow, workflow_methods};
+use temporalio_sdk::{
+    ActivityOptions, ChildWorkflowOptions, WorkflowContext, WorkflowResult,
+    activities::{ActivityContext, ActivityError},
 };
-use temporalio_common::protos::{
-    coresdk::AsJsonPayloadExt,
-    temporal::api::{common, history::v1::history_event::Attributes},
-};
-use temporalio_sdk::{ActContext, ActivityOptions, ChildWorkflowOptions, WfContext};
 
 pub(crate) async fn priority_values_sent_to_server() {
     let mut starter = if let Some(wfs) =
@@ -17,95 +16,121 @@ pub(crate) async fn priority_values_sent_to_server() {
     } else {
         return;
     };
-    starter.workflow_options.priority = Some(Priority {
-        priority_key: 1,
-        fairness_key: "fair-wf".to_string(),
-        fairness_weight: 4.2,
-    });
+    starter.workflow_options.priority = Priority {
+        priority_key: Some(1),
+        fairness_key: Some("fair-wf".to_string()),
+        fairness_weight: Some(4.2),
+    };
     let mut worker = starter.worker().await;
     let child_type = "child-wf";
 
-    worker.register_wf(starter.get_task_queue(), move |ctx: WfContext| async move {
-        let child = ctx.child_workflow(ChildWorkflowOptions {
-            workflow_id: format!("{}-child", ctx.task_queue()),
-            workflow_type: child_type.to_owned(),
-            options: WorkflowOptions {
+    struct PriorityActivities;
+    #[activities]
+    impl PriorityActivities {
+        #[activity]
+        async fn echo(ctx: ActivityContext, echo_me: String) -> Result<String, ActivityError> {
+            assert_eq!(
+                ctx.info().priority,
+                Priority {
+                    priority_key: Some(5),
+                    fairness_key: Some("fair-act".to_string()),
+                    fairness_weight: Some(1.1)
+                }
+            );
+            Ok(echo_me)
+        }
+    }
+
+    #[workflow]
+    #[derive(Default)]
+    struct ParentWf {
+        child_type: String,
+    }
+
+    #[workflow_methods]
+    impl ParentWf {
+        #[run]
+        async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+            let child = ctx.child_workflow(ChildWorkflowOptions {
+                workflow_id: format!("{}-child", ctx.task_queue()),
+                workflow_type: ctx.state(|wf| wf.child_type.clone()),
                 priority: Some(Priority {
-                    priority_key: 4,
-                    fairness_key: "fair-child".to_string(),
-                    fairness_weight: 1.23,
+                    priority_key: Some(4),
+                    fairness_key: Some("fair-child".to_string()),
+                    fairness_weight: Some(1.23),
                 }),
                 ..Default::default()
-            },
-            ..Default::default()
-        });
+            });
 
-        let started = child
-            .start(&ctx)
-            .await
-            .into_started()
-            .expect("Child should start OK");
-        let activity = ctx.activity(ActivityOptions {
-            activity_type: "echo".to_owned(),
-            input: "hello".as_json_payload().unwrap(),
-            start_to_close_timeout: Some(Duration::from_secs(5)),
-            priority: Some(Priority {
-                priority_key: 5,
-                fairness_key: "fair-act".to_string(),
-                fairness_weight: 1.1,
-            }),
-            // Currently no priority info attached to eagerly run activities
-            do_not_eagerly_execute: true,
-            ..Default::default()
-        });
-        started.result().await;
-        activity.await.unwrap_ok_payload();
-        Ok(().into())
-    });
-    worker.register_wf(child_type.to_owned(), |ctx: WfContext| async move {
-        assert_eq!(
-            ctx.workflow_initial_info().priority,
-            Some(common::v1::Priority {
-                priority_key: 4,
-                fairness_key: "fair-child".to_string(),
-                fairness_weight: 1.23
-            })
-        );
-        Ok(().into())
-    });
-    worker.register_activity("echo", |ctx: ActContext, echo_me: String| async move {
-        assert_eq!(
-            ctx.get_info().priority,
-            Priority {
-                priority_key: 5,
-                fairness_key: "fair-act".to_string(),
-                fairness_weight: 1.1
-            }
-        );
-        Ok(echo_me)
+            let started = child
+                .start()
+                .await
+                .into_started()
+                .expect("Child should start OK");
+            let activity = ctx.start_activity(
+                PriorityActivities::echo,
+                "hello".to_string(),
+                ActivityOptions {
+                    start_to_close_timeout: Some(Duration::from_secs(5)),
+                    priority: Some(Priority {
+                        priority_key: Some(5),
+                        fairness_key: Some("fair-act".to_string()),
+                        fairness_weight: Some(1.1),
+                    }),
+                    do_not_eagerly_execute: true,
+                    ..Default::default()
+                },
+            );
+            started.result().await;
+            let _ = activity.await;
+            Ok(())
+        }
+    }
+
+    #[workflow]
+    #[derive(Default)]
+    struct ChildWf;
+
+    #[workflow_methods]
+    impl ChildWf {
+        #[run(name = "child-wf")]
+        async fn run(ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+            assert_eq!(
+                ctx.workflow_initial_info().priority,
+                Some(common::v1::Priority {
+                    priority_key: 4,
+                    fairness_key: "fair-child".to_string(),
+                    fairness_weight: 1.23
+                })
+            );
+            Ok(())
+        }
+    }
+
+    worker.register_activities(PriorityActivities);
+    worker.register_workflow_with_factory::<ParentWf, _>(move || ParentWf {
+        child_type: child_type.to_owned(),
     });
+    worker.register_workflow::<ChildWf>();
 
-    starter
-        .start_with_worker(starter.get_task_queue(), &mut worker)
-        .await;
+    worker
+        .submit_workflow(ParentWf::run, (), starter.workflow_options.clone())
+        .await
+        .unwrap();
     worker.run_until_done().await.unwrap();
 
     let client = starter.get_client().await;
-    let handle = client.get_untyped_workflow_handle(starter.get_task_queue(), "");
-    let res = handle
-        .get_workflow_result(GetWorkflowResultOptions::default())
+    let handle = client.get_workflow_handle::<UntypedWorkflow>(starter.get_task_queue());
+    handle
+        .get_result(WorkflowGetResultOptions::default())
         .await
         .unwrap();
-    // Expect workflow success
-    res.unwrap_success();
-    let history = client
-        .get_workflow_execution_history(starter.get_task_queue().to_owned(), None, vec![])
+    let events = handle
+        .fetch_history(Default::default())
         .await
         .unwrap()
-        .history
-        .unwrap();
-    let workflow_init_event = history
-        .events
+        .into_events();
+    let workflow_init_event = events
         .iter()
         .find_map(|e| {
             if let Attributes::WorkflowExecutionStartedEventAttributes(e) =
@@ -121,8 +146,7 @@ pub(crate) async fn priority_values_sent_to_server() {
         workflow_init_event.priority.as_ref().unwrap().priority_key,
         1
     );
-    let child_init_event = history
-        .events
+    let child_init_event = events
         .iter()
         .find_map(|e| {
             if let Attributes::StartChildWorkflowExecutionInitiatedEventAttributes(e) =
@@ -135,8 +159,7 @@ pub(crate) async fn priority_values_sent_to_server() {
         })
         .unwrap();
     assert_eq!(child_init_event.priority.as_ref().unwrap().priority_key, 4);
-    let activity_sched_event = history
-        .events
+    let activity_sched_event = events
         .iter()
         .find_map(|e| {
             if let Attributes::ActivityTaskScheduledEventAttributes(e) =

package/sdk-core/crates/sdk-core/tests/workflows_procmacro.rs

@@ -0,0 +1,6 @@
+#[test]
+fn workflows_procmacro_build_tests() {
+    let t = trybuild::TestCases::new();
+    t.pass("tests/workflows_trybuild/*_pass.rs");
+    t.compile_fail("tests/workflows_trybuild/*_fail.rs");
+}

package/sdk-core/crates/sdk-core/tests/workflows_trybuild/async_query_fail.rs

@@ -0,0 +1,26 @@
+use temporalio_macros::{workflow, workflow_methods};
+
+#[workflow]
+pub struct BadWorkflow;
+
+#[workflow_methods]
+impl BadWorkflow {
+    #[run]
+    pub async fn run(_ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        Ok(())
+    }
+
+    // This should fail - queries must not be async
+    #[query]
+    pub async fn get_value(&self, _ctx: &WorkflowContextView) -> u32 {
+        42
+    }
+}
+
+impl Default for BadWorkflow {
+    fn default() -> Self {
+        Self
+    }
+}
+
+fn main() {}

package/sdk-core/crates/sdk-core/tests/workflows_trybuild/async_query_fail.stderr

@@ -0,0 +1,5 @@
+error: #[query] methods must not be async (queries are synchronous)
+  --> tests/workflows_trybuild/async_query_fail.rs:15:9
+   |
+15 |     pub async fn get_value(&self, _ctx: &WorkflowContextView) -> u32 {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

package/sdk-core/crates/sdk-core/tests/workflows_trybuild/basic_pass.rs

@@ -0,0 +1,49 @@
+use temporalio_macros::{workflow, workflow_methods};
+use temporalio_sdk::{SyncWorkflowContext, WorkflowContext, WorkflowContextView, WorkflowResult};
+
+#[workflow]
+pub struct MyWorkflow {
+    counter: u32,
+}
+
+#[workflow_methods]
+impl MyWorkflow {
+    #[init]
+    pub fn new(_ctx: &WorkflowContextView, _input: String) -> Self {
+        Self { counter: 0 }
+    }
+
+    // Async run uses &self
+    #[run]
+    pub async fn run(_ctx: &mut WorkflowContext<Self>) -> WorkflowResult<String> {
+        Ok("hi".to_owned())
+    }
+
+    // Sync signal uses &mut self
+    #[signal(name = "increment")]
+    pub fn increment_counter(&mut self, _ctx: &mut SyncWorkflowContext<Self>, amount: u32) {
+        self.counter += amount;
+    }
+
+    #[signal]
+    pub async fn async_signal(_ctx: &mut WorkflowContext<Self>) {}
+
+    // Query uses &self with read-only context
+    #[query]
+    pub fn get_counter(&self, _ctx: &WorkflowContextView) -> u32 {
+        self.counter
+    }
+
+    #[update(name = "double")]
+    pub fn double_counter(&mut self, _ctx: &mut SyncWorkflowContext<Self>) -> u32 {
+        self.counter *= 2;
+        self.counter
+    }
+
+    #[update]
+    pub async fn async_update(_ctx: &mut WorkflowContext<Self>, val: i32) -> i32 {
+        val * 2
+    }
+}
+
+fn main() {}

package/sdk-core/crates/sdk-core/tests/workflows_trybuild/minimal_pass.rs

@@ -0,0 +1,21 @@
+use temporalio_macros::{workflow, workflow_methods};
+use temporalio_sdk::{WorkflowContext, WorkflowResult};
+
+#[workflow]
+pub struct MinimalWorkflow;
+
+#[workflow_methods]
+impl MinimalWorkflow {
+    #[run]
+    pub async fn run(_ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        Ok(())
+    }
+}
+
+impl Default for MinimalWorkflow {
+    fn default() -> Self {
+        Self
+    }
+}
+
+fn main() {}

package/sdk-core/crates/sdk-core/tests/workflows_trybuild/mut_query_fail.rs

@@ -0,0 +1,26 @@
+use temporalio_macros::{workflow, workflow_methods};
+
+#[workflow]
+pub struct BadWorkflow;
+
+#[workflow_methods]
+impl BadWorkflow {
+    #[run]
+    pub async fn run(_ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        Ok(())
+    }
+
+    // This should fail - queries must use &self, not &mut self
+    #[query]
+    pub fn get_value(&mut self, _ctx: &WorkflowContextView) -> u32 {
+        42
+    }
+}
+
+impl Default for BadWorkflow {
+    fn default() -> Self {
+        Self
+    }
+}
+
+fn main() {}

package/sdk-core/crates/sdk-core/tests/workflows_trybuild/mut_query_fail.stderr

@@ -0,0 +1,5 @@
+error: #[query] methods must use `&self` as the receiver (not `&mut self`) - queries are read-only
+  --> tests/workflows_trybuild/mut_query_fail.rs:15:22
+   |
+15 |     pub fn get_value(&mut self, _ctx: &WorkflowContextView) -> u32 {
+   |                      ^^^^^^^^^

package/sdk-core/crates/sdk-core/tests/workflows_trybuild/sync_run_fail.rs

@@ -0,0 +1,21 @@
+use temporalio_macros::{workflow, workflow_methods};
+
+#[workflow]
+pub struct BadWorkflow;
+
+#[workflow_methods]
+impl BadWorkflow {
+    // This should fail - run must be async
+    #[run]
+    pub fn run(&self, _ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+        Ok(())
+    }
+}
+
+impl Default for BadWorkflow {
+    fn default() -> Self {
+        Self
+    }
+}
+
+fn main() {}

package/sdk-core/crates/sdk-core/tests/workflows_trybuild/sync_run_fail.stderr

@@ -0,0 +1,5 @@
+error: #[run] methods must be async
+  --> tests/workflows_trybuild/sync_run_fail.rs:10:9
+   |
+10 |     pub fn run(&self, _ctx: &mut WorkflowContext<Self>) -> WorkflowResult<()> {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

package/sdk-core/crates/sdk-core-c-bridge/Cargo.toml

@@ -7,6 +7,9 @@ license-file = { workspace = true }
 description = "C bridge for Temporal Core SDK"
 homepage = "https://temporal.io/"
 repository = "https://github.com/temporalio/sdk-core"
+keywords = ["temporal", "workflow"]
+categories = ["development-tools"]
+publish = false
 
 [lib]
 name = "temporalio_sdk_core_c_bridge"
@@ -38,14 +41,17 @@ xz2 = { version = "0.1" }
 
 [dependencies.temporalio-client]
 path = "../client"
+version = "0.1"
 
 [dependencies.temporalio-sdk-core]
 path = "../sdk-core"
+version = "0.1"
 features = ["ephemeral-server"]
 
 [dependencies.temporalio-common]
 path = "../common"
-features = ["envconfig"]
+version = "0.1"
+features = ["core-based-sdk"]
 
 [dev-dependencies]
 base64 = "0.21.0"

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

@@ -56,8 +56,6 @@ typedef enum TemporalCoreSlotKindType {
 
 typedef struct TemporalCoreCancellationToken TemporalCoreCancellationToken;
 
-typedef struct TemporalCoreClient TemporalCoreClient;
-
 /**
  * Representation of gRPC request for the callback.
  *
@@ -67,6 +65,8 @@ typedef struct TemporalCoreClient TemporalCoreClient;
  */
 typedef struct TemporalCoreClientGrpcOverrideRequest TemporalCoreClientGrpcOverrideRequest;
 
+typedef struct TemporalCoreConnection TemporalCoreConnection;
+
 typedef struct TemporalCoreEphemeralServer TemporalCoreEphemeralServer;
 
 typedef struct TemporalCoreForwardedLog TemporalCoreForwardedLog;
@@ -144,7 +144,7 @@ typedef struct TemporalCoreClientHttpConnectProxyOptions {
 typedef void (*TemporalCoreClientGrpcOverrideCallback)(struct TemporalCoreClientGrpcOverrideRequest *request,
                                                        void *user_data);
 
-typedef struct TemporalCoreClientOptions {
+typedef struct TemporalCoreConnectionOptions {
   struct TemporalCoreByteArrayRef target_url;
   struct TemporalCoreByteArrayRef client_name;
   struct TemporalCoreByteArrayRef client_version;
@@ -171,7 +171,7 @@ typedef struct TemporalCoreClientOptions {
    * Optional user data passed to each callback call.
    */
   void *grpc_override_callback_user_data;
-} TemporalCoreClientOptions;
+} TemporalCoreConnectionOptions;
 
 typedef struct TemporalCoreByteArray {
   const uint8_t *data;
@@ -190,7 +190,7 @@ typedef struct TemporalCoreByteArray {
  * If success or fail are not null, they must be manually freed when done.
  */
 typedef void (*TemporalCoreClientConnectCallback)(void *user_data,
-                                                  struct TemporalCoreClient *success,
+                                                  struct TemporalCoreConnection *success,
                                                   const struct TemporalCoreByteArray *fail);
 
 /**
@@ -692,7 +692,7 @@ typedef struct TemporalCoreCustomSlotSupplierCallbacks {
    */
   TemporalCoreCustomSlotSupplierTryReserveCallback try_reserve;
   /**
-   * 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.
    */
   TemporalCoreCustomSlotSupplierMarkUsedCallback mark_used;
@@ -834,19 +834,19 @@ void temporal_core_cancellation_token_free(struct TemporalCoreCancellationToken
  * callback.
  */
 void temporal_core_client_connect(struct TemporalCoreRuntime *runtime,
-                                  const struct TemporalCoreClientOptions *options,
+                                  const struct TemporalCoreConnectionOptions *options,
                                   void *user_data,
                                   TemporalCoreClientConnectCallback callback);
 
-void temporal_core_client_free(struct TemporalCoreClient *client);
+void temporal_core_client_free(struct TemporalCoreConnection *client);
 
-void temporal_core_client_update_metadata(struct TemporalCoreClient *client,
+void temporal_core_client_update_metadata(struct TemporalCoreConnection *client,
                                           TemporalCoreMetadataRef metadata);
 
-void temporal_core_client_update_binary_metadata(struct TemporalCoreClient *client,
+void temporal_core_client_update_binary_metadata(struct TemporalCoreConnection *client,
                                                  TemporalCoreMetadataRef metadata);
 
-void temporal_core_client_update_api_key(struct TemporalCoreClient *client,
+void temporal_core_client_update_api_key(struct TemporalCoreConnection *client,
                                          struct TemporalCoreByteArrayRef api_key);
 
 /**
@@ -889,7 +889,7 @@ void temporal_core_client_grpc_override_request_respond(struct TemporalCoreClien
 /**
  * Client, options, and user data must live through callback.
  */
-void temporal_core_client_rpc_call(struct TemporalCoreClient *client,
+void temporal_core_client_rpc_call(struct TemporalCoreConnection *client,
                                    const struct TemporalCoreRpcCallOptions *options,
                                    void *user_data,
                                    TemporalCoreClientRpcCallCallback callback);
@@ -996,7 +996,7 @@ void temporal_core_ephemeral_server_shutdown(struct TemporalCoreEphemeralServer
                                              void *user_data,
                                              TemporalCoreEphemeralServerShutdownCallback callback);
 
-struct TemporalCoreWorkerOrFail temporal_core_worker_new(struct TemporalCoreClient *client,
+struct TemporalCoreWorkerOrFail temporal_core_worker_new(struct TemporalCoreConnection *connection,
                                                          const struct TemporalCoreWorkerOptions *options);
 
 void temporal_core_worker_free(struct TemporalCoreWorker *worker);
@@ -1006,7 +1006,7 @@ void temporal_core_worker_validate(struct TemporalCoreWorker *worker,
                                    TemporalCoreWorkerCallback callback);
 
 const struct TemporalCoreByteArray *temporal_core_worker_replace_client(struct TemporalCoreWorker *worker,
-                                                                        struct TemporalCoreClient *new_client);
+                                                                        struct TemporalCoreConnection *new_connection);
 
 void temporal_core_worker_poll_workflow_activation(struct TemporalCoreWorker *worker,
                                                    void *user_data,