@temporalio/core-bridge 1.14.2-canary-release-testing.0 → 1.16.0

package/sdk-core/crates/client/src/{raw.rs → grpc.rs}

@@ -1,11 +1,14 @@
-//! We need a way to trait-ify the raw grpc client because there is no other way to get the
-//! information we need via interceptors. This module contains the necessary stuff to make that
-//! happen.
+//! gRPC service traits for direct access to Temporal services.
+//!
+//! Most users should use the higher-level methods on [`Client`] or [`Connection`] instead.
+//! These traits are useful for advanced scenarios like custom interceptors, testing with mocks,
+//! or making raw gRPC calls not covered by the higher-level API.
 
 use crate::{
-    Client, ConfiguredClient, LONG_POLL_TIMEOUT, RequestExt, RetryClient, SharedReplaceableClient,
+    Client, Connection, LONG_POLL_TIMEOUT, RequestExt, SharedReplaceableClient,
     TEMPORAL_NAMESPACE_HEADER_KEY, TemporalServiceClient,
     metrics::namespace_kv,
+    retry::make_future_retry,
     worker::{ClientWorkerSet, Slot},
 };
 use dyn_clone::DynClone;
@@ -32,7 +35,7 @@ use tonic::{
 };
 
 /// Something that has access to the raw grpc services
-trait RawClientProducer {
+pub(crate) 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<ClientWorkerSet>>;
@@ -54,10 +57,10 @@ trait RawClientProducer {
 }
 
 /// 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].
+/// function. Implementers may override this to provide things like retry behavior.
 #[async_trait::async_trait]
-trait RawGrpcCaller: Send + Sync + 'static {
+pub(crate) trait RawGrpcCaller: Send + Sync + 'static {
+    /// Make a gRPC call. The default implementation simply invokes the provided function.
     async fn call<F, Req, Resp>(
         &mut self,
         _call_name: &'static str,
@@ -67,11 +70,10 @@ trait RawGrpcCaller: Send + Sync + 'static {
     where
         Req: Clone + Unpin + Send + Sync + 'static,
         Resp: Send + 'static,
+        F: FnMut(Request<Req>) -> BoxFuture<'static, Result<Response<Resp>, Status>>,
         F: Send + Sync + Unpin + 'static,
-        for<'a> F:
-            FnMut(&'a mut Self, Request<Req>) -> BoxFuture<'static, Result<Response<Resp>, Status>>,
     {
-        callfn(self, req).await
+        callfn(req).await
     }
 }
 
@@ -110,19 +112,15 @@ impl<F, Req, Resp> ErasedCallOp for CallShim<F, Req, Resp>
 where
     Req: Clone + Unpin + Send + Sync + 'static,
     Resp: Send + 'static,
+    F: FnMut(Request<Req>) -> BoxFuture<'static, Result<Response<Resp>, Status>>,
     F: Send + Sync + Unpin + 'static,
-    for<'a> F: FnMut(
-        &'a mut dyn ErasedRawClient,
-        Request<Req>,
-    ) -> BoxFuture<'static, Result<Response<Resp>, Status>>,
 {
     fn invoke(
         &mut self,
-        raw: &mut dyn ErasedRawClient,
+        _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"),
@@ -133,80 +131,7 @@ where
 }
 
 #[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")
-        }))
-    }
-}
-
-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)
-    }
-}
-
-impl<RC> RawClientProducer for RetryClient<RC>
-where
-    RC: RawClientProducer + 'static,
-{
-    fn get_workers_info(&self) -> Option<Arc<ClientWorkerSet>> {
-        self.get_client().get_workers_info()
-    }
-
-    fn workflow_client(&mut self) -> Box<dyn WorkflowService> {
-        self.get_client_mut().workflow_client()
-    }
-
-    fn operator_client(&mut self) -> Box<dyn OperatorService> {
-        self.get_client_mut().operator_client()
-    }
-
-    fn cloud_client(&mut self) -> Box<dyn CloudService> {
-        self.get_client_mut().cloud_client()
-    }
-
-    fn test_client(&mut self) -> Box<dyn TestService> {
-        self.get_client_mut().test_client()
-    }
-
-    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,
-{
+impl RawGrpcCaller for Connection {
     async fn call<F, Req, Resp>(
         &mut self,
         call_name: &'static str,
@@ -215,19 +140,25 @@ where
     ) -> Result<Response<Resp>, Status>
     where
         Req: Clone + Unpin + Send + Sync + 'static,
-        F: FnMut(&mut Self, Request<Req>) -> BoxFuture<'static, Result<Response<Resp>, Status>>,
+        Resp: Send + 'static,
+        F: FnMut(Request<Req>) -> BoxFuture<'static, Result<Response<Resp>, Status>>,
         F: Send + Sync + Unpin + 'static,
     {
-        let info = self.get_call_info(call_name, Some(&req));
+        let info = self
+            .inner
+            .retry_options
+            .get_call_info(call_name, Some(&req));
         req.extensions_mut().insert(info.call_type);
         if info.call_type.is_long() {
             req.set_default_timeout(LONG_POLL_TIMEOUT);
         }
+
         let fact = || {
             let req_clone = req_cloner(&req);
-            callfn(self, req_clone)
+            callfn(req_clone)
         };
-        let res = Self::make_future_retry(info, fact);
+
+        let res = make_future_retry(info, fact);
         res.map_err(|(e, _attempt)| e).map_ok(|x| x.0).await
     }
 }
@@ -251,123 +182,192 @@ fn req_cloner<T: Clone>(cloneme: &Request<T>) -> Request<T> {
     new_req
 }
 
-impl<RC> RawClientProducer for SharedReplaceableClient<RC>
+#[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: FnMut(Request<Req>) -> BoxFuture<'static, Result<Response<Resp>, Status>>,
+        F: Send + Sync + Unpin + 'static,
+    {
+        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")
+        }))
+    }
+}
+
+impl<T> ErasedRawClient for T
 where
-    RC: RawClientProducer + Clone + Send + Sync + 'static,
+    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)
+    }
+}
+
+impl RawClientProducer for Connection {
     fn get_workers_info(&self) -> Option<Arc<ClientWorkerSet>> {
-        self.inner_cow().get_workers_info()
+        Some(self.workers())
     }
+
     fn workflow_client(&mut self) -> Box<dyn WorkflowService> {
-        self.inner_mut_refreshed().workflow_client()
+        self.inner.service.workflow_service()
     }
 
     fn operator_client(&mut self) -> Box<dyn OperatorService> {
-        self.inner_mut_refreshed().operator_client()
+        self.inner.service.operator_service()
     }
 
     fn cloud_client(&mut self) -> Box<dyn CloudService> {
-        self.inner_mut_refreshed().cloud_client()
+        self.inner.service.cloud_service()
     }
 
     fn test_client(&mut self) -> Box<dyn TestService> {
-        self.inner_mut_refreshed().test_client()
+        self.inner.service.test_service()
     }
 
     fn health_client(&mut self) -> Box<dyn HealthService> {
-        self.inner_mut_refreshed().health_client()
+        self.inner.service.health_service()
     }
 }
 
-#[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<ClientWorkerSet>> {
         None
     }
 
     fn workflow_client(&mut self) -> Box<dyn WorkflowService> {
-        self.workflow_svc()
+        self.workflow_service()
     }
 
     fn operator_client(&mut self) -> Box<dyn OperatorService> {
-        self.operator_svc()
+        self.operator_service()
     }
 
     fn cloud_client(&mut self) -> Box<dyn CloudService> {
-        self.cloud_svc()
+        self.cloud_service()
     }
 
     fn test_client(&mut self) -> Box<dyn TestService> {
-        self.test_svc()
+        self.test_service()
     }
 
     fn health_client(&mut self) -> Box<dyn HealthService> {
-        self.health_svc()
+        self.health_service()
     }
 }
 
 impl RawGrpcCaller for TemporalServiceClient {}
 
-impl RawClientProducer for ConfiguredClient<TemporalServiceClient> {
+impl RawClientProducer for Client {
     fn get_workers_info(&self) -> Option<Arc<ClientWorkerSet>> {
-        Some(self.workers())
+        Some(self.connection.workers())
     }
 
     fn workflow_client(&mut self) -> Box<dyn WorkflowService> {
-        self.client.workflow_client()
+        self.connection.workflow_client()
     }
 
     fn operator_client(&mut self) -> Box<dyn OperatorService> {
-        self.client.operator_client()
+        self.connection.operator_client()
     }
 
     fn cloud_client(&mut self) -> Box<dyn CloudService> {
-        self.client.cloud_client()
+        self.connection.cloud_client()
     }
 
     fn test_client(&mut self) -> Box<dyn TestService> {
-        self.client.test_client()
+        self.connection.test_client()
     }
 
     fn health_client(&mut self) -> Box<dyn HealthService> {
-        self.client.health_client()
+        self.connection.health_client()
     }
 }
 
-impl RawGrpcCaller for ConfiguredClient<TemporalServiceClient> {}
+#[async_trait::async_trait]
+impl RawGrpcCaller for Client {
+    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: FnMut(Request<Req>) -> BoxFuture<'static, Result<Response<Resp>, Status>>,
+        F: Send + Sync + Unpin + 'static,
+    {
+        self.connection.call(call_name, callfn, req).await
+    }
+}
 
-impl RawClientProducer for Client {
+impl<RC> RawClientProducer for SharedReplaceableClient<RC>
+where
+    RC: RawClientProducer + Clone + Send + Sync + 'static,
+{
     fn get_workers_info(&self) -> Option<Arc<ClientWorkerSet>> {
-        self.inner.get_workers_info()
+        self.inner_cow().get_workers_info()
     }
-
     fn workflow_client(&mut self) -> Box<dyn WorkflowService> {
-        self.inner.workflow_client()
+        self.inner_mut_refreshed().workflow_client()
     }
 
     fn operator_client(&mut self) -> Box<dyn OperatorService> {
-        self.inner.operator_client()
+        self.inner_mut_refreshed().operator_client()
     }
 
     fn cloud_client(&mut self) -> Box<dyn CloudService> {
-        self.inner.cloud_client()
+        self.inner_mut_refreshed().cloud_client()
     }
 
     fn test_client(&mut self) -> Box<dyn TestService> {
-        self.inner.test_client()
+        self.inner_mut_refreshed().test_client()
     }
 
     fn health_client(&mut self) -> Box<dyn HealthService> {
-        self.inner.health_client()
+        self.inner_mut_refreshed().health_client()
     }
 }
 
-impl RawGrpcCaller for Client {}
+#[async_trait::async_trait]
+impl<RC> RawGrpcCaller for SharedReplaceableClient<RC>
+where
+    RC: RawGrpcCaller + Clone + Sync + 'static,
+{
+    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: FnMut(Request<Req>) -> BoxFuture<'static, Result<Response<Resp>, Status>>,
+        F: Send + Sync + Unpin + 'static,
+    {
+        self.inner_mut_refreshed()
+            .call(call_name, callfn, req)
+            .await
+    }
+}
 
 #[derive(Clone, Debug)]
 pub(super) struct AttachMetricLabels {
@@ -426,6 +426,7 @@ macro_rules! proxy_def {
         ) -> BoxFuture<'_, Result<tonic::Response<$resp>, tonic::Status>>;
     };
 }
+
 /// Helps re-declare gRPC client methods
 ///
 /// There are four forms:
@@ -447,9 +448,10 @@ macro_rules! proxy_impl {
             mut request: tonic::Request<$req>,
         ) -> BoxFuture<'_, Result<tonic::Response<$resp>, tonic::Status>> {
             $( type_closure_arg(&mut request, $closure); )*
+            let mut self_clone = self.clone();
             #[allow(unused_mut)]
-            let fact = |c: &mut Self, mut req: tonic::Request<$req>| {
-                let mut c = c.$client_meth();
+            let fact = move |mut req: tonic::Request<$req>| {
+                let mut c = self_clone.$client_meth();
                 async move { c.$method(req).await }.boxed()
             };
             self.call(stringify!($method), fact, request)
@@ -463,10 +465,12 @@ macro_rules! proxy_impl {
             mut request: tonic::Request<$req>,
         ) -> BoxFuture<'_, Result<tonic::Response<$resp>, tonic::Status>> {
             type_closure_arg(&mut request, $closure_request);
+            let workers_info = self.get_workers_info();
+            let mut self_clone = self.clone();
             #[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(), $closure_before);
-                let mut c = c.$client_meth();
+            let fact = move |mut req: tonic::Request<$req>| {
+                let data = type_closure_two_arg(&mut req, workers_info.clone(), $closure_before);
+                let mut c = self_clone.$client_meth();
                 async move {
                     type_closure_two_arg(c.$method(req).await, data, $closure_after)
                 }.boxed()
@@ -519,7 +523,7 @@ macro_rules! proxier_impl {
 
         impl<RC> $trait_name for RC
         where
-            RC: RawGrpcCaller + RawClientProducer + Clone,
+            RC: RawGrpcCaller + RawClientProducer + Clone + Unpin,
         {
             $(
                 proxy_impl!($client_type, $client_meth, $method, $req, $resp
@@ -1102,6 +1106,15 @@ proxier! {
             r.extensions_mut().insert(labels);
         }
     );
+    (
+        count_schedules,
+        CountSchedulesRequest,
+        CountSchedulesResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
     (
         update_worker_build_id_compatibility,
         UpdateWorkerBuildIdCompatibilityRequest,
@@ -1479,6 +1492,96 @@ proxier! {
             r.extensions_mut().insert(labels);
         }
     );
+    (
+        pause_workflow_execution,
+        PauseWorkflowExecutionRequest,
+        PauseWorkflowExecutionResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        unpause_workflow_execution,
+        UnpauseWorkflowExecutionRequest,
+        UnpauseWorkflowExecutionResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        start_activity_execution,
+        StartActivityExecutionRequest,
+        StartActivityExecutionResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        describe_activity_execution,
+        DescribeActivityExecutionRequest,
+        DescribeActivityExecutionResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        poll_activity_execution,
+        PollActivityExecutionRequest,
+        PollActivityExecutionResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        list_activity_executions,
+        ListActivityExecutionsRequest,
+        ListActivityExecutionsResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        count_activity_executions,
+        CountActivityExecutionsRequest,
+        CountActivityExecutionsResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        request_cancel_activity_execution,
+        RequestCancelActivityExecutionRequest,
+        RequestCancelActivityExecutionResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        terminate_activity_execution,
+        TerminateActivityExecutionRequest,
+        TerminateActivityExecutionResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
+    (
+        delete_activity_execution,
+        DeleteActivityExecutionRequest,
+        DeleteActivityExecutionResponse,
+        |r| {
+            let labels = namespaced_request!(r);
+            r.extensions_mut().insert(labels);
+        }
+    );
 }
 
 proxier! {
@@ -1598,7 +1701,7 @@ proxier! {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{ClientOptions, RetryClient};
+    use crate::{ClientOptions, ConnectionOptions};
     use std::collections::HashSet;
     use temporalio_common::{
         protos::temporal::api::{
@@ -1613,63 +1716,62 @@ mod tests {
     // Just to help make sure some stuff compiles. Not run.
     #[allow(dead_code)]
     async fn raw_client_retry_compiles() {
-        let opts = ClientOptions::builder()
-            .target_url(Url::parse("http://localhost:7233").unwrap())
+        let opts = ConnectionOptions::new(Url::parse("http://localhost:7233").unwrap())
             .client_name("test")
             .client_version("0.0.0")
             .build();
-        let raw_client = opts.connect_no_namespace(None).await.unwrap();
-        let mut retry_client = RetryClient::new(raw_client, opts.retry_options);
+        let connection = Connection::connect(opts).await.unwrap();
+        let mut client = Client::new(connection, ClientOptions::new("default").build()).unwrap();
 
         let list_ns_req = ListNamespacesRequest::default();
-        let fact = |c: &mut RetryClient<_>, req| {
-            let mut c = c.workflow_client();
+        let wf_client = client.workflow_client();
+        let fact = move |req| {
+            let mut c = wf_client.clone();
             async move { c.list_namespaces(req).await }.boxed()
         };
-        retry_client
+        client
             .call("whatever", fact, Request::new(list_ns_req.clone()))
             .await
             .unwrap();
 
         // Operator svc method
         let op_del_ns_req = DeleteNamespaceRequest::default();
-        let fact = |c: &mut RetryClient<_>, req| {
-            let mut c = c.operator_client();
+        let op_client = client.operator_client();
+        let fact = move |req| {
+            let mut c = op_client.clone();
             async move { c.delete_namespace(req).await }.boxed()
         };
-        retry_client
+        client
             .call("whatever", fact, Request::new(op_del_ns_req.clone()))
             .await
             .unwrap();
 
         // Cloud svc method
         let cloud_del_ns_req = cloudreq::DeleteNamespaceRequest::default();
-        let fact = |c: &mut RetryClient<_>, req| {
-            let mut c = c.cloud_client();
+        let cloud_client = client.cloud_client();
+        let fact = move |req| {
+            let mut c = cloud_client.clone();
             async move { c.delete_namespace(req).await }.boxed()
         };
-        retry_client
+        client
             .call("whatever", fact, Request::new(cloud_del_ns_req.clone()))
             .await
             .unwrap();
 
         // Verify calling through traits works
-        retry_client
+        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.into_request())
+        OperatorService::delete_namespace(&mut client, op_del_ns_req.into_request())
             .await
             .unwrap();
-        CloudService::delete_namespace(&mut retry_client, cloud_del_ns_req.into_request())
+        CloudService::delete_namespace(&mut client, cloud_del_ns_req.into_request())
             .await
             .unwrap();
-        retry_client
-            .get_current_time(().into_request())
-            .await
-            .unwrap();
-        retry_client
+        client.get_current_time(().into_request()).await.unwrap();
+        client
             .check(HealthCheckRequest::default().into_request())
             .await
             .unwrap();
@@ -1941,4 +2043,113 @@ mod tests {
             .await
             .unwrap();
     }
+
+    /// Tests that Connection's RawClientProducer impl correctly provides worker info
+    /// so that eager workflow start can reserve a slot and dispatch the WFT.
+    #[tokio::test]
+    async fn connection_eager_start_dispatches_wft() {
+        use crate::{
+            ConnectionOptions,
+            callback_based::{CallbackBasedGrpcService, GrpcSuccessResponse},
+            worker::{MockClientWorker, MockSlot},
+        };
+        use prost::Message;
+        use std::sync::atomic::{AtomicBool, Ordering};
+        use temporalio_common::protos::temporal::api::workflowservice::v1::PollWorkflowTaskQueueResponse;
+
+        let dispatched = Arc::new(AtomicBool::new(false));
+        let dispatched_clone = dispatched.clone();
+
+        // Create a callback-based service that returns an eager_workflow_task in the response
+        let service_override = CallbackBasedGrpcService {
+            callback: Arc::new(|_req| {
+                Box::pin(async {
+                    let resp = StartWorkflowExecutionResponse {
+                        run_id: "test-run-id".to_string(),
+                        eager_workflow_task: Some(PollWorkflowTaskQueueResponse {
+                            task_token: vec![1, 2, 3],
+                            ..Default::default()
+                        }),
+                        ..Default::default()
+                    };
+                    let proto = resp.encode_to_vec();
+                    Ok(GrpcSuccessResponse {
+                        headers: Default::default(),
+                        proto,
+                    })
+                })
+            }),
+        };
+
+        let opts = ConnectionOptions::new(url::Url::parse("http://localhost:7233").unwrap())
+            .skip_get_system_info(true)
+            .service_override(service_override)
+            .build();
+        let mut connection = crate::Connection::connect(opts).await.unwrap();
+
+        // Register a mock worker on the connection's worker set
+        let mut mock_worker = MockClientWorker::new();
+        mock_worker
+            .expect_namespace()
+            .return_const("default".to_string());
+        mock_worker
+            .expect_task_queue()
+            .return_const("test-tq".to_string());
+        mock_worker
+            .expect_deployment_options()
+            .return_const(None::<temporalio_common::worker::WorkerDeploymentOptions>);
+        mock_worker.expect_heartbeat_enabled().return_const(false);
+        let uuid = Uuid::new_v4();
+        mock_worker.expect_worker_instance_key().return_const(uuid);
+        mock_worker
+            .expect_worker_task_types()
+            .return_const(WorkerTaskTypes {
+                enable_workflows: true,
+                enable_local_activities: false,
+                enable_remote_activities: false,
+                enable_nexus: false,
+            });
+
+        let mut mock_slot = MockSlot::new();
+        mock_slot.expect_schedule_wft().returning(move |_| {
+            dispatched_clone.store(true, Ordering::SeqCst);
+            Ok(())
+        });
+        mock_worker
+            .expect_try_reserve_wft_slot()
+            .return_once(|| Some(Box::new(mock_slot)));
+
+        connection
+            .workers()
+            .register_worker(Arc::new(mock_worker), true)
+            .unwrap();
+
+        // Make an eager start_workflow_execution call through Connection
+        let req = StartWorkflowExecutionRequest {
+            namespace: "default".to_string(),
+            workflow_id: "test-wf".to_string(),
+            workflow_type: Some(
+                temporalio_common::protos::temporal::api::common::v1::WorkflowType {
+                    name: "test-workflow".to_string(),
+                },
+            ),
+            task_queue: Some(TaskQueue {
+                name: "test-tq".to_string(),
+                kind: 0,
+                normal_name: String::new(),
+            }),
+            request_eager_execution: true,
+            ..Default::default()
+        };
+
+        connection
+            .start_workflow_execution(req.into_request())
+            .await
+            .unwrap();
+
+        assert!(
+            dispatched.load(Ordering::SeqCst),
+            "Eager workflow task should have been dispatched to the worker"
+        );
+    }
 }