@temporalio/core-bridge 1.13.0 → 1.13.2

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

@@ -3,14 +3,14 @@
 //! happen.
 
 use crate::{
-    Client, ConfiguredClient, InterceptedMetricsSvc, LONG_POLL_TIMEOUT, RequestExt, RetryClient,
+    Client, ConfiguredClient, LONG_POLL_TIMEOUT, RequestExt, RetryClient, SharedReplaceableClient,
     TEMPORAL_NAMESPACE_HEADER_KEY, TemporalServiceClient,
-    metrics::{namespace_kv, task_queue_kv},
-    raw::sealed::RawClientLike,
+    metrics::namespace_kv,
     worker_registry::{Slot, SlotManager},
 };
+use dyn_clone::DynClone;
 use futures_util::{FutureExt, TryFutureExt, future::BoxFuture};
-use std::sync::Arc;
+use std::{any::Any, marker::PhantomData, sync::Arc};
 use temporal_sdk_core_api::telemetry::metrics::MetricKeyValue;
 use temporal_sdk_core_protos::{
     grpc::health::v1::{health_client::HealthClient, *},
@@ -29,115 +29,182 @@ use tonic::{
     metadata::{AsciiMetadataValue, KeyAndValueRef},
 };
 
-pub(super) mod sealed {
-    use super::*;
-
-    /// Something that has access to the raw grpc services
-    #[async_trait::async_trait]
-    pub trait RawClientLike: Send {
-        type SvcType: Send + Sync + Clone + 'static;
-
-        /// Return a ref to the workflow service client instance
-        fn workflow_client(&self) -> &WorkflowServiceClient<Self::SvcType>;
+/// Something that has access to the raw grpc services
+trait RawClientProducer {
+    /// Returns information about workers associated with this client. Implementers outside of
+    /// core can safely return `None`.
+    fn get_workers_info(&self) -> Option<Arc<SlotManager>>;
 
-        /// Return a mutable ref to the workflow service client instance
-        fn workflow_client_mut(&mut self) -> &mut WorkflowServiceClient<Self::SvcType>;
+    /// Return a workflow service client instance
+    fn workflow_client(&mut self) -> Box<dyn WorkflowService>;
 
-        /// Return a ref to the operator service client instance
-        fn operator_client(&self) -> &OperatorServiceClient<Self::SvcType>;
+    /// Return a mutable ref to the operator service client instance
+    fn operator_client(&mut self) -> Box<dyn OperatorService>;
 
-        /// Return a mutable ref to the operator service client instance
-        fn operator_client_mut(&mut self) -> &mut OperatorServiceClient<Self::SvcType>;
+    /// Return a mutable ref to the cloud service client instance
+    fn cloud_client(&mut self) -> Box<dyn CloudService>;
 
-        /// Return a ref to the cloud service client instance
-        fn cloud_client(&self) -> &CloudServiceClient<Self::SvcType>;
+    /// Return a mutable ref to the test service client instance
+    fn test_client(&mut self) -> Box<dyn TestService>;
 
-        /// Return a mutable ref to the cloud service client instance
-        fn cloud_client_mut(&mut self) -> &mut CloudServiceClient<Self::SvcType>;
-
-        /// Return a ref to the test service client instance
-        fn test_client(&self) -> &TestServiceClient<Self::SvcType>;
+    /// Return a mutable ref to the health service client instance
+    fn health_client(&mut self) -> Box<dyn HealthService>;
+}
 
-        /// Return a mutable ref to the test service client instance
-        fn test_client_mut(&mut self) -> &mut TestServiceClient<Self::SvcType>;
+/// Any client that can make gRPC calls. The default implementation simply invokes the passed-in
+/// function. Implementers may override this to provide things like retry behavior, ex:
+/// [RetryClient].
+#[async_trait::async_trait]
+trait RawGrpcCaller: Send + Sync + 'static {
+    async fn call<F, Req, Resp>(
+        &mut self,
+        _call_name: &'static str,
+        mut callfn: F,
+        req: Request<Req>,
+    ) -> Result<Response<Resp>, Status>
+    where
+        Req: Clone + Unpin + Send + Sync + 'static,
+        Resp: Send + 'static,
+        F: Send + Sync + Unpin + 'static,
+        for<'a> F:
+            FnMut(&'a mut Self, Request<Req>) -> BoxFuture<'static, Result<Response<Resp>, Status>>,
+    {
+        callfn(self, req).await
+    }
+}
 
-        /// Return a ref to the health service client instance
-        fn health_client(&self) -> &HealthClient<Self::SvcType>;
+trait ErasedRawClient: Send + Sync + 'static {
+    fn erased_call(
+        &mut self,
+        call_name: &'static str,
+        op: &mut dyn ErasedCallOp,
+    ) -> BoxFuture<'static, Result<Response<Box<dyn Any + Send>>, Status>>;
+}
 
-        /// Return a mutable ref to the health service client instance
-        fn health_client_mut(&mut self) -> &mut HealthClient<Self::SvcType>;
+trait ErasedCallOp: Send {
+    fn invoke(
+        &mut self,
+        raw: &mut dyn ErasedRawClient,
+        call_name: &'static str,
+    ) -> BoxFuture<'static, Result<Response<Box<dyn Any + Send>>, Status>>;
+}
 
-        /// Return a registry with workers using this client instance
-        fn get_workers_info(&self) -> Option<Arc<SlotManager>>;
+struct CallShim<F, Req, Resp> {
+    callfn: F,
+    seed_req: Option<Request<Req>>,
+    _resp: PhantomData<Resp>,
+}
 
-        async fn call<F, Req, Resp>(
-            &mut self,
-            _call_name: &'static str,
-            mut callfn: F,
-            req: Request<Req>,
-        ) -> Result<Response<Resp>, Status>
-        where
-            Req: Clone + Unpin + Send + Sync + 'static,
-            F: FnMut(&mut Self, Request<Req>) -> BoxFuture<'static, Result<Response<Resp>, Status>>,
-            F: Send + Sync + Unpin + 'static,
-        {
-            callfn(self, req).await
+impl<F, Req, Resp> CallShim<F, Req, Resp> {
+    fn new(callfn: F, seed_req: Request<Req>) -> Self {
+        Self {
+            callfn,
+            seed_req: Some(seed_req),
+            _resp: PhantomData,
         }
     }
 }
-
-#[async_trait::async_trait]
-impl<RC, T> RawClientLike for RetryClient<RC>
+impl<F, Req, Resp> ErasedCallOp for CallShim<F, Req, Resp>
 where
-    RC: RawClientLike<SvcType = T> + 'static,
-    T: Send + Sync + Clone + 'static,
+    Req: Clone + Unpin + Send + Sync + 'static,
+    Resp: Send + 'static,
+    F: Send + Sync + Unpin + 'static,
+    for<'a> F: FnMut(
+        &'a mut dyn ErasedRawClient,
+        Request<Req>,
+    ) -> BoxFuture<'static, Result<Response<Resp>, Status>>,
 {
-    type SvcType = T;
-
-    fn workflow_client(&self) -> &WorkflowServiceClient<Self::SvcType> {
-        self.get_client().workflow_client()
-    }
-
-    fn workflow_client_mut(&mut self) -> &mut WorkflowServiceClient<Self::SvcType> {
-        self.get_client_mut().workflow_client_mut()
-    }
-
-    fn operator_client(&self) -> &OperatorServiceClient<Self::SvcType> {
-        self.get_client().operator_client()
+    fn invoke(
+        &mut self,
+        raw: &mut dyn ErasedRawClient,
+        _call_name: &'static str,
+    ) -> BoxFuture<'static, Result<Response<Box<dyn Any + Send>>, Status>> {
+        (self.callfn)(
+            raw,
+            self.seed_req
+                .take()
+                .expect("CallShim must have request populated"),
+        )
+        .map(|res| res.map(|payload| payload.map(|t| Box::new(t) as Box<dyn Any + Send>)))
+        .boxed()
     }
+}
 
-    fn operator_client_mut(&mut self) -> &mut OperatorServiceClient<Self::SvcType> {
-        self.get_client_mut().operator_client_mut()
+#[async_trait::async_trait]
+impl RawGrpcCaller for dyn ErasedRawClient {
+    async fn call<F, Req, Resp>(
+        &mut self,
+        call_name: &'static str,
+        callfn: F,
+        req: Request<Req>,
+    ) -> Result<Response<Resp>, Status>
+    where
+        Req: Clone + Unpin + Send + Sync + 'static,
+        Resp: Send + 'static,
+        F: Send + Sync + Unpin + 'static,
+        for<'a> F: FnMut(
+            &'a mut dyn ErasedRawClient,
+            Request<Req>,
+        ) -> BoxFuture<'static, Result<Response<Resp>, Status>>,
+    {
+        let mut shim = CallShim::new(callfn, req);
+        let erased_resp = ErasedRawClient::erased_call(self, call_name, &mut shim).await?;
+        Ok(erased_resp.map(|boxed| {
+            *boxed
+                .downcast()
+                .expect("RawGrpcCaller erased response type mismatch")
+        }))
     }
+}
 
-    fn cloud_client(&self) -> &CloudServiceClient<Self::SvcType> {
-        self.get_client().cloud_client()
+impl<T> ErasedRawClient for T
+where
+    T: RawGrpcCaller + 'static,
+{
+    fn erased_call(
+        &mut self,
+        call_name: &'static str,
+        op: &mut dyn ErasedCallOp,
+    ) -> BoxFuture<'static, Result<Response<Box<dyn Any + Send>>, Status>> {
+        let raw: &mut dyn ErasedRawClient = self;
+        op.invoke(raw, call_name)
     }
+}
 
-    fn cloud_client_mut(&mut self) -> &mut CloudServiceClient<Self::SvcType> {
-        self.get_client_mut().cloud_client_mut()
+impl<RC> RawClientProducer for RetryClient<RC>
+where
+    RC: RawClientProducer + 'static,
+{
+    fn get_workers_info(&self) -> Option<Arc<SlotManager>> {
+        self.get_client().get_workers_info()
     }
 
-    fn test_client(&self) -> &TestServiceClient<Self::SvcType> {
-        self.get_client().test_client()
+    fn workflow_client(&mut self) -> Box<dyn WorkflowService> {
+        self.get_client_mut().workflow_client()
     }
 
-    fn test_client_mut(&mut self) -> &mut TestServiceClient<Self::SvcType> {
-        self.get_client_mut().test_client_mut()
+    fn operator_client(&mut self) -> Box<dyn OperatorService> {
+        self.get_client_mut().operator_client()
     }
 
-    fn health_client(&self) -> &HealthClient<Self::SvcType> {
-        self.get_client().health_client()
+    fn cloud_client(&mut self) -> Box<dyn CloudService> {
+        self.get_client_mut().cloud_client()
     }
 
-    fn health_client_mut(&mut self) -> &mut HealthClient<Self::SvcType> {
-        self.get_client_mut().health_client_mut()
+    fn test_client(&mut self) -> Box<dyn TestService> {
+        self.get_client_mut().test_client()
     }
 
-    fn get_workers_info(&self) -> Option<Arc<SlotManager>> {
-        self.get_client().get_workers_info()
+    fn health_client(&mut self) -> Box<dyn HealthService> {
+        self.get_client_mut().health_client()
     }
+}
 
+#[async_trait::async_trait]
+impl<RC> RawGrpcCaller for RetryClient<RC>
+where
+    RC: RawGrpcCaller + 'static,
+{
     async fn call<F, Req, Resp>(
         &mut self,
         call_name: &'static str,
@@ -163,202 +230,173 @@ where
     }
 }
 
-impl<T> RawClientLike for TemporalServiceClient<T>
+/// Helper for cloning a tonic request as long as the inner message may be cloned.
+fn req_cloner<T: Clone>(cloneme: &Request<T>) -> Request<T> {
+    let msg = cloneme.get_ref().clone();
+    let mut new_req = Request::new(msg);
+    let new_met = new_req.metadata_mut();
+    for kv in cloneme.metadata().iter() {
+        match kv {
+            KeyAndValueRef::Ascii(k, v) => {
+                new_met.insert(k, v.clone());
+            }
+            KeyAndValueRef::Binary(k, v) => {
+                new_met.insert_bin(k, v.clone());
+            }
+        }
+    }
+    *new_req.extensions_mut() = cloneme.extensions().clone();
+    new_req
+}
+
+impl<RC> RawClientProducer for SharedReplaceableClient<RC>
 where
-    T: Send + Sync + Clone + 'static,
-    T: GrpcService<Body> + 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,
+    RC: RawClientProducer + Clone + Send + Sync + 'static,
 {
-    type SvcType = T;
-
-    fn workflow_client(&self) -> &WorkflowServiceClient<Self::SvcType> {
-        self.workflow_svc()
+    fn get_workers_info(&self) -> Option<Arc<SlotManager>> {
+        self.inner_cow().get_workers_info()
+    }
+    fn workflow_client(&mut self) -> Box<dyn WorkflowService> {
+        self.inner_mut_refreshed().workflow_client()
     }
 
-    fn workflow_client_mut(&mut self) -> &mut WorkflowServiceClient<Self::SvcType> {
-        self.workflow_svc_mut()
+    fn operator_client(&mut self) -> Box<dyn OperatorService> {
+        self.inner_mut_refreshed().operator_client()
     }
 
-    fn operator_client(&self) -> &OperatorServiceClient<Self::SvcType> {
-        self.operator_svc()
+    fn cloud_client(&mut self) -> Box<dyn CloudService> {
+        self.inner_mut_refreshed().cloud_client()
     }
 
-    fn operator_client_mut(&mut self) -> &mut OperatorServiceClient<Self::SvcType> {
-        self.operator_svc_mut()
+    fn test_client(&mut self) -> Box<dyn TestService> {
+        self.inner_mut_refreshed().test_client()
     }
 
-    fn cloud_client(&self) -> &CloudServiceClient<Self::SvcType> {
-        self.cloud_svc()
+    fn health_client(&mut self) -> Box<dyn HealthService> {
+        self.inner_mut_refreshed().health_client()
     }
+}
 
-    fn cloud_client_mut(&mut self) -> &mut CloudServiceClient<Self::SvcType> {
-        self.cloud_svc_mut()
+#[async_trait::async_trait]
+impl<RC> RawGrpcCaller for SharedReplaceableClient<RC> where
+    RC: RawGrpcCaller + Clone + Sync + 'static
+{
+}
+
+impl RawClientProducer for TemporalServiceClient {
+    fn get_workers_info(&self) -> Option<Arc<SlotManager>> {
+        None
     }
 
-    fn test_client(&self) -> &TestServiceClient<Self::SvcType> {
-        self.test_svc()
+    fn workflow_client(&mut self) -> Box<dyn WorkflowService> {
+        self.workflow_svc()
     }
 
-    fn test_client_mut(&mut self) -> &mut TestServiceClient<Self::SvcType> {
-        self.test_svc_mut()
+    fn operator_client(&mut self) -> Box<dyn OperatorService> {
+        self.operator_svc()
     }
 
-    fn health_client(&self) -> &HealthClient<Self::SvcType> {
-        self.health_svc()
+    fn cloud_client(&mut self) -> Box<dyn CloudService> {
+        self.cloud_svc()
     }
 
-    fn health_client_mut(&mut self) -> &mut HealthClient<Self::SvcType> {
-        self.health_svc_mut()
+    fn test_client(&mut self) -> Box<dyn TestService> {
+        self.test_svc()
     }
 
-    fn get_workers_info(&self) -> Option<Arc<SlotManager>> {
-        None
+    fn health_client(&mut self) -> Box<dyn HealthService> {
+        self.health_svc()
     }
 }
 
-impl<T> RawClientLike for ConfiguredClient<TemporalServiceClient<T>>
-where
-    T: Send + Sync + Clone + 'static,
-    T: GrpcService<Body> + 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,
-{
-    type SvcType = T;
+impl RawGrpcCaller for TemporalServiceClient {}
 
-    fn workflow_client(&self) -> &WorkflowServiceClient<Self::SvcType> {
-        self.client.workflow_client()
+impl RawClientProducer for ConfiguredClient<TemporalServiceClient> {
+    fn get_workers_info(&self) -> Option<Arc<SlotManager>> {
+        Some(self.workers())
     }
 
-    fn workflow_client_mut(&mut self) -> &mut WorkflowServiceClient<Self::SvcType> {
-        self.client.workflow_client_mut()
+    fn workflow_client(&mut self) -> Box<dyn WorkflowService> {
+        self.client.workflow_client()
     }
 
-    fn operator_client(&self) -> &OperatorServiceClient<Self::SvcType> {
+    fn operator_client(&mut self) -> Box<dyn OperatorService> {
         self.client.operator_client()
     }
 
-    fn operator_client_mut(&mut self) -> &mut OperatorServiceClient<Self::SvcType> {
-        self.client.operator_client_mut()
-    }
-
-    fn cloud_client(&self) -> &CloudServiceClient<Self::SvcType> {
+    fn cloud_client(&mut self) -> Box<dyn CloudService> {
         self.client.cloud_client()
     }
 
-    fn cloud_client_mut(&mut self) -> &mut CloudServiceClient<Self::SvcType> {
-        self.client.cloud_client_mut()
-    }
-
-    fn test_client(&self) -> &TestServiceClient<Self::SvcType> {
+    fn test_client(&mut self) -> Box<dyn TestService> {
         self.client.test_client()
     }
 
-    fn test_client_mut(&mut self) -> &mut TestServiceClient<Self::SvcType> {
-        self.client.test_client_mut()
-    }
-
-    fn health_client(&self) -> &HealthClient<Self::SvcType> {
+    fn health_client(&mut self) -> Box<dyn HealthService> {
         self.client.health_client()
     }
+}
 
-    fn health_client_mut(&mut self) -> &mut HealthClient<Self::SvcType> {
-        self.client.health_client_mut()
-    }
+impl RawGrpcCaller for ConfiguredClient<TemporalServiceClient> {}
 
+impl RawClientProducer for Client {
     fn get_workers_info(&self) -> Option<Arc<SlotManager>> {
-        Some(self.workers())
+        self.inner.get_workers_info()
     }
-}
-
-impl RawClientLike for Client {
-    type SvcType = InterceptedMetricsSvc;
 
-    fn workflow_client(&self) -> &WorkflowServiceClient<Self::SvcType> {
+    fn workflow_client(&mut self) -> Box<dyn WorkflowService> {
         self.inner.workflow_client()
     }
 
-    fn workflow_client_mut(&mut self) -> &mut WorkflowServiceClient<Self::SvcType> {
-        self.inner.workflow_client_mut()
-    }
-
-    fn operator_client(&self) -> &OperatorServiceClient<Self::SvcType> {
+    fn operator_client(&mut self) -> Box<dyn OperatorService> {
         self.inner.operator_client()
     }
 
-    fn operator_client_mut(&mut self) -> &mut OperatorServiceClient<Self::SvcType> {
-        self.inner.operator_client_mut()
-    }
-
-    fn cloud_client(&self) -> &CloudServiceClient<Self::SvcType> {
+    fn cloud_client(&mut self) -> Box<dyn CloudService> {
         self.inner.cloud_client()
     }
 
-    fn cloud_client_mut(&mut self) -> &mut CloudServiceClient<Self::SvcType> {
-        self.inner.cloud_client_mut()
-    }
-
-    fn test_client(&self) -> &TestServiceClient<Self::SvcType> {
+    fn test_client(&mut self) -> Box<dyn TestService> {
         self.inner.test_client()
     }
 
-    fn test_client_mut(&mut self) -> &mut TestServiceClient<Self::SvcType> {
-        self.inner.test_client_mut()
-    }
-
-    fn health_client(&self) -> &HealthClient<Self::SvcType> {
+    fn health_client(&mut self) -> Box<dyn HealthService> {
         self.inner.health_client()
     }
-
-    fn health_client_mut(&mut self) -> &mut HealthClient<Self::SvcType> {
-        self.inner.health_client_mut()
-    }
-
-    fn get_workers_info(&self) -> Option<Arc<SlotManager>> {
-        self.inner.get_workers_info()
-    }
 }
 
-/// Helper for cloning a tonic request as long as the inner message may be cloned.
-fn req_cloner<T: Clone>(cloneme: &Request<T>) -> Request<T> {
-    let msg = cloneme.get_ref().clone();
-    let mut new_req = Request::new(msg);
-    let new_met = new_req.metadata_mut();
-    for kv in cloneme.metadata().iter() {
-        match kv {
-            KeyAndValueRef::Ascii(k, v) => {
-                new_met.insert(k, v.clone());
-            }
-            KeyAndValueRef::Binary(k, v) => {
-                new_met.insert_bin(k, v.clone());
-            }
-        }
-    }
-    *new_req.extensions_mut() = cloneme.extensions().clone();
-    new_req
-}
+impl RawGrpcCaller for Client {}
 
 #[derive(Clone, Debug)]
 pub(super) struct AttachMetricLabels {
     pub(super) labels: Vec<MetricKeyValue>,
+    pub(super) normal_task_queue: Option<String>,
+    pub(super) sticky_task_queue: Option<String>,
 }
 impl AttachMetricLabels {
     pub(super) fn new(kvs: impl Into<Vec<MetricKeyValue>>) -> Self {
-        Self { labels: kvs.into() }
+        Self {
+            labels: kvs.into(),
+            normal_task_queue: None,
+            sticky_task_queue: None,
+        }
     }
     pub(super) fn namespace(ns: impl Into<String>) -> Self {
         AttachMetricLabels::new(vec![namespace_kv(ns.into())])
     }
     pub(super) fn task_q(&mut self, tq: Option<TaskQueue>) -> &mut Self {
         if let Some(tq) = tq {
-            self.task_q_str(tq.name);
+            if !tq.normal_name.is_empty() {
+                self.sticky_task_queue = Some(tq.name);
+                self.normal_task_queue = Some(tq.normal_name);
+            } else {
+                self.normal_task_queue = Some(tq.name);
+            }
         }
         self
     }
     pub(super) fn task_q_str(&mut self, tq: impl Into<String>) -> &mut Self {
-        self.labels.push(task_queue_kv(tq.into()));
+        self.normal_task_queue = Some(tq.into());
         self
     }
 }
@@ -368,62 +406,27 @@ impl AttachMetricLabels {
 #[derive(Copy, Clone, Debug)]
 pub(super) struct IsUserLongPoll;
 
-// Blanket impl the trait for all raw-client-like things. Since the trait default-implements
-// everything, there's nothing to actually implement.
-impl<RC, T> WorkflowService for RC
-where
-    RC: RawClientLike<SvcType = T>,
-    T: GrpcService<Body> + Send + Clone + 'static,
-    T::ResponseBody: tonic::codegen::Body<Data = tonic::codegen::Bytes> + Send + 'static,
-    T::Error: Into<tonic::codegen::StdError>,
-    T::Future: Send,
-    <T::ResponseBody as tonic::codegen::Body>::Error: Into<tonic::codegen::StdError> + Send,
-{
-}
-impl<RC, T> OperatorService for RC
-where
-    RC: RawClientLike<SvcType = T>,
-    T: GrpcService<Body> + Send + Clone + 'static,
-    T::ResponseBody: tonic::codegen::Body<Data = tonic::codegen::Bytes> + Send + 'static,
-    T::Error: Into<tonic::codegen::StdError>,
-    T::Future: Send,
-    <T::ResponseBody as tonic::codegen::Body>::Error: Into<tonic::codegen::StdError> + Send,
-{
-}
-impl<RC, T> CloudService for RC
-where
-    RC: RawClientLike<SvcType = T>,
-    T: GrpcService<Body> + Send + Clone + 'static,
-    T::ResponseBody: tonic::codegen::Body<Data = tonic::codegen::Bytes> + Send + 'static,
-    T::Error: Into<tonic::codegen::StdError>,
-    T::Future: Send,
-    <T::ResponseBody as tonic::codegen::Body>::Error: Into<tonic::codegen::StdError> + Send,
-{
-}
-impl<RC, T> TestService for RC
-where
-    RC: RawClientLike<SvcType = T>,
-    T: GrpcService<Body> + Send + Clone + 'static,
-    T::ResponseBody: tonic::codegen::Body<Data = tonic::codegen::Bytes> + Send + 'static,
-    T::Error: Into<tonic::codegen::StdError>,
-    T::Future: Send,
-    <T::ResponseBody as tonic::codegen::Body>::Error: Into<tonic::codegen::StdError> + Send,
-{
-}
-impl<RC, T> HealthService for RC
-where
-    RC: RawClientLike<SvcType = T>,
-    T: GrpcService<Body> + Send + Clone + 'static,
-    T::ResponseBody: tonic::codegen::Body<Data = tonic::codegen::Bytes> + Send + 'static,
-    T::Error: Into<tonic::codegen::StdError>,
-    T::Future: Send,
-    <T::ResponseBody as tonic::codegen::Body>::Error: Into<tonic::codegen::StdError> + Send,
-{
+macro_rules! proxy_def {
+    ($client_type:tt, $client_meth:ident, $method:ident, $req:ty, $resp:ty, defaults) => {
+        #[doc = concat!("See [", stringify!($client_type), "::", stringify!($method), "]")]
+        fn $method(
+            &mut self,
+            _request: tonic::Request<$req>,
+        ) -> BoxFuture<'_, Result<tonic::Response<$resp>, tonic::Status>> {
+            async { Ok(tonic::Response::new(<$resp>::default())) }.boxed()
+        }
+    };
+    ($client_type:tt, $client_meth:ident, $method:ident, $req:ty, $resp:ty) => {
+        #[doc = concat!("See [", stringify!($client_type), "::", stringify!($method), "]")]
+        fn $method(
+            &mut self,
+            _request: tonic::Request<$req>,
+        ) -> BoxFuture<'_, Result<tonic::Response<$resp>, tonic::Status>>;
+    };
 }
-
 /// Helps re-declare gRPC client methods
 ///
-/// There are two forms:
+/// There are four forms:
 ///
 /// * The first takes a closure that can modify the request. This is only called once, before the
 ///   actual rpc call is made, and before determinations are made about the kind of call (long poll
@@ -431,22 +434,23 @@ where
 /// * The second takes three closures. The first can modify the request like in the first form.
 ///   The second can modify the request and return a value, and is called right before every call
 ///   (including on retries). The third is called with the response to the call after it resolves.
-macro_rules! proxy {
+/// * The third and fourth are equivalents of the above that skip calling through the `call` method
+///   and are implemented directly on the generated gRPC clients (IE: the bottom of the stack).
+macro_rules! proxy_impl {
     ($client_type:tt, $client_meth:ident, $method:ident, $req:ty, $resp:ty $(, $closure:expr)?) => {
         #[doc = concat!("See [", stringify!($client_type), "::", stringify!($method), "]")]
         fn $method(
             &mut self,
-            request: impl tonic::IntoRequest<$req>,
-        ) -> BoxFuture<'_, Result<tonic::Response<$resp>, tonic::Status>> {
             #[allow(unused_mut)]
-            let mut as_req = request.into_request();
-            $( type_closure_arg(&mut as_req, $closure); )*
+            mut request: tonic::Request<$req>,
+        ) -> BoxFuture<'_, Result<tonic::Response<$resp>, tonic::Status>> {
+            $( type_closure_arg(&mut request, $closure); )*
             #[allow(unused_mut)]
             let fact = |c: &mut Self, mut req: tonic::Request<$req>| {
-                let mut c = c.$client_meth().clone();
+                let mut c = c.$client_meth();
                 async move { c.$method(req).await }.boxed()
             };
-            self.call(stringify!($method), fact, as_req)
+            self.call(stringify!($method), fact, request)
         }
     };
     ($client_type:tt, $client_meth:ident, $method:ident, $req:ty, $resp:ty,
@@ -454,52 +458,108 @@ macro_rules! proxy {
         #[doc = concat!("See [", stringify!($client_type), "::", stringify!($method), "]")]
         fn $method(
             &mut self,
-            request: impl tonic::IntoRequest<$req>,
+            mut request: tonic::Request<$req>,
         ) -> BoxFuture<'_, Result<tonic::Response<$resp>, tonic::Status>> {
-            #[allow(unused_mut)]
-            let mut as_req = request.into_request();
-            type_closure_arg(&mut as_req, $closure_request);
+            type_closure_arg(&mut request, $closure_request);
             #[allow(unused_mut)]
             let fact = |c: &mut Self, mut req: tonic::Request<$req>| {
-                let data = type_closure_two_arg(&mut req, c.get_workers_info().unwrap(),
-                                                $closure_before);
-                let mut c = c.$client_meth().clone();
+                let data = type_closure_two_arg(&mut req, c.get_workers_info(), $closure_before);
+                let mut c = c.$client_meth();
                 async move {
                     type_closure_two_arg(c.$method(req).await, data, $closure_after)
                 }.boxed()
             };
-            self.call(stringify!($method), fact, as_req)
+            self.call(stringify!($method), fact, request)
+        }
+    };
+    ($client_type:tt, $method:ident, $req:ty, $resp:ty $(, $closure:expr)?) => {
+        #[doc = concat!("See [", stringify!($client_type), "::", stringify!($method), "]")]
+        fn $method(
+            &mut self,
+            #[allow(unused_mut)]
+            mut request: tonic::Request<$req>,
+        ) -> BoxFuture<'_, Result<tonic::Response<$resp>, tonic::Status>> {
+            $( type_closure_arg(&mut request, $closure); )*
+            async move { <$client_type<_>>::$method(self, request).await }.boxed()
+        }
+    };
+    ($client_type:tt, $method:ident, $req:ty, $resp:ty,
+     $closure_request:expr, $closure_before:expr, $closure_after:expr) => {
+        #[doc = concat!("See [", stringify!($client_type), "::", stringify!($method), "]")]
+        fn $method(
+            &mut self,
+            mut request: tonic::Request<$req>,
+        ) -> BoxFuture<'_, Result<tonic::Response<$resp>, tonic::Status>> {
+            type_closure_arg(&mut request, $closure_request);
+            let data = type_closure_two_arg(&mut request, Option::<Arc<SlotManager>>::None,
+                                            $closure_before);
+            async move {
+                type_closure_two_arg(<$client_type<_>>::$method(self, request).await,
+                                     data, $closure_after)
+            }.boxed()
         }
     };
 }
-macro_rules! proxier {
-    ( $trait_name:ident; $impl_list_name:ident; $client_type:tt; $client_meth:ident;
-      $(($method:ident, $req:ty, $resp:ty
-         $(, $closure:expr $(, $closure_before:expr, $closure_after:expr)?)? );)* ) => {
+macro_rules! proxier_impl {
+    ($trait_name:ident; $impl_list_name:ident; $client_type:tt; $client_meth:ident;
+     [$( proxy_def!($($def_args:tt)*); )*];
+     $(($method:ident, $req:ty, $resp:ty
+       $(, $closure:expr $(, $closure_before:expr, $closure_after:expr)?)? );)* ) => {
         #[cfg(test)]
         const $impl_list_name: &'static [&'static str] = &[$(stringify!($method)),*];
-        /// Trait version of the generated client with modifications to attach appropriate metric
-        /// labels or whatever else to requests
-        pub trait $trait_name: RawClientLike
+
+        #[doc = concat!("Trait version of [", stringify!($client_type), "]")]
+        pub trait $trait_name: Send + Sync + DynClone
+        {
+            $( proxy_def!($($def_args)*); )*
+        }
+        dyn_clone::clone_trait_object!($trait_name);
+
+        impl<RC> $trait_name for RC
         where
-            // Yo this is wild
-            <Self as RawClientLike>::SvcType: GrpcService<Body> + Send + Clone + 'static,
-            <<Self as RawClientLike>::SvcType as GrpcService<Body>>::ResponseBody:
-                tonic::codegen::Body<Data = tonic::codegen::Bytes> + Send + 'static,
-            <<Self as RawClientLike>::SvcType as GrpcService<Body>>::Error:
-                Into<tonic::codegen::StdError>,
-            <<Self as RawClientLike>::SvcType as GrpcService<Body>>::Future: Send,
-            <<<Self as RawClientLike>::SvcType as GrpcService<Body>>::ResponseBody
-                as tonic::codegen::Body>::Error: Into<tonic::codegen::StdError> + Send,
+            RC: RawGrpcCaller + RawClientProducer + Clone,
         {
             $(
-               proxy!($client_type, $client_meth, $method, $req, $resp
-                      $(,$closure $(,$closure_before, $closure_after)*)*);
+                proxy_impl!($client_type, $client_meth, $method, $req, $resp
+                            $(,$closure $(,$closure_before, $closure_after)*)*);
+            )*
+        }
+
+        impl<T: Send + Sync + 'static> RawGrpcCaller for $client_type<T> {}
+
+        impl<T> $trait_name for $client_type<T>
+        where
+            T: GrpcService<Body> + Clone + Send + Sync + '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,
+            <T as tonic::client::GrpcService<Body>>::Future: Send
+        {
+            $(
+                proxy_impl!($client_type, $method, $req, $resp
+                            $(,$closure $(,$closure_before, $closure_after)*)*);
             )*
         }
     };
 }
 
+macro_rules! proxier {
+    ( $trait_name:ident; $impl_list_name:ident; $client_type:tt; $client_meth:ident;
+      $(($method:ident, $req:ty, $resp:ty
+         $(, $closure:expr $(, $closure_before:expr, $closure_after:expr)?)? );)* ) => {
+        proxier_impl!($trait_name; $impl_list_name; $client_type; $client_meth;
+                      [$(proxy_def!($client_type, $client_meth, $method, $req, $resp);)*];
+                      $(($method, $req, $resp $(, $closure $(, $closure_before, $closure_after)?)?);)*);
+    };
+    ( $trait_name:ident; $impl_list_name:ident; $client_type:tt; $client_meth:ident; defaults;
+      $(($method:ident, $req:ty, $resp:ty
+         $(, $closure:expr $(, $closure_before:expr, $closure_after:expr)?)? );)* ) => {
+        proxier_impl!($trait_name; $impl_list_name; $client_type; $client_meth;
+                      [$(proxy_def!($client_type, $client_meth, $method, $req, $resp, defaults);)*];
+                      $(($method, $req, $resp $(, $closure $(, $closure_before, $closure_after)?)?);)*);
+    };
+}
+
 macro_rules! namespaced_request {
     ($req:ident) => {{
         let ns_str = $req.get_ref().namespace.clone();
@@ -526,7 +586,7 @@ fn type_closure_two_arg<T, R, S>(arg1: R, arg2: T, f: impl FnOnce(R, T) -> S) ->
 }
 
 proxier! {
-    WorkflowService; ALL_IMPLEMENTED_WORKFLOW_SERVICE_RPCS; WorkflowServiceClient; workflow_client_mut;
+    WorkflowService; ALL_IMPLEMENTED_WORKFLOW_SERVICE_RPCS; WorkflowServiceClient; workflow_client; defaults;
     (
         register_namespace,
         RegisterNamespaceRequest,
@@ -578,21 +638,39 @@ proxier! {
             r.extensions_mut().insert(labels);
         },
         |r, workers| {
-            let mut slot: Option<Box<dyn Slot + Send>> = None;
-            let req_mut = r.get_mut();
-            if req_mut.request_eager_execution {
-                let namespace = req_mut.namespace.clone();
-                let task_queue = req_mut.task_queue.as_ref()
-                                    .map(|tq| tq.name.clone()).unwrap_or_default();
-                match workers.try_reserve_wft_slot(namespace, task_queue) {
-                    Some(s) => slot = Some(s),
-                    None => req_mut.request_eager_execution = false
+            if let Some(workers) = workers {
+                let mut slot: Option<Box<dyn Slot + Send>> = None;
+                let req_mut = r.get_mut();
+                if req_mut.request_eager_execution {
+                    let namespace = req_mut.namespace.clone();
+                    let task_queue = req_mut.task_queue.as_ref()
+                                        .map(|tq| tq.name.clone()).unwrap_or_default();
+                    match workers.try_reserve_wft_slot(namespace, task_queue) {
+                        Some(reservation) => {
+                            // Populate eager_worker_deployment_options from the slot reservation
+                            if let Some(opts) = reservation.deployment_options {
+                                req_mut.eager_worker_deployment_options = Some(temporal_sdk_core_protos::temporal::api::deployment::v1::WorkerDeploymentOptions {
+                                    deployment_name: opts.version.deployment_name,
+                                    build_id: opts.version.build_id,
+                                    worker_versioning_mode: if opts.use_worker_versioning {
+                                        temporal_sdk_core_protos::temporal::api::enums::v1::WorkerVersioningMode::Versioned.into()
+                                    } else {
+                                        temporal_sdk_core_protos::temporal::api::enums::v1::WorkerVersioningMode::Unversioned.into()
+                                    },
+                                });
+                            }
+                            slot = Some(reservation.slot);
+                        }
+                        None => req_mut.request_eager_execution = false
+                    }
                 }
+                slot
+            } else {
+                None
             }
-            slot
         },
         |resp, slot| {
-            if let Some(mut s) = slot
+            if let Some(s) = slot
                 && let Ok(response) = resp.as_ref()
                     && let Some(task) = response.get_ref().clone().eager_workflow_task
                         && let Err(e) = s.schedule_wft(task) {
@@ -1382,10 +1460,28 @@ proxier! {
             r.extensions_mut().insert(labels);
         }
     );
+    (
+        describe_worker,
+        DescribeWorkerRequest,
+        DescribeWorkerResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        set_worker_deployment_manager,
+        SetWorkerDeploymentManagerRequest,
+        SetWorkerDeploymentManagerResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
 }
 
 proxier! {
-    OperatorService; ALL_IMPLEMENTED_OPERATOR_SERVICE_RPCS; OperatorServiceClient; operator_client_mut;
+    OperatorService; ALL_IMPLEMENTED_OPERATOR_SERVICE_RPCS; OperatorServiceClient; operator_client; defaults;
     (add_search_attributes, AddSearchAttributesRequest, AddSearchAttributesResponse);
     (remove_search_attributes, RemoveSearchAttributesRequest, RemoveSearchAttributesResponse);
     (list_search_attributes, ListSearchAttributesRequest, ListSearchAttributesResponse);
@@ -1406,7 +1502,7 @@ proxier! {
 }
 
 proxier! {
-    CloudService; ALL_IMPLEMENTED_CLOUD_SERVICE_RPCS; CloudServiceClient; cloud_client_mut;
+    CloudService; ALL_IMPLEMENTED_CLOUD_SERVICE_RPCS; CloudServiceClient; cloud_client; defaults;
     (get_users, cloudreq::GetUsersRequest, cloudreq::GetUsersResponse);
     (get_user, cloudreq::GetUserRequest, cloudreq::GetUserResponse);
     (create_user, cloudreq::CreateUserRequest, cloudreq::CreateUserResponse);
@@ -1481,7 +1577,7 @@ proxier! {
 }
 
 proxier! {
-    TestService; ALL_IMPLEMENTED_TEST_SERVICE_RPCS; TestServiceClient; test_client_mut;
+    TestService; ALL_IMPLEMENTED_TEST_SERVICE_RPCS; TestServiceClient; test_client; defaults;
     (lock_time_skipping, LockTimeSkippingRequest, LockTimeSkippingResponse);
     (unlock_time_skipping, UnlockTimeSkippingRequest, UnlockTimeSkippingResponse);
     (sleep, SleepRequest, SleepResponse);
@@ -1491,7 +1587,7 @@ proxier! {
 }
 
 proxier! {
-    HealthService; ALL_IMPLEMENTED_HEALTH_SERVICE_RPCS; HealthClient; health_client_mut;
+    HealthService; ALL_IMPLEMENTED_HEALTH_SERVICE_RPCS; HealthClient; health_client;
     (check, HealthCheckRequest, HealthCheckResponse);
     (watch, HealthCheckRequest, tonic::codec::Streaming<HealthCheckResponse>);
 }
@@ -1504,6 +1600,7 @@ mod tests {
     use temporal_sdk_core_protos::temporal::api::{
         operatorservice::v1::DeleteNamespaceRequest, workflowservice::v1::ListNamespacesRequest,
     };
+    use tonic::IntoRequest;
 
     // Just to help make sure some stuff compiles. Not run.
     #[allow(dead_code)]
@@ -1514,7 +1611,7 @@ mod tests {
 
         let list_ns_req = ListNamespacesRequest::default();
         let fact = |c: &mut RetryClient<_>, req| {
-            let mut c = c.workflow_client_mut().clone();
+            let mut c = c.workflow_client();
             async move { c.list_namespaces(req).await }.boxed()
         };
         retry_client
@@ -1525,7 +1622,7 @@ mod tests {
         // Operator svc method
         let op_del_ns_req = DeleteNamespaceRequest::default();
         let fact = |c: &mut RetryClient<_>, req| {
-            let mut c = c.operator_client_mut().clone();
+            let mut c = c.operator_client();
             async move { c.delete_namespace(req).await }.boxed()
         };
         retry_client
@@ -1536,7 +1633,7 @@ mod tests {
         // Cloud svc method
         let cloud_del_ns_req = cloudreq::DeleteNamespaceRequest::default();
         let fact = |c: &mut RetryClient<_>, req| {
-            let mut c = c.cloud_client_mut().clone();
+            let mut c = c.cloud_client();
             async move { c.delete_namespace(req).await }.boxed()
         };
         retry_client
@@ -1545,17 +1642,23 @@ mod tests {
             .unwrap();
 
         // Verify calling through traits works
-        retry_client.list_namespaces(list_ns_req).await.unwrap();
+        retry_client
+            .list_namespaces(list_ns_req.into_request())
+            .await
+            .unwrap();
         // Have to disambiguate operator and cloud service
-        OperatorService::delete_namespace(&mut retry_client, op_del_ns_req)
+        OperatorService::delete_namespace(&mut retry_client, op_del_ns_req.into_request())
+            .await
+            .unwrap();
+        CloudService::delete_namespace(&mut retry_client, cloud_del_ns_req.into_request())
             .await
             .unwrap();
-        CloudService::delete_namespace(&mut retry_client, cloud_del_ns_req)
+        retry_client
+            .get_current_time(().into_request())
             .await
             .unwrap();
-        retry_client.get_current_time(()).await.unwrap();
         retry_client
-            .check(HealthCheckRequest::default())
+            .check(HealthCheckRequest::default().into_request())
             .await
             .unwrap();
     }
@@ -1621,4 +1724,192 @@ mod tests {
         let proto_def = include_str!("../../sdk-core-protos/protos/grpc/health/v1/health.proto");
         verify_methods(proto_def, ALL_IMPLEMENTED_HEALTH_SERVICE_RPCS);
     }
+
+    #[tokio::test]
+    async fn can_mock_services() {
+        #[derive(Clone)]
+        struct MyFakeServices {}
+        impl RawGrpcCaller for MyFakeServices {}
+        impl WorkflowService for MyFakeServices {
+            fn list_namespaces(
+                &mut self,
+                _request: Request<ListNamespacesRequest>,
+            ) -> BoxFuture<'_, Result<Response<ListNamespacesResponse>, Status>> {
+                async {
+                    Ok(Response::new(ListNamespacesResponse {
+                        namespaces: vec![DescribeNamespaceResponse {
+                            failover_version: 12345,
+                            ..Default::default()
+                        }],
+                        ..Default::default()
+                    }))
+                }
+                .boxed()
+            }
+        }
+        impl OperatorService for MyFakeServices {}
+        impl CloudService for MyFakeServices {}
+        impl TestService for MyFakeServices {}
+        // Health service isn't possible to create a default impl for.
+        impl HealthService for MyFakeServices {
+            fn check(
+                &mut self,
+                _request: tonic::Request<HealthCheckRequest>,
+            ) -> BoxFuture<'_, Result<tonic::Response<HealthCheckResponse>, tonic::Status>>
+            {
+                todo!()
+            }
+            fn watch(
+                &mut self,
+                _request: tonic::Request<HealthCheckRequest>,
+            ) -> BoxFuture<
+                '_,
+                Result<
+                    tonic::Response<tonic::codec::Streaming<HealthCheckResponse>>,
+                    tonic::Status,
+                >,
+            > {
+                todo!()
+            }
+        }
+        let mut mocked_client = TemporalServiceClient::from_services(
+            Box::new(MyFakeServices {}),
+            Box::new(MyFakeServices {}),
+            Box::new(MyFakeServices {}),
+            Box::new(MyFakeServices {}),
+            Box::new(MyFakeServices {}),
+        );
+        let r = mocked_client
+            .list_namespaces(ListNamespacesRequest::default().into_request())
+            .await
+            .unwrap();
+        assert_eq!(r.into_inner().namespaces[0].failover_version, 12345);
+    }
+
+    #[rstest::rstest]
+    #[case::with_versioning(true)]
+    #[case::without_versioning(false)]
+    #[tokio::test]
+    async fn eager_reservations_attach_deployment_options(#[case] use_worker_versioning: bool) {
+        use crate::worker_registry::{MockSlot, MockSlotProvider};
+        use temporal_sdk_core_api::worker::{WorkerDeploymentOptions, WorkerDeploymentVersion};
+        use temporal_sdk_core_protos::temporal::api::enums::v1::WorkerVersioningMode;
+
+        let expected_mode = if use_worker_versioning {
+            WorkerVersioningMode::Versioned
+        } else {
+            WorkerVersioningMode::Unversioned
+        };
+
+        #[derive(Clone)]
+        struct MyFakeServices {
+            slot_manager: Arc<SlotManager>,
+            expected_mode: WorkerVersioningMode,
+        }
+        impl RawGrpcCaller for MyFakeServices {}
+        impl RawClientProducer for MyFakeServices {
+            fn get_workers_info(&self) -> Option<Arc<SlotManager>> {
+                Some(self.slot_manager.clone())
+            }
+            fn workflow_client(&mut self) -> Box<dyn WorkflowService> {
+                Box::new(MyFakeWfClient {
+                    expected_mode: self.expected_mode,
+                })
+            }
+            fn operator_client(&mut self) -> Box<dyn OperatorService> {
+                unimplemented!()
+            }
+            fn cloud_client(&mut self) -> Box<dyn CloudService> {
+                unimplemented!()
+            }
+            fn test_client(&mut self) -> Box<dyn TestService> {
+                unimplemented!()
+            }
+            fn health_client(&mut self) -> Box<dyn HealthService> {
+                unimplemented!()
+            }
+        }
+
+        let deployment_opts = WorkerDeploymentOptions {
+            version: WorkerDeploymentVersion {
+                deployment_name: "test-deployment".to_string(),
+                build_id: "test-build-123".to_string(),
+            },
+            use_worker_versioning,
+            default_versioning_behavior: None,
+        };
+
+        let mut mock_provider = MockSlotProvider::new();
+        mock_provider
+            .expect_namespace()
+            .return_const("test-namespace".to_string());
+        mock_provider
+            .expect_task_queue()
+            .return_const("test-task-queue".to_string());
+        let mut mock_slot = MockSlot::new();
+        mock_slot.expect_schedule_wft().returning(|_| Ok(()));
+        mock_provider
+            .expect_try_reserve_wft_slot()
+            .return_once(|| Some(Box::new(mock_slot)));
+        mock_provider
+            .expect_deployment_options()
+            .return_const(Some(deployment_opts.clone()));
+
+        let slot_manager = Arc::new(SlotManager::new());
+        slot_manager.register(Box::new(mock_provider));
+
+        #[derive(Clone)]
+        struct MyFakeWfClient {
+            expected_mode: WorkerVersioningMode,
+        }
+        impl WorkflowService for MyFakeWfClient {
+            fn start_workflow_execution(
+                &mut self,
+                request: tonic::Request<StartWorkflowExecutionRequest>,
+            ) -> BoxFuture<'_, Result<tonic::Response<StartWorkflowExecutionResponse>, tonic::Status>>
+            {
+                let req = request.into_inner();
+                let expected_mode = self.expected_mode;
+
+                assert!(
+                    req.eager_worker_deployment_options.is_some(),
+                    "eager_worker_deployment_options should be populated"
+                );
+
+                let opts = req.eager_worker_deployment_options.as_ref().unwrap();
+                assert_eq!(opts.deployment_name, "test-deployment");
+                assert_eq!(opts.build_id, "test-build-123");
+                assert_eq!(opts.worker_versioning_mode, expected_mode as i32);
+
+                async { Ok(Response::new(StartWorkflowExecutionResponse::default())) }.boxed()
+            }
+        }
+
+        let mut mfs = MyFakeServices {
+            slot_manager,
+            expected_mode,
+        };
+
+        // Create a request with eager execution enabled
+        let req = StartWorkflowExecutionRequest {
+            namespace: "test-namespace".to_string(),
+            workflow_id: "test-wf-id".to_string(),
+            workflow_type: Some(
+                temporal_sdk_core_protos::temporal::api::common::v1::WorkflowType {
+                    name: "test-workflow".to_string(),
+                },
+            ),
+            task_queue: Some(TaskQueue {
+                name: "test-task-queue".to_string(),
+                kind: 0,
+                normal_name: String::new(),
+            }),
+            request_eager_execution: true,
+            ..Default::default()
+        };
+
+        mfs.start_workflow_execution(req.into_request())
+            .await
+            .unwrap();
+    }
 }