@temporalio/core-bridge 1.1.0 → 1.4.0

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

@@ -13,17 +13,25 @@ mod retry;
 mod workflow_handle;
 
 pub use crate::retry::{CallType, RetryClient, RETRYABLE_ERROR_CODES};
-pub use raw::WorkflowService;
+pub use raw::{HealthService, OperatorService, TestService, WorkflowService};
+pub use temporal_sdk_core_protos::temporal::api::{
+    filter::v1::{StartTimeFilter, StatusFilter, WorkflowExecutionFilter, WorkflowTypeFilter},
+    workflowservice::v1::{
+        list_closed_workflow_executions_request::Filters as ListClosedFilters,
+        list_open_workflow_executions_request::Filters as ListOpenFilters,
+    },
+};
 pub use workflow_handle::{WorkflowExecutionInfo, WorkflowExecutionResult};
 
 use crate::{
     metrics::{GrpcMetricSvc, MetricsContext},
     raw::{sealed::RawClientLike, AttachMetricLabels},
-    sealed::{RawClientLikeUser, WfHandleClient},
+    sealed::WfHandleClient,
     workflow_handle::UntypedWorkflowHandle,
 };
-use backoff::{ExponentialBackoff, SystemClock};
+use backoff::{exponential, ExponentialBackoff, SystemClock};
 use http::uri::InvalidUri;
+use once_cell::sync::OnceCell;
 use opentelemetry::metrics::Meter;
 use parking_lot::RwLock;
 use std::{
@@ -36,18 +44,23 @@ use std::{
 };
 use temporal_sdk_core_protos::{
     coresdk::{workflow_commands::QueryResult, IntoPayloadsExt},
+    grpc::health::v1::health_client::HealthClient,
     temporal::api::{
         command::v1::Command,
-        common::v1::{Payload, Payloads, WorkflowExecution, WorkflowType},
-        enums::v1::{TaskQueueKind, WorkflowTaskFailedCause},
+        common::v1::{Header, Payload, Payloads, WorkflowExecution, WorkflowType},
+        enums::v1::{TaskQueueKind, WorkflowIdReusePolicy, WorkflowTaskFailedCause},
         failure::v1::Failure,
-        query::v1::{WorkflowQuery, WorkflowQueryResult},
-        taskqueue::v1::{StickyExecutionAttributes, TaskQueue, TaskQueueMetadata},
+        operatorservice::v1::operator_service_client::OperatorServiceClient,
+        query::v1::WorkflowQuery,
+        taskqueue::v1::{StickyExecutionAttributes, TaskQueue},
+        testservice::v1::test_service_client::TestServiceClient,
         workflowservice::v1::{workflow_service_client::WorkflowServiceClient, *},
     },
     TaskToken,
 };
 use tonic::{
+    body::BoxBody,
+    client::GrpcService,
     codegen::InterceptedService,
     metadata::{MetadataKey, MetadataValue},
     service::Interceptor,
@@ -58,6 +71,9 @@ use tower::ServiceBuilder;
 use url::Url;
 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"];
 /// 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);
@@ -164,20 +180,24 @@ impl RetryConfig {
             max_retries: 0,
         }
     }
+
+    pub(crate) fn into_exp_backoff<C>(self, clock: C) -> exponential::ExponentialBackoff<C> {
+        exponential::ExponentialBackoff {
+            current_interval: self.initial_interval,
+            initial_interval: self.initial_interval,
+            randomization_factor: self.randomization_factor,
+            multiplier: self.multiplier,
+            max_interval: self.max_interval,
+            max_elapsed_time: self.max_elapsed_time,
+            clock,
+            start_time: Instant::now(),
+        }
+    }
 }
 
 impl From<RetryConfig> for ExponentialBackoff {
     fn from(c: RetryConfig) -> Self {
-        Self {
-            current_interval: c.initial_interval,
-            initial_interval: c.initial_interval,
-            randomization_factor: c.randomization_factor,
-            multiplier: c.multiplier,
-            max_interval: c.max_interval,
-            max_elapsed_time: c.max_elapsed_time,
-            clock: SystemClock::default(),
-            start_time: Instant::now(),
-        }
+        c.into_exp_backoff(SystemClock::default())
     }
 }
 
@@ -203,51 +223,12 @@ pub enum ClientInitError {
     SystemInfoCallError(tonic::Status),
 }
 
-#[doc(hidden)]
-/// Allows passing different kinds of clients into things that want to be flexible. Motivating
-/// use-case was worker initialization.
-///
-/// Needs to exist in this crate to avoid blanket impl conflicts.
-pub enum AnyClient {
-    /// A high level client, like the type workers work with
-    HighLevel(Arc<dyn WorkflowClientTrait + Send + Sync>),
-    /// A low level gRPC client, wrapped with the typical interceptors
-    LowLevel(Box<ConfiguredClient<WorkflowServiceClientWithMetrics>>),
-}
-
-impl<SGA> From<SGA> for AnyClient
-where
-    SGA: WorkflowClientTrait + Send + Sync + 'static,
-{
-    fn from(s: SGA) -> Self {
-        Self::HighLevel(Arc::new(s))
-    }
-}
-impl<SGA> From<Arc<SGA>> for AnyClient
-where
-    SGA: WorkflowClientTrait + Send + Sync + 'static,
-{
-    fn from(s: Arc<SGA>) -> Self {
-        Self::HighLevel(s)
-    }
-}
-impl From<RetryClient<ConfiguredClient<WorkflowServiceClientWithMetrics>>> for AnyClient {
-    fn from(c: RetryClient<ConfiguredClient<WorkflowServiceClientWithMetrics>>) -> Self {
-        Self::LowLevel(Box::new(c.into_inner()))
-    }
-}
-impl From<ConfiguredClient<WorkflowServiceClientWithMetrics>> for AnyClient {
-    fn from(c: ConfiguredClient<WorkflowServiceClientWithMetrics>) -> Self {
-        Self::LowLevel(Box::new(c))
-    }
-}
-
 /// A client with [ClientOptions] attached, which can be passed to initialize workers,
-/// or can be used directly.
+/// or can be used directly. Is cheap to clone.
 #[derive(Clone, Debug)]
 pub struct ConfiguredClient<C> {
     client: C,
-    options: ClientOptions,
+    options: Arc<ClientOptions>,
     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>,
@@ -270,11 +251,6 @@ impl<C> ConfiguredClient<C> {
     pub fn capabilities(&self) -> Option<&get_system_info_response::Capabilities> {
         self.capabilities.as_ref()
     }
-
-    /// De-constitute this type
-    pub fn into_parts(self) -> (C, ClientOptions) {
-        (self.client, self.options)
-    }
 }
 
 // The configured client is effectively a "smart" (dumb) pointer
@@ -317,7 +293,7 @@ impl ClientOptions {
         &self,
         metrics_meter: Option<&Meter>,
         headers: Option<Arc<RwLock<HashMap<String, String>>>>,
-    ) -> Result<RetryClient<ConfiguredClient<WorkflowServiceClientWithMetrics>>, ClientInitError>
+    ) -> Result<RetryClient<ConfiguredClient<TemporalServiceClientWithMetrics>>, ClientInitError>
     {
         let channel = Channel::from_shared(self.target_url.to_string())?;
         let channel = self.add_tls_to_channel(channel).await?;
@@ -333,11 +309,12 @@ impl ClientOptions {
             opts: self.clone(),
             headers: headers.clone(),
         };
+        let svc = InterceptedService::new(service, interceptor);
 
         let mut client = ConfiguredClient {
             headers,
-            client: WorkflowServiceClient::with_interceptor(service, interceptor),
-            options: self.clone(),
+            client: TemporalServiceClient::new(svc),
+            options: Arc::new(self.clone()),
             capabilities: None,
         };
         match client
@@ -416,27 +393,35 @@ impl Interceptor for ServiceCallInterceptor {
     /// cancel the request and have that status returned to the caller.
     fn call(&mut self, mut request: tonic::Request<()>) -> Result<tonic::Request<()>, Status> {
         let metadata = request.metadata_mut();
-        metadata.insert(
-            "client-name",
-            self.opts
-                .client_name
-                .parse()
-                .unwrap_or_else(|_| MetadataValue::from_static("")),
-        );
-        metadata.insert(
-            "client-version",
-            self.opts
-                .client_version
-                .parse()
-                .unwrap_or_else(|_| MetadataValue::from_static("")),
-        );
+        if !metadata.contains_key(CLIENT_NAME_HEADER_KEY) {
+            metadata.insert(
+                CLIENT_NAME_HEADER_KEY,
+                self.opts
+                    .client_name
+                    .parse()
+                    .unwrap_or_else(|_| MetadataValue::from_static("")),
+            );
+        }
+        if !metadata.contains_key(CLIENT_VERSION_HEADER_KEY) {
+            metadata.insert(
+                CLIENT_VERSION_HEADER_KEY,
+                self.opts
+                    .client_version
+                    .parse()
+                    .unwrap_or_else(|_| MetadataValue::from_static("")),
+            );
+        }
         let headers = &*self.headers.read();
         for (k, v) in headers {
-            if let (Ok(k), Ok(v)) = (MetadataKey::from_str(k), MetadataValue::from_str(v)) {
+            if metadata.contains_key(k) {
+                // Don't overwrite per-request specified headers
+                continue;
+            }
+            if let (Ok(k), Ok(v)) = (MetadataKey::from_str(k), v.parse()) {
                 metadata.insert(k, v);
             }
         }
-        if metadata.get("grpc-timeout").is_none() {
+        if !metadata.contains_key("grpc-timeout") {
             request.set_timeout(OTHER_CALL_TIMEOUT);
         }
 
@@ -444,15 +429,88 @@ impl Interceptor for ServiceCallInterceptor {
     }
 }
 
+/// Aggregates various services exposed by the Temporal server
+#[derive(Debug, Clone)]
+pub struct TemporalServiceClient<T> {
+    svc: T,
+    workflow_svc_client: OnceCell<WorkflowServiceClient<T>>,
+    operator_svc_client: OnceCell<OperatorServiceClient<T>>,
+    test_svc_client: OnceCell<TestServiceClient<T>>,
+    health_svc_client: OnceCell<HealthClient<T>>,
+}
+impl<T> TemporalServiceClient<T>
+where
+    T: Clone,
+    T: GrpcService<BoxBody> + Send + Clone + 'static,
+    T::ResponseBody: tonic::codegen::Body<Data = tonic::codegen::Bytes> + Send + 'static,
+    T::Error: Into<tonic::codegen::StdError>,
+    <T::ResponseBody as tonic::codegen::Body>::Error: Into<tonic::codegen::StdError> + Send,
+{
+    fn new(svc: T) -> Self {
+        Self {
+            svc,
+            workflow_svc_client: OnceCell::new(),
+            operator_svc_client: OnceCell::new(),
+            test_svc_client: OnceCell::new(),
+            health_svc_client: OnceCell::new(),
+        }
+    }
+    /// Get the underlying workflow service client
+    pub fn workflow_svc(&self) -> &WorkflowServiceClient<T> {
+        self.workflow_svc_client
+            .get_or_init(|| WorkflowServiceClient::new(self.svc.clone()))
+    }
+    /// Get the underlying operator service client
+    pub fn operator_svc(&self) -> &OperatorServiceClient<T> {
+        self.operator_svc_client
+            .get_or_init(|| OperatorServiceClient::new(self.svc.clone()))
+    }
+    /// Get the underlying test service client
+    pub fn test_svc(&self) -> &TestServiceClient<T> {
+        self.test_svc_client
+            .get_or_init(|| TestServiceClient::new(self.svc.clone()))
+    }
+    /// Get the underlying health service client
+    pub fn health_svc(&self) -> &HealthClient<T> {
+        self.health_svc_client
+            .get_or_init(|| HealthClient::new(self.svc.clone()))
+    }
+    /// Get the underlying workflow service client mutably
+    pub fn workflow_svc_mut(&mut self) -> &mut WorkflowServiceClient<T> {
+        let _ = self.workflow_svc();
+        self.workflow_svc_client.get_mut().unwrap()
+    }
+    /// Get the underlying operator service client mutably
+    pub fn operator_svc_mut(&mut self) -> &mut OperatorServiceClient<T> {
+        let _ = self.operator_svc();
+        self.operator_svc_client.get_mut().unwrap()
+    }
+    /// Get the underlying test service client mutably
+    pub fn test_svc_mut(&mut self) -> &mut TestServiceClient<T> {
+        let _ = self.test_svc();
+        self.test_svc_client.get_mut().unwrap()
+    }
+    /// Get the underlying health service client mutably
+    pub fn health_svc_mut(&mut self) -> &mut HealthClient<T> {
+        let _ = self.health_svc();
+        self.health_svc_client.get_mut().unwrap()
+    }
+}
 /// A [WorkflowServiceClient] with the default interceptors attached.
 pub type WorkflowServiceClientWithMetrics = WorkflowServiceClient<InterceptedMetricsSvc>;
+/// An [OperatorServiceClient] with the default interceptors attached.
+pub type OperatorServiceClientWithMetrics = OperatorServiceClient<InterceptedMetricsSvc>;
+/// An [TestServiceClient] with the default interceptors attached.
+pub type TestServiceClientWithMetrics = TestServiceClient<InterceptedMetricsSvc>;
+/// A [TemporalServiceClient] with the default interceptors attached.
+pub type TemporalServiceClientWithMetrics = TemporalServiceClient<InterceptedMetricsSvc>;
 type InterceptedMetricsSvc = InterceptedService<GrpcMetricSvc, ServiceCallInterceptor>;
 
 /// Contains an instance of a namespace-bound client for interacting with the Temporal server
 #[derive(Debug, Clone)]
 pub struct Client {
     /// Client for interacting with workflow service
-    inner: ConfiguredClient<WorkflowServiceClientWithMetrics>,
+    inner: ConfiguredClient<TemporalServiceClientWithMetrics>,
     /// The namespace this client interacts with
     namespace: String,
     /// If set, attach as the worker build id to relevant calls
@@ -462,7 +520,7 @@ pub struct Client {
 impl Client {
     /// Create a new client from an existing configured lower level client and a namespace
     pub fn new(
-        client: ConfiguredClient<WorkflowServiceClientWithMetrics>,
+        client: ConfiguredClient<TemporalServiceClientWithMetrics>,
         namespace: String,
     ) -> Self {
         Client {
@@ -489,7 +547,7 @@ impl Client {
     /// Note that it is reasonably cheap to clone the returned type if you need to own it. Such
     /// clones will keep re-using the same channel.
     pub fn raw_client(&self) -> &WorkflowServiceClientWithMetrics {
-        self.inner.deref()
+        self.inner.workflow_svc()
     }
 
     /// Return the options this client was initialized with
@@ -499,7 +557,7 @@ impl Client {
 
     /// Return the options this client was initialized with mutably
     pub fn options_mut(&mut self) -> &mut ClientOptions {
-        &mut self.inner.options
+        Arc::make_mut(&mut self.inner.options)
     }
 
     /// Set a worker build id to be attached to relevant requests. Unlikely to be useful outside
@@ -507,6 +565,39 @@ impl Client {
     pub fn set_worker_build_id(&mut self, id: String) {
         self.bound_worker_build_id = Some(id)
     }
+
+    /// Returns a reference to the underlying client
+    pub fn inner(&self) -> &ConfiguredClient<TemporalServiceClientWithMetrics> {
+        &self.inner
+    }
+
+    /// Consumes self and returns the underlying 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
+#[derive(Clone)]
+pub enum Namespace {
+    /// Namespace name
+    Name(String),
+    /// Namespace id
+    Id(String),
+}
+
+impl Namespace {
+    fn into_describe_namespace_request(self) -> DescribeNamespaceRequest {
+        let (namespace, id) = match self {
+            Namespace::Name(n) => (n, "".to_owned()),
+            Namespace::Id(n) => ("".to_owned(), n),
+        };
+        DescribeNamespaceRequest { namespace, id }
+    }
 }
 
 /// This trait provides higher-level friendlier interaction with the server.
@@ -521,25 +612,10 @@ pub trait WorkflowClientTrait {
         task_queue: String,
         workflow_id: String,
         workflow_type: String,
+        request_id: Option<String>,
         options: WorkflowOptions,
     ) -> Result<StartWorkflowExecutionResponse>;
 
-    /// Fetch new workflow tasks from the provided queue. Should block indefinitely if there is no
-    /// work.
-    async fn poll_workflow_task(
-        &self,
-        task_queue: String,
-        is_sticky: bool,
-    ) -> Result<PollWorkflowTaskQueueResponse>;
-
-    /// Fetch new activity tasks from the provided queue. Should block indefinitely if there is no
-    /// work.
-    async fn poll_activity_task(
-        &self,
-        task_queue: String,
-        max_tasks_per_sec: Option<f64>,
-    ) -> Result<PollActivityTaskQueueResponse>;
-
     /// Notifies the server that workflow tasks for a given workflow should be sent to the normal
     /// non-sticky task queue. This normally happens when workflow has been evicted from the cache.
     async fn reset_sticky_task_queue(
@@ -548,12 +624,6 @@ pub trait WorkflowClientTrait {
         run_id: String,
     ) -> Result<ResetStickyTaskQueueResponse>;
 
-    /// Complete a workflow activation.
-    async fn complete_workflow_task(
-        &self,
-        request: WorkflowTaskCompletion,
-    ) -> Result<RespondWorkflowTaskCompletedResponse>;
-
     /// Complete activity task by sending response to the server. `task_token` contains activity
     /// identifier that would've been received from polling for an activity task. `result` is a blob
     /// that contains activity response.
@@ -607,6 +677,7 @@ pub trait WorkflowClientTrait {
         run_id: String,
         signal_name: String,
         payloads: Option<Payloads>,
+        request_id: Option<String>,
     ) -> Result<SignalWorkflowExecutionResponse>;
 
     /// Send signal and start workflow transcationally
@@ -618,9 +689,11 @@ pub trait WorkflowClientTrait {
         task_queue: String,
         workflow_id: String,
         workflow_type: String,
+        request_id: Option<String>,
         options: WorkflowOptions,
         signal_name: String,
         signal_input: Option<Payloads>,
+        signal_header: Option<Header>,
     ) -> Result<SignalWithStartWorkflowExecutionResponse>;
 
     /// Request a query of a certain workflow instance
@@ -659,6 +732,7 @@ pub trait WorkflowClientTrait {
         workflow_id: String,
         run_id: Option<String>,
         reason: String,
+        request_id: Option<String>,
     ) -> Result<RequestCancelWorkflowExecutionResponse>;
 
     /// Terminate a currently executing workflow
@@ -671,6 +745,35 @@ pub trait WorkflowClientTrait {
     /// Lists all available namespaces
     async fn list_namespaces(&self) -> Result<ListNamespacesResponse>;
 
+    /// Query namespace details
+    async fn describe_namespace(&self, namespace: Namespace) -> Result<DescribeNamespaceResponse>;
+
+    /// List open workflows with Standard Visibility filtering
+    async fn list_open_workflow_executions(
+        &self,
+        max_page_size: i32,
+        next_page_token: Vec<u8>,
+        start_time_filter: Option<StartTimeFilter>,
+        filters: Option<ListOpenFilters>,
+    ) -> Result<ListOpenWorkflowExecutionsResponse>;
+
+    /// List closed workflows Standard Visibility filtering
+    async fn list_closed_workflow_executions(
+        &self,
+        max_page_size: i32,
+        next_page_token: Vec<u8>,
+        start_time_filter: Option<StartTimeFilter>,
+        filters: Option<ListClosedFilters>,
+    ) -> Result<ListClosedWorkflowExecutionsResponse>;
+
+    /// List workflows with Advanced Visibility filtering
+    async fn list_workflow_executions(
+        &self,
+        max_page_size: i32,
+        next_page_token: Vec<u8>,
+        query: String,
+    ) -> Result<ListWorkflowExecutionsResponse>;
+
     /// Returns options that were used to initialize the client
     fn get_options(&self) -> &ClientOptions;
 
@@ -681,9 +784,22 @@ pub trait WorkflowClientTrait {
 /// Optional fields supplied at the start of workflow execution
 #[derive(Debug, Clone, Default)]
 pub struct WorkflowOptions {
-    /// Optionally indicates the default task timeout for workflow tasks
+    /// Set the policy for reusing the workflow id
+    pub id_reuse_policy: WorkflowIdReusePolicy,
+
+    /// Optionally set the execution timeout for the workflow
+    /// <https://docs.temporal.io/workflows/#workflow-execution-timeout>
+    pub execution_timeout: Option<Duration>,
+
+    /// Optionally indicates the default run timeout for a workflow run
+    pub run_timeout: Option<Duration>,
+
+    /// Optionally indicates the default task timeout for a workflow run
     pub task_timeout: Option<Duration>,
 
+    /// Optionally set a cron schedule for the workflow
+    pub cron_schedule: Option<String>,
+
     /// Optionally associate extra search attributes with a workflow
     pub search_attributes: Option<HashMap<String, Payload>>,
 }
@@ -696,10 +812,9 @@ impl WorkflowClientTrait for Client {
         task_queue: String,
         workflow_id: String,
         workflow_type: String,
+        request_id: Option<String>,
         options: WorkflowOptions,
     ) -> Result<StartWorkflowExecutionResponse> {
-        let request_id = Uuid::new_v4().to_string();
-
         Ok(self
             .wf_svc()
             .start_workflow_execution(StartWorkflowExecutionRequest {
@@ -713,65 +828,21 @@ impl WorkflowClientTrait for Client {
                     name: task_queue,
                     kind: TaskQueueKind::Unspecified as i32,
                 }),
-                request_id,
-                workflow_task_timeout: options.task_timeout.map(Into::into),
-                search_attributes: options.search_attributes.map(Into::into),
+                request_id: request_id.unwrap_or_else(|| Uuid::new_v4().to_string()),
+                workflow_id_reuse_policy: options.id_reuse_policy as i32,
+                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_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(),
                 ..Default::default()
             })
             .await?
             .into_inner())
     }
 
-    async fn poll_workflow_task(
-        &self,
-        task_queue: String,
-        is_sticky: bool,
-    ) -> Result<PollWorkflowTaskQueueResponse> {
-        let request = PollWorkflowTaskQueueRequest {
-            namespace: self.namespace.clone(),
-            task_queue: Some(TaskQueue {
-                name: task_queue,
-                kind: if is_sticky {
-                    TaskQueueKind::Sticky
-                } else {
-                    TaskQueueKind::Normal
-                } as i32,
-            }),
-            identity: self.inner.options.identity.clone(),
-            binary_checksum: self.bound_worker_build_id.clone().unwrap_or_default(),
-        };
-
-        Ok(self
-            .wf_svc()
-            .poll_workflow_task_queue(request)
-            .await?
-            .into_inner())
-    }
-
-    async fn poll_activity_task(
-        &self,
-        task_queue: String,
-        max_tasks_per_sec: Option<f64>,
-    ) -> Result<PollActivityTaskQueueResponse> {
-        let request = PollActivityTaskQueueRequest {
-            namespace: self.namespace.clone(),
-            task_queue: Some(TaskQueue {
-                name: task_queue,
-                kind: TaskQueueKind::Normal as i32,
-            }),
-            identity: self.inner.options.identity.clone(),
-            task_queue_metadata: max_tasks_per_sec.map(|tps| TaskQueueMetadata {
-                max_tasks_per_second: Some(tps),
-            }),
-        };
-
-        Ok(self
-            .wf_svc()
-            .poll_activity_task_queue(request)
-            .await?
-            .into_inner())
-    }
-
     async fn reset_sticky_task_queue(
         &self,
         workflow_id: String,
@@ -791,42 +862,6 @@ impl WorkflowClientTrait for Client {
             .into_inner())
     }
 
-    async fn complete_workflow_task(
-        &self,
-        request: WorkflowTaskCompletion,
-    ) -> Result<RespondWorkflowTaskCompletedResponse> {
-        let request = RespondWorkflowTaskCompletedRequest {
-            task_token: request.task_token.into(),
-            commands: request.commands,
-            identity: self.inner.options.identity.clone(),
-            sticky_attributes: request.sticky_attributes,
-            return_new_workflow_task: request.return_new_workflow_task,
-            force_create_new_workflow_task: request.force_create_new_workflow_task,
-            binary_checksum: self.bound_worker_build_id.clone().unwrap_or_default(),
-            query_results: request
-                .query_responses
-                .into_iter()
-                .map(|qr| {
-                    let (id, completed_type, query_result, error_message) = qr.into_components();
-                    (
-                        id,
-                        WorkflowQueryResult {
-                            result_type: completed_type as i32,
-                            answer: query_result,
-                            error_message,
-                        },
-                    )
-                })
-                .collect(),
-            namespace: self.namespace.clone(),
-        };
-        Ok(self
-            .wf_svc()
-            .respond_workflow_task_completed(request)
-            .await?
-            .into_inner())
-    }
-
     async fn complete_activity_task(
         &self,
         task_token: TaskToken,
@@ -924,6 +959,7 @@ impl WorkflowClientTrait for Client {
         run_id: String,
         signal_name: String,
         payloads: Option<Payloads>,
+        request_id: Option<String>,
     ) -> Result<SignalWorkflowExecutionResponse> {
         Ok(self
             .wf_svc()
@@ -936,6 +972,7 @@ impl WorkflowClientTrait for Client {
                 signal_name,
                 input: payloads,
                 identity: self.inner.options.identity.clone(),
+                request_id: request_id.unwrap_or_else(|| Uuid::new_v4().to_string()),
                 ..Default::default()
             })
             .await?
@@ -948,11 +985,12 @@ impl WorkflowClientTrait for Client {
         task_queue: String,
         workflow_id: String,
         workflow_type: String,
+        request_id: Option<String>,
         options: WorkflowOptions,
         signal_name: String,
         signal_input: Option<Payloads>,
+        signal_header: Option<Header>,
     ) -> Result<SignalWithStartWorkflowExecutionResponse> {
-        let request_id = Uuid::new_v4().to_string();
         Ok(self
             .wf_svc()
             .signal_with_start_workflow_execution(SignalWithStartWorkflowExecutionRequest {
@@ -965,13 +1003,20 @@ impl WorkflowClientTrait for Client {
                     name: task_queue,
                     kind: TaskQueueKind::Normal as i32,
                 }),
-                request_id,
                 input,
                 signal_name,
                 signal_input,
                 identity: self.inner.options.identity.clone(),
-                workflow_task_timeout: options.task_timeout.map(Into::into),
-                search_attributes: options.search_attributes.map(Into::into),
+                request_id: request_id.unwrap_or_else(|| Uuid::new_v4().to_string()),
+                workflow_id_reuse_policy: options.id_reuse_policy as i32,
+                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_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(),
+                header: signal_header,
                 ..Default::default()
             })
             .await?
@@ -1062,6 +1107,7 @@ impl WorkflowClientTrait for Client {
         workflow_id: String,
         run_id: Option<String>,
         reason: String,
+        request_id: Option<String>,
     ) -> Result<RequestCancelWorkflowExecutionResponse> {
         Ok(self
             .wf_svc()
@@ -1072,7 +1118,7 @@ impl WorkflowClientTrait for Client {
                     run_id: run_id.unwrap_or_default(),
                 }),
                 identity: self.inner.options.identity.clone(),
-                request_id: "".to_string(),
+                request_id: request_id.unwrap_or_else(|| Uuid::new_v4().to_string()),
                 first_execution_run_id: "".to_string(),
                 reason,
             })
@@ -1110,6 +1156,72 @@ impl WorkflowClientTrait for Client {
             .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())
+    }
+
+    async fn list_open_workflow_executions(
+        &self,
+        maximum_page_size: i32,
+        next_page_token: Vec<u8>,
+        start_time_filter: Option<StartTimeFilter>,
+        filters: Option<ListOpenFilters>,
+    ) -> Result<ListOpenWorkflowExecutionsResponse> {
+        Ok(self
+            .wf_svc()
+            .list_open_workflow_executions(ListOpenWorkflowExecutionsRequest {
+                namespace: self.namespace.clone(),
+                maximum_page_size,
+                next_page_token,
+                start_time_filter,
+                filters,
+            })
+            .await?
+            .into_inner())
+    }
+
+    async fn list_closed_workflow_executions(
+        &self,
+        maximum_page_size: i32,
+        next_page_token: Vec<u8>,
+        start_time_filter: Option<StartTimeFilter>,
+        filters: Option<ListClosedFilters>,
+    ) -> Result<ListClosedWorkflowExecutionsResponse> {
+        Ok(self
+            .wf_svc()
+            .list_closed_workflow_executions(ListClosedWorkflowExecutionsRequest {
+                namespace: self.namespace.clone(),
+                maximum_page_size,
+                next_page_token,
+                start_time_filter,
+                filters,
+            })
+            .await?
+            .into_inner())
+    }
+
+    async fn list_workflow_executions(
+        &self,
+        page_size: i32,
+        next_page_token: Vec<u8>,
+        query: String,
+    ) -> Result<ListWorkflowExecutionsResponse> {
+        Ok(self
+            .wf_svc()
+            .list_workflow_executions(ListWorkflowExecutionsRequest {
+                namespace: self.namespace.clone(),
+                page_size,
+                next_page_token,
+                query,
+            })
+            .await?
+            .into_inner())
+    }
+
     fn get_options(&self) -> &ClientOptions {
         &self.inner.options
     }
@@ -1122,39 +1234,28 @@ impl WorkflowClientTrait for Client {
 mod sealed {
     use crate::{InterceptedMetricsSvc, RawClientLike, WorkflowClientTrait};
 
-    pub trait RawClientLikeUser {
-        type RawClientT: RawClientLike<SvcType = InterceptedMetricsSvc>;
-        /// Used to access the client as a [WorkflowService] implementor rather than the raw struct
-        fn wf_svc(&self) -> Self::RawClientT;
+    pub trait WfHandleClient:
+        WorkflowClientTrait + RawClientLike<SvcType = InterceptedMetricsSvc>
+    {
     }
-
-    pub trait WfHandleClient: WorkflowClientTrait + RawClientLikeUser {}
-    impl<T> WfHandleClient for T where T: WorkflowClientTrait + RawClientLikeUser {}
-}
-
-impl RawClientLikeUser for Client {
-    type RawClientT = WorkflowServiceClientWithMetrics;
-
-    fn wf_svc(&self) -> Self::RawClientT {
-        self.raw_client().clone()
+    impl<T> WfHandleClient for T where
+        T: WorkflowClientTrait + RawClientLike<SvcType = InterceptedMetricsSvc>
+    {
     }
 }
 
 /// Additional methods for workflow clients
-pub trait WfClientExt: WfHandleClient + Sized {
+pub trait WfClientExt: WfHandleClient + Sized + Clone {
     /// Create an untyped handle for a workflow execution, which can be used to do things like
     /// wait for that workflow's result. `run_id` may be left blank to target the latest run.
     fn get_untyped_workflow_handle(
         &self,
         workflow_id: impl Into<String>,
         run_id: impl Into<String>,
-    ) -> UntypedWorkflowHandle<Self::RawClientT>
-    where
-        Self::RawClientT: Clone,
-    {
+    ) -> UntypedWorkflowHandle<Self> {
         let rid = run_id.into();
         UntypedWorkflowHandle::new(
-            self.wf_svc(),
+            self.clone(),
             WorkflowExecutionInfo {
                 namespace: self.namespace().to_string(),
                 workflow_id: workflow_id.into(),
@@ -1163,4 +1264,31 @@ pub trait WfClientExt: WfHandleClient + Sized {
         )
     }
 }
-impl<T> WfClientExt for T where T: WfHandleClient + Sized {}
+impl<T> WfClientExt for T where T: WfHandleClient + Clone + Sized {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn respects_per_call_headers() {
+        let opts = ClientOptionsBuilder::default()
+            .identity("enchicat".to_string())
+            .target_url(Url::parse("https://smolkitty").unwrap())
+            .client_name("cute-kitty".to_string())
+            .client_version("0.1.0".to_string())
+            .build()
+            .unwrap();
+
+        let mut static_headers = HashMap::new();
+        static_headers.insert("enchi".to_string(), "kitty".to_string());
+        let mut iceptor = ServiceCallInterceptor {
+            opts,
+            headers: Arc::new(RwLock::new(static_headers)),
+        };
+        let mut req = tonic::Request::new(());
+        req.metadata_mut().insert("enchi", "cat".parse().unwrap());
+        let next_req = iceptor.call(req).unwrap();
+        assert_eq!(next_req.metadata().get("enchi").unwrap(), "cat");
+    }
+}