@temporalio/core-bridge 1.8.6 → 1.9.0-rc.0

package/sdk-core/client/src/lib.rs

@@ -6,14 +6,13 @@
 
 #[macro_use]
 extern crate tracing;
-
 mod metrics;
 mod raw;
 mod retry;
+mod worker_registry;
 mod workflow_handle;
 
 pub use crate::retry::{CallType, RetryClient, RETRYABLE_ERROR_CODES};
-pub use metrics::ClientMetricProvider;
 pub use raw::{HealthService, OperatorService, TestService, WorkflowService};
 pub use temporal_sdk_core_protos::temporal::api::{
     enums::v1::ArchivalState,
@@ -24,6 +23,7 @@ pub use temporal_sdk_core_protos::temporal::api::{
     },
 };
 pub use tonic;
+pub use worker_registry::{Slot, SlotManager, SlotProvider, WorkerKey};
 pub use workflow_handle::{WorkflowExecutionInfo, WorkflowExecutionResult};
 
 use crate::{
@@ -44,6 +44,7 @@ use std::{
     sync::Arc,
     time::{Duration, Instant},
 };
+use temporal_sdk_core_api::telemetry::metrics::TemporalMeter;
 use temporal_sdk_core_protos::{
     coresdk::{workflow_commands::QueryResult, IntoPayloadsExt},
     grpc::health::v1::health_client::HealthClient,
@@ -56,6 +57,7 @@ use temporal_sdk_core_protos::{
         replication::v1::ClusterReplicationConfig,
         taskqueue::v1::TaskQueue,
         testservice::v1::test_service_client::TestServiceClient,
+        update,
         workflowservice::v1::{workflow_service_client::WorkflowServiceClient, *},
     },
     TaskToken,
@@ -76,7 +78,11 @@ use uuid::Uuid;
 static CLIENT_NAME_HEADER_KEY: &str = "client-name";
 static CLIENT_VERSION_HEADER_KEY: &str = "client-version";
 /// These must match the gRPC method names, not the snake case versions that exist in the Rust code.
-static LONG_POLL_METHOD_NAMES: [&str; 2] = ["PollWorkflowTaskQueue", "PollActivityTaskQueue"];
+static LONG_POLL_METHOD_NAMES: [&str; 3] = [
+    "PollWorkflowTaskQueue",
+    "PollActivityTaskQueue",
+    "PollWorkflowExecutionUpdateRequest",
+];
 /// The server times out polls after 60 seconds. Set our timeout to be slightly beyond that.
 const LONG_POLL_TIMEOUT: Duration = Duration::from_secs(70);
 const OTHER_CALL_TIMEOUT: Duration = Duration::from_secs(30);
@@ -122,6 +128,10 @@ pub struct ClientOptions {
     /// override.
     #[builder(default)]
     pub override_origin: Option<Uri>,
+
+    /// If set (which it is by default), HTTP2 gRPC keep alive will be enabled.
+    #[builder(default = "Some(ClientKeepAliveConfig::default())")]
+    pub keep_alive: Option<ClientKeepAliveConfig>,
 }
 
 /// Configuration options for TLS
@@ -147,6 +157,24 @@ pub struct ClientTlsConfig {
     pub client_private_key: Vec<u8>,
 }
 
+/// Client keep alive configuration.
+#[derive(Clone, Debug)]
+pub struct ClientKeepAliveConfig {
+    /// Interval to send HTTP2 keep alive pings.
+    pub interval: Duration,
+    /// Timeout that the keep alive must be responded to within or the connection will be closed.
+    pub timeout: Duration,
+}
+
+impl Default for ClientKeepAliveConfig {
+    fn default() -> Self {
+        Self {
+            interval: Duration::from_secs(30),
+            timeout: Duration::from_secs(15),
+        }
+    }
+}
+
 /// Configuration for retrying requests to the server
 #[derive(Clone, Debug)]
 pub struct RetryConfig {
@@ -253,6 +281,7 @@ pub struct ConfiguredClient<C> {
     headers: Arc<RwLock<HashMap<String, String>>>,
     /// Capabilities as read from the `get_system_info` RPC call made on client connection
     capabilities: Option<get_system_info_response::Capabilities>,
+    workers: Arc<SlotManager>,
 }
 
 impl<C> ConfiguredClient<C> {
@@ -272,6 +301,11 @@ impl<C> ConfiguredClient<C> {
     pub fn capabilities(&self) -> Option<&get_system_info_response::Capabilities> {
         self.capabilities.as_ref()
     }
+
+    /// Returns a cloned reference to a registry with workers using this client instance
+    pub fn workers(&self) -> Arc<SlotManager> {
+        self.workers.clone()
+    }
 }
 
 // The configured client is effectively a "smart" (dumb) pointer
@@ -294,7 +328,7 @@ impl ClientOptions {
     pub async fn connect(
         &self,
         namespace: impl Into<String>,
-        metrics_meter: Option<&dyn ClientMetricProvider>,
+        metrics_meter: Option<TemporalMeter>,
         headers: Option<Arc<RwLock<HashMap<String, String>>>>,
     ) -> Result<RetryClient<Client>, ClientInitError> {
         let client = self
@@ -312,12 +346,20 @@ impl ClientOptions {
     /// See [RetryClient] for more
     pub async fn connect_no_namespace(
         &self,
-        metrics_meter: Option<&dyn ClientMetricProvider>,
+        metrics_meter: Option<TemporalMeter>,
         headers: Option<Arc<RwLock<HashMap<String, String>>>>,
     ) -> Result<RetryClient<ConfiguredClient<TemporalServiceClientWithMetrics>>, ClientInitError>
     {
         let channel = Channel::from_shared(self.target_url.to_string())?;
         let channel = self.add_tls_to_channel(channel).await?;
+        let channel = if let Some(keep_alive) = self.keep_alive.as_ref() {
+            channel
+                .keep_alive_while_idle(true)
+                .http2_keep_alive_interval(keep_alive.interval)
+                .keep_alive_timeout(keep_alive.timeout)
+        } else {
+            channel
+        };
         let channel = if let Some(origin) = self.override_origin.clone() {
             channel.origin(origin)
         } else {
@@ -325,9 +367,9 @@ impl ClientOptions {
         };
         let channel = channel.connect().await?;
         let service = ServiceBuilder::new()
-            .layer_fn(|channel| GrpcMetricSvc {
+            .layer_fn(move |channel| GrpcMetricSvc {
                 inner: channel,
-                metrics: metrics_meter.map(|mm| MetricsContext::new(vec![], mm)),
+                metrics: metrics_meter.clone().map(MetricsContext::new),
             })
             .service(channel);
         let headers = headers.unwrap_or_default();
@@ -342,6 +384,7 @@ impl ClientOptions {
             client: TemporalServiceClient::new(svc),
             options: Arc::new(self.clone()),
             capabilities: None,
+            workers: Arc::new(SlotManager::new()),
         };
         match client
             .get_system_info(GetSystemInfoRequest::default())
@@ -578,10 +621,6 @@ impl Client {
     pub fn into_inner(self) -> ConfiguredClient<TemporalServiceClientWithMetrics> {
         self.inner
     }
-
-    fn wf_svc(&self) -> WorkflowServiceClientWithMetrics {
-        self.inner.workflow_svc().clone()
-    }
 }
 
 /// Enum to help reference a namespace by either the namespace name or the namespace id
@@ -905,6 +944,16 @@ pub trait WorkflowClientTrait {
     /// Get Cluster Search Attributes
     async fn get_search_attributes(&self) -> Result<GetSearchAttributesResponse>;
 
+    /// Send an Update to a workflow execution
+    async fn update_workflow_execution(
+        &self,
+        workflow_id: String,
+        run_id: String,
+        name: String,
+        wait_policy: update::v1::WaitPolicy,
+        args: Option<Payloads>,
+    ) -> Result<UpdateWorkflowExecutionResponse>;
+
     /// Returns options that were used to initialize the client
     fn get_options(&self) -> &ClientOptions;
 
@@ -933,6 +982,10 @@ pub struct WorkflowOptions {
 
     /// Optionally associate extra search attributes with a workflow
     pub search_attributes: Option<HashMap<String, Payload>>,
+
+    /// Optionally enable Eager Workflow Start, a latency optimization using local workers
+    /// NOTE: Experimental and incompatible with versioning with BuildIDs
+    pub enable_eager_workflow_start: bool,
 }
 
 #[async_trait::async_trait]
@@ -946,9 +999,9 @@ impl WorkflowClientTrait for Client {
         request_id: Option<String>,
         options: WorkflowOptions,
     ) -> Result<StartWorkflowExecutionResponse> {
-        Ok(self
-            .wf_svc()
-            .start_workflow_execution(StartWorkflowExecutionRequest {
+        Ok(WorkflowService::start_workflow_execution(
+            &mut self.inner.clone(),
+            StartWorkflowExecutionRequest {
                 namespace: self.namespace.clone(),
                 input: input.into_payloads(),
                 workflow_id,
@@ -965,14 +1018,16 @@ impl WorkflowClientTrait for Client {
                 workflow_execution_timeout: options
                     .execution_timeout
                     .and_then(|d| d.try_into().ok()),
-                workflow_run_timeout: options.execution_timeout.and_then(|d| d.try_into().ok()),
+                workflow_run_timeout: options.run_timeout.and_then(|d| d.try_into().ok()),
                 workflow_task_timeout: options.task_timeout.and_then(|d| d.try_into().ok()),
                 search_attributes: options.search_attributes.and_then(|d| d.try_into().ok()),
                 cron_schedule: options.cron_schedule.unwrap_or_default(),
+                request_eager_execution: options.enable_eager_workflow_start,
                 ..Default::default()
-            })
-            .await?
-            .into_inner())
+            },
+        )
+        .await?
+        .into_inner())
     }
 
     async fn reset_sticky_task_queue(
@@ -987,11 +1042,11 @@ impl WorkflowClientTrait for Client {
                 run_id,
             }),
         };
-        Ok(self
-            .wf_svc()
-            .reset_sticky_task_queue(request)
-            .await?
-            .into_inner())
+        Ok(
+            WorkflowService::reset_sticky_task_queue(&mut self.inner.client.clone(), request)
+                .await?
+                .into_inner(),
+        )
     }
 
     async fn complete_activity_task(
@@ -999,17 +1054,18 @@ impl WorkflowClientTrait for Client {
         task_token: TaskToken,
         result: Option<Payloads>,
     ) -> Result<RespondActivityTaskCompletedResponse> {
-        Ok(self
-            .wf_svc()
-            .respond_activity_task_completed(RespondActivityTaskCompletedRequest {
+        Ok(WorkflowService::respond_activity_task_completed(
+            &mut self.inner.client.clone(),
+            RespondActivityTaskCompletedRequest {
                 task_token: task_token.0,
                 result,
                 identity: self.inner.options.identity.clone(),
                 namespace: self.namespace.clone(),
                 worker_version: None,
-            })
-            .await?
-            .into_inner())
+            },
+        )
+        .await?
+        .into_inner())
     }
 
     async fn record_activity_heartbeat(
@@ -1017,16 +1073,17 @@ impl WorkflowClientTrait for Client {
         task_token: TaskToken,
         details: Option<Payloads>,
     ) -> Result<RecordActivityTaskHeartbeatResponse> {
-        Ok(self
-            .wf_svc()
-            .record_activity_task_heartbeat(RecordActivityTaskHeartbeatRequest {
+        Ok(WorkflowService::record_activity_task_heartbeat(
+            &mut self.inner.client.clone(),
+            RecordActivityTaskHeartbeatRequest {
                 task_token: task_token.0,
                 details,
                 identity: self.inner.options.identity.clone(),
                 namespace: self.namespace.clone(),
-            })
-            .await?
-            .into_inner())
+            },
+        )
+        .await?
+        .into_inner())
     }
 
     async fn cancel_activity_task(
@@ -1034,17 +1091,18 @@ impl WorkflowClientTrait for Client {
         task_token: TaskToken,
         details: Option<Payloads>,
     ) -> Result<RespondActivityTaskCanceledResponse> {
-        Ok(self
-            .wf_svc()
-            .respond_activity_task_canceled(RespondActivityTaskCanceledRequest {
+        Ok(WorkflowService::respond_activity_task_canceled(
+            &mut self.inner.client.clone(),
+            RespondActivityTaskCanceledRequest {
                 task_token: task_token.0,
                 details,
                 identity: self.inner.options.identity.clone(),
                 namespace: self.namespace.clone(),
                 worker_version: None,
-            })
-            .await?
-            .into_inner())
+            },
+        )
+        .await?
+        .into_inner())
     }
 
     async fn fail_activity_task(
@@ -1052,9 +1110,9 @@ impl WorkflowClientTrait for Client {
         task_token: TaskToken,
         failure: Option<Failure>,
     ) -> Result<RespondActivityTaskFailedResponse> {
-        Ok(self
-            .wf_svc()
-            .respond_activity_task_failed(RespondActivityTaskFailedRequest {
+        Ok(WorkflowService::respond_activity_task_failed(
+            &mut self.inner.client.clone(),
+            RespondActivityTaskFailedRequest {
                 task_token: task_token.0,
                 failure,
                 identity: self.inner.options.identity.clone(),
@@ -1062,9 +1120,10 @@ impl WorkflowClientTrait for Client {
                 // TODO: Implement - https://github.com/temporalio/sdk-core/issues/293
                 last_heartbeat_details: None,
                 worker_version: None,
-            })
-            .await?
-            .into_inner())
+            },
+        )
+        .await?
+        .into_inner())
     }
 
     async fn signal_workflow_execution(
@@ -1075,9 +1134,9 @@ impl WorkflowClientTrait for Client {
         payloads: Option<Payloads>,
         request_id: Option<String>,
     ) -> Result<SignalWorkflowExecutionResponse> {
-        Ok(self
-            .wf_svc()
-            .signal_workflow_execution(SignalWorkflowExecutionRequest {
+        Ok(WorkflowService::signal_workflow_execution(
+            &mut self.inner.client.clone(),
+            SignalWorkflowExecutionRequest {
                 namespace: self.namespace.clone(),
                 workflow_execution: Some(WorkflowExecution {
                     workflow_id,
@@ -1088,9 +1147,10 @@ impl WorkflowClientTrait for Client {
                 identity: self.inner.options.identity.clone(),
                 request_id: request_id.unwrap_or_else(|| Uuid::new_v4().to_string()),
                 ..Default::default()
-            })
-            .await?
-            .into_inner())
+            },
+        )
+        .await?
+        .into_inner())
     }
 
     async fn signal_with_start_workflow_execution(
@@ -1098,9 +1158,9 @@ impl WorkflowClientTrait for Client {
         options: SignalWithStartOptions,
         workflow_options: WorkflowOptions,
     ) -> Result<SignalWithStartWorkflowExecutionResponse> {
-        Ok(self
-            .wf_svc()
-            .signal_with_start_workflow_execution(SignalWithStartWorkflowExecutionRequest {
+        Ok(WorkflowService::signal_with_start_workflow_execution(
+            &mut self.inner.client.clone(),
+            SignalWithStartWorkflowExecutionRequest {
                 namespace: self.namespace.clone(),
                 workflow_id: options.workflow_id,
                 workflow_type: Some(WorkflowType {
@@ -1122,9 +1182,7 @@ impl WorkflowClientTrait for Client {
                 workflow_execution_timeout: workflow_options
                     .execution_timeout
                     .and_then(|d| d.try_into().ok()),
-                workflow_run_timeout: workflow_options
-                    .execution_timeout
-                    .and_then(|d| d.try_into().ok()),
+                workflow_run_timeout: workflow_options.run_timeout.and_then(|d| d.try_into().ok()),
                 workflow_task_timeout: workflow_options
                     .task_timeout
                     .and_then(|d| d.try_into().ok()),
@@ -1134,9 +1192,10 @@ impl WorkflowClientTrait for Client {
                 cron_schedule: workflow_options.cron_schedule.unwrap_or_default(),
                 header: options.signal_header,
                 ..Default::default()
-            })
-            .await?
-            .into_inner())
+            },
+        )
+        .await?
+        .into_inner())
     }
 
     async fn query_workflow_execution(
@@ -1145,9 +1204,9 @@ impl WorkflowClientTrait for Client {
         run_id: String,
         query: WorkflowQuery,
     ) -> Result<QueryWorkflowResponse> {
-        Ok(self
-            .wf_svc()
-            .query_workflow(QueryWorkflowRequest {
+        Ok(WorkflowService::query_workflow(
+            &mut self.inner.client.clone(),
+            QueryWorkflowRequest {
                 namespace: self.namespace.clone(),
                 execution: Some(WorkflowExecution {
                     workflow_id,
@@ -1155,9 +1214,10 @@ impl WorkflowClientTrait for Client {
                 }),
                 query: Some(query),
                 query_reject_condition: 1,
-            })
-            .await?
-            .into_inner())
+            },
+        )
+        .await?
+        .into_inner())
     }
 
     async fn describe_workflow_execution(
@@ -1165,17 +1225,18 @@ impl WorkflowClientTrait for Client {
         workflow_id: String,
         run_id: Option<String>,
     ) -> Result<DescribeWorkflowExecutionResponse> {
-        Ok(self
-            .wf_svc()
-            .describe_workflow_execution(DescribeWorkflowExecutionRequest {
+        Ok(WorkflowService::describe_workflow_execution(
+            &mut self.inner.client.clone(),
+            DescribeWorkflowExecutionRequest {
                 namespace: self.namespace.clone(),
                 execution: Some(WorkflowExecution {
                     workflow_id,
                     run_id: run_id.unwrap_or_default(),
                 }),
-            })
-            .await?
-            .into_inner())
+            },
+        )
+        .await?
+        .into_inner())
     }
 
     async fn get_workflow_execution_history(
@@ -1184,9 +1245,9 @@ impl WorkflowClientTrait for Client {
         run_id: Option<String>,
         page_token: Vec<u8>,
     ) -> Result<GetWorkflowExecutionHistoryResponse> {
-        Ok(self
-            .wf_svc()
-            .get_workflow_execution_history(GetWorkflowExecutionHistoryRequest {
+        Ok(WorkflowService::get_workflow_execution_history(
+            &mut self.inner.client.clone(),
+            GetWorkflowExecutionHistoryRequest {
                 namespace: self.namespace.clone(),
                 execution: Some(WorkflowExecution {
                     workflow_id,
@@ -1194,9 +1255,10 @@ impl WorkflowClientTrait for Client {
                 }),
                 next_page_token: page_token,
                 ..Default::default()
-            })
-            .await?
-            .into_inner())
+            },
+        )
+        .await?
+        .into_inner())
     }
 
     async fn respond_legacy_query(
@@ -1205,17 +1267,18 @@ impl WorkflowClientTrait for Client {
         query_result: QueryResult,
     ) -> Result<RespondQueryTaskCompletedResponse> {
         let (_, completed_type, query_result, error_message) = query_result.into_components();
-        Ok(self
-            .wf_svc()
-            .respond_query_task_completed(RespondQueryTaskCompletedRequest {
+        Ok(WorkflowService::respond_query_task_completed(
+            &mut self.inner.client.clone(),
+            RespondQueryTaskCompletedRequest {
                 task_token: task_token.into(),
                 completed_type: completed_type as i32,
                 query_result,
                 error_message,
                 namespace: self.namespace.clone(),
-            })
-            .await?
-            .into_inner())
+            },
+        )
+        .await?
+        .into_inner())
     }
 
     async fn cancel_workflow_execution(
@@ -1225,9 +1288,9 @@ impl WorkflowClientTrait for Client {
         reason: String,
         request_id: Option<String>,
     ) -> Result<RequestCancelWorkflowExecutionResponse> {
-        Ok(self
-            .wf_svc()
-            .request_cancel_workflow_execution(RequestCancelWorkflowExecutionRequest {
+        Ok(WorkflowService::request_cancel_workflow_execution(
+            &mut self.inner.client.clone(),
+            RequestCancelWorkflowExecutionRequest {
                 namespace: self.namespace.clone(),
                 workflow_execution: Some(WorkflowExecution {
                     workflow_id,
@@ -1237,9 +1300,10 @@ impl WorkflowClientTrait for Client {
                 request_id: request_id.unwrap_or_else(|| Uuid::new_v4().to_string()),
                 first_execution_run_id: "".to_string(),
                 reason,
-            })
-            .await?
-            .into_inner())
+            },
+        )
+        .await?
+        .into_inner())
     }
 
     async fn terminate_workflow_execution(
@@ -1247,9 +1311,9 @@ impl WorkflowClientTrait for Client {
         workflow_id: String,
         run_id: Option<String>,
     ) -> Result<TerminateWorkflowExecutionResponse> {
-        Ok(self
-            .wf_svc()
-            .terminate_workflow_execution(TerminateWorkflowExecutionRequest {
+        Ok(WorkflowService::terminate_workflow_execution(
+            &mut self.inner.client.clone(),
+            TerminateWorkflowExecutionRequest {
                 namespace: self.namespace.clone(),
                 workflow_execution: Some(WorkflowExecution {
                     workflow_id,
@@ -1259,9 +1323,10 @@ impl WorkflowClientTrait for Client {
                 details: None,
                 identity: self.inner.options.identity.clone(),
                 first_execution_run_id: "".to_string(),
-            })
-            .await?
-            .into_inner())
+            },
+        )
+        .await?
+        .into_inner())
     }
 
     async fn register_namespace(
@@ -1269,23 +1334,29 @@ impl WorkflowClientTrait for Client {
         options: RegisterNamespaceOptions,
     ) -> Result<RegisterNamespaceResponse> {
         let req = Into::<RegisterNamespaceRequest>::into(options);
-        Ok(self.wf_svc().register_namespace(req).await?.into_inner())
+        Ok(
+            WorkflowService::register_namespace(&mut self.inner.client.clone(), req)
+                .await?
+                .into_inner(),
+        )
     }
 
     async fn list_namespaces(&self) -> Result<ListNamespacesResponse> {
-        Ok(self
-            .wf_svc()
-            .list_namespaces(ListNamespacesRequest::default())
-            .await?
-            .into_inner())
+        Ok(WorkflowService::list_namespaces(
+            &mut self.inner.client.clone(),
+            ListNamespacesRequest::default(),
+        )
+        .await?
+        .into_inner())
     }
 
     async fn describe_namespace(&self, namespace: Namespace) -> Result<DescribeNamespaceResponse> {
-        Ok(self
-            .wf_svc()
-            .describe_namespace(namespace.into_describe_namespace_request())
-            .await?
-            .into_inner())
+        Ok(WorkflowService::describe_namespace(
+            &mut self.inner.client.clone(),
+            namespace.into_describe_namespace_request(),
+        )
+        .await?
+        .into_inner())
     }
 
     async fn list_open_workflow_executions(
@@ -1295,17 +1366,18 @@ impl WorkflowClientTrait for Client {
         start_time_filter: Option<StartTimeFilter>,
         filters: Option<ListOpenFilters>,
     ) -> Result<ListOpenWorkflowExecutionsResponse> {
-        Ok(self
-            .wf_svc()
-            .list_open_workflow_executions(ListOpenWorkflowExecutionsRequest {
+        Ok(WorkflowService::list_open_workflow_executions(
+            &mut self.inner.client.clone(),
+            ListOpenWorkflowExecutionsRequest {
                 namespace: self.namespace.clone(),
                 maximum_page_size,
                 next_page_token,
                 start_time_filter,
                 filters,
-            })
-            .await?
-            .into_inner())
+            },
+        )
+        .await?
+        .into_inner())
     }
 
     async fn list_closed_workflow_executions(
@@ -1315,17 +1387,18 @@ impl WorkflowClientTrait for Client {
         start_time_filter: Option<StartTimeFilter>,
         filters: Option<ListClosedFilters>,
     ) -> Result<ListClosedWorkflowExecutionsResponse> {
-        Ok(self
-            .wf_svc()
-            .list_closed_workflow_executions(ListClosedWorkflowExecutionsRequest {
+        Ok(WorkflowService::list_closed_workflow_executions(
+            &mut self.inner.client.clone(),
+            ListClosedWorkflowExecutionsRequest {
                 namespace: self.namespace.clone(),
                 maximum_page_size,
                 next_page_token,
                 start_time_filter,
                 filters,
-            })
-            .await?
-            .into_inner())
+            },
+        )
+        .await?
+        .into_inner())
     }
 
     async fn list_workflow_executions(
@@ -1334,16 +1407,17 @@ impl WorkflowClientTrait for Client {
         next_page_token: Vec<u8>,
         query: String,
     ) -> Result<ListWorkflowExecutionsResponse> {
-        Ok(self
-            .wf_svc()
-            .list_workflow_executions(ListWorkflowExecutionsRequest {
+        Ok(WorkflowService::list_workflow_executions(
+            &mut self.inner.client.clone(),
+            ListWorkflowExecutionsRequest {
                 namespace: self.namespace.clone(),
                 page_size,
                 next_page_token,
                 query,
-            })
-            .await?
-            .into_inner())
+            },
+        )
+        .await?
+        .into_inner())
     }
 
     async fn list_archived_workflow_executions(
@@ -1352,24 +1426,61 @@ impl WorkflowClientTrait for Client {
         next_page_token: Vec<u8>,
         query: String,
     ) -> Result<ListArchivedWorkflowExecutionsResponse> {
-        Ok(self
-            .wf_svc()
-            .list_archived_workflow_executions(ListArchivedWorkflowExecutionsRequest {
+        Ok(WorkflowService::list_archived_workflow_executions(
+            &mut self.inner.client.clone(),
+            ListArchivedWorkflowExecutionsRequest {
                 namespace: self.namespace.clone(),
                 page_size,
                 next_page_token,
                 query,
-            })
-            .await?
-            .into_inner())
+            },
+        )
+        .await?
+        .into_inner())
     }
 
     async fn get_search_attributes(&self) -> Result<GetSearchAttributesResponse> {
-        Ok(self
-            .wf_svc()
-            .get_search_attributes(GetSearchAttributesRequest {})
-            .await?
-            .into_inner())
+        Ok(WorkflowService::get_search_attributes(
+            &mut self.inner.client.clone(),
+            GetSearchAttributesRequest {},
+        )
+        .await?
+        .into_inner())
+    }
+
+    async fn update_workflow_execution(
+        &self,
+        workflow_id: String,
+        run_id: String,
+        name: String,
+        wait_policy: update::v1::WaitPolicy,
+        args: Option<Payloads>,
+    ) -> Result<UpdateWorkflowExecutionResponse> {
+        Ok(WorkflowService::update_workflow_execution(
+            &mut self.inner.client.clone(),
+            UpdateWorkflowExecutionRequest {
+                namespace: self.namespace.clone(),
+                workflow_execution: Some(WorkflowExecution {
+                    workflow_id,
+                    run_id,
+                }),
+                wait_policy: Some(wait_policy),
+                request: Some(update::v1::Request {
+                    meta: Some(update::v1::Meta {
+                        update_id: "".into(),
+                        identity: self.inner.options.identity.clone(),
+                    }),
+                    input: Some(update::v1::Input {
+                        header: None,
+                        name,
+                        args,
+                    }),
+                }),
+                ..Default::default()
+            },
+        )
+        .await?
+        .into_inner())
     }
 
     fn get_options(&self) -> &ClientOptions {
@@ -1441,4 +1552,27 @@ mod tests {
         let next_req = iceptor.call(req).unwrap();
         assert_eq!(next_req.metadata().get("enchi").unwrap(), "cat");
     }
+
+    #[test]
+    fn keep_alive_defaults() {
+        let mut builder = ClientOptionsBuilder::default();
+        builder
+            .identity("enchicat".to_string())
+            .target_url(Url::parse("https://smolkitty").unwrap())
+            .client_name("cute-kitty".to_string())
+            .client_version("0.1.0".to_string());
+        // If unset, defaults to Some
+        let opts = builder.build().unwrap();
+        assert_eq!(
+            opts.keep_alive.clone().unwrap().interval,
+            ClientKeepAliveConfig::default().interval
+        );
+        assert_eq!(
+            opts.keep_alive.clone().unwrap().timeout,
+            ClientKeepAliveConfig::default().timeout
+        );
+        // But can be set to none
+        let opts = builder.keep_alive(None).build().unwrap();
+        assert!(opts.keep_alive.is_none());
+    }
 }