@temporalio/core-bridge 1.11.6 → 1.11.8

package/sdk-core/core/src/worker/activities.rs

@@ -1,5 +1,4 @@
 mod activity_heartbeat_manager;
-mod activity_task_poller_stream;
 mod local_activities;
 
 pub(crate) use local_activities::{
@@ -8,54 +7,49 @@ pub(crate) use local_activities::{
 };
 
 use crate::{
+    PollError, TaskToken,
     abstractions::{
-        ClosableMeteredPermitDealer, MeteredPermitDealer, OwnedMeteredSemPermit,
-        TrackedOwnedMeteredSemPermit, UsedMeteredSemPermit,
+        ClosableMeteredPermitDealer, MeteredPermitDealer, TrackedOwnedMeteredSemPermit,
+        UsedMeteredSemPermit,
     },
-    pollers::BoxedActPoller,
-    telemetry::metrics::{activity_type, eager, workflow_type, MetricsContext},
+    pollers::{BoxedActPoller, PermittedTqResp, TrackedPermittedTqResp, new_activity_task_poller},
+    telemetry::metrics::{MetricsContext, activity_type, eager, workflow_type},
     worker::{
-        activities::{
-            activity_heartbeat_manager::ActivityHeartbeatError,
-            activity_task_poller_stream::new_activity_task_poller,
-        },
-        client::WorkerClient,
+        activities::activity_heartbeat_manager::ActivityHeartbeatError, client::WorkerClient,
     },
-    PollActivityError, TaskToken,
 };
 use activity_heartbeat_manager::ActivityHeartbeatManager;
 use dashmap::DashMap;
 use futures_util::{
-    stream,
+    Stream, StreamExt, stream,
     stream::{BoxStream, PollNext},
-    Stream, StreamExt,
 };
 use std::{
     convert::TryInto,
     future,
     sync::{
-        atomic::{AtomicBool, Ordering},
         Arc,
+        atomic::{AtomicBool, Ordering},
     },
     time::{Duration, Instant, SystemTime},
 };
 use temporal_sdk_core_api::worker::ActivitySlotKind;
 use temporal_sdk_core_protos::{
     coresdk::{
+        ActivityHeartbeat, ActivitySlotInfo,
         activity_result::{self as ar, activity_execution_result as aer},
         activity_task::{ActivityCancelReason, ActivityTask},
-        ActivityHeartbeat, ActivitySlotInfo,
     },
     temporal::api::{
-        failure::v1::{failure::FailureInfo, ApplicationFailureInfo, CanceledFailureInfo, Failure},
+        failure::v1::{ApplicationFailureInfo, CanceledFailureInfo, Failure, failure::FailureInfo},
         workflowservice::v1::PollActivityTaskQueueResponse,
     },
 };
 use tokio::{
     join,
     sync::{
-        mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender},
         Mutex, Notify,
+        mpsc::{UnboundedReceiver, UnboundedSender, unbounded_channel},
     },
     task::JoinHandle,
 };
@@ -147,7 +141,7 @@ pub(crate) struct WorkerActivityTasks {
     heartbeat_manager: ActivityHeartbeatManager,
     /// Combined stream for any ActivityTask producing source (polls, eager activities,
     /// cancellations)
-    activity_task_stream: Mutex<BoxStream<'static, Result<ActivityTask, PollActivityError>>>,
+    activity_task_stream: Mutex<BoxStream<'static, Result<ActivityTask, PollError>>>,
     /// Activities that have been issued to lang but not yet completed
     outstanding_activity_tasks: OutstandingActMap,
     /// Ensures we don't exceed this worker's maximum concurrent activity limit for activities. This
@@ -157,7 +151,7 @@ pub(crate) struct WorkerActivityTasks {
     /// Holds activity tasks we have received in direct response to workflow task completion (a.k.a
     /// eager activities). Tasks received in this stream hold a "tracked" permit that is issued by
     /// the `eager_activities_semaphore`.
-    eager_activities_tx: UnboundedSender<TrackedPermittedTqResp>,
+    eager_activities_tx: UnboundedSender<TrackedPermittedTqResp<PollActivityTaskQueueResponse>>,
     /// Ensures that no activities are in the middle of flushing their results to server while we
     /// try to shut down.
     completers_lock: tokio::sync::RwLock<()>,
@@ -176,7 +170,7 @@ pub(crate) struct WorkerActivityTasks {
 #[derive(derive_more::From)]
 enum ActivityTaskSource {
     PendingCancel(PendingActivityCancel),
-    PendingStart(Result<(PermittedTqResp, bool), PollActivityError>),
+    PendingStart(Result<(PermittedTqResp<PollActivityTaskQueueResponse>, bool), PollError>),
 }
 
 impl WorkerActivityTasks {
@@ -245,11 +239,14 @@ impl WorkerActivityTasks {
 
     /// Merges the server poll and eager [ActivityTask] sources
     fn merge_start_task_sources(
-        non_poll_tasks_rx: UnboundedReceiver<TrackedPermittedTqResp>,
-        poller_stream: impl Stream<Item = Result<PermittedTqResp, tonic::Status>>,
+        non_poll_tasks_rx: UnboundedReceiver<TrackedPermittedTqResp<PollActivityTaskQueueResponse>>,
+        poller_stream: impl Stream<
+            Item = Result<PermittedTqResp<PollActivityTaskQueueResponse>, tonic::Status>,
+        >,
         eager_activities_semaphore: Arc<ClosableMeteredPermitDealer<ActivitySlotKind>>,
         on_complete_token: CancellationToken,
-    ) -> impl Stream<Item = Result<(PermittedTqResp, bool), PollActivityError>> {
+    ) -> impl Stream<Item = Result<(PermittedTqResp<PollActivityTaskQueueResponse>, bool), PollError>>
+    {
         let non_poll_stream = stream::unfold(
             (non_poll_tasks_rx, eager_activities_semaphore),
             |(mut non_poll_tasks_rx, eager_activities_semaphore)| async move {
@@ -302,13 +299,13 @@ impl WorkerActivityTasks {
     ///
     /// Polls the various task sources (server polls, eager activities, cancellations) while
     /// respecting the provided rate limits and allowed concurrency. Returns
-    /// [PollActivityError::ShutDown] after shutdown is completed and all tasks sources are
+    /// [PollError::ShutDown] after shutdown is completed and all tasks sources are
     /// depleted.
-    pub(crate) async fn poll(&self) -> Result<ActivityTask, PollActivityError> {
+    pub(crate) async fn poll(&self) -> Result<ActivityTask, PollError> {
         let mut poller_stream = self.activity_task_stream.lock().await;
         poller_stream.next().await.unwrap_or_else(|| {
             self.poll_returned_shutdown_token.cancel();
-            Err(PollActivityError::ShutDown)
+            Err(PollError::ShutDown)
         })
     }
 
@@ -354,7 +351,7 @@ impl WorkerActivityTasks {
                     aer::Status::Failed(ar::Failure { failure }) => {
                         act_metrics.act_execution_failed();
                         client
-                            .fail_activity_task(task_token.clone(), failure.map(Into::into))
+                            .fail_activity_task(task_token.clone(), failure)
                             .await
                             .err()
                     }
@@ -389,7 +386,7 @@ impl WorkerActivityTasks {
                                 None
                             };
                             client
-                                .cancel_activity_task(task_token.clone(), details.map(Into::into))
+                                .cancel_activity_task(task_token.clone(), details)
                                 .await
                                 .err()
                         }
@@ -485,7 +482,7 @@ where
     ///  cancels_stream ------------------------------+--- activity_task_stream
     ///  eager_activities_rx ---+--- starts_stream ---|
     ///  server_poll_stream  ---|
-    fn streamify(self) -> impl Stream<Item = Result<ActivityTask, PollActivityError>> {
+    fn streamify(self) -> impl Stream<Item = Result<ActivityTask, PollError>> {
         let outstanding_tasks_clone = self.outstanding_tasks.clone();
         let should_issue_immediate_cancel = Arc::new(AtomicBool::new(false));
         let should_issue_immediate_cancel_clone = should_issue_immediate_cancel.clone();
@@ -662,7 +659,7 @@ where
 /// Allows for the handling of activities returned by WFT completions.
 pub(crate) struct ActivitiesFromWFTsHandle {
     sem: Arc<ClosableMeteredPermitDealer<ActivitySlotKind>>,
-    tx: UnboundedSender<TrackedPermittedTqResp>,
+    tx: UnboundedSender<TrackedPermittedTqResp<PollActivityTaskQueueResponse>>,
 }
 
 impl ActivitiesFromWFTsHandle {
@@ -675,7 +672,10 @@ impl ActivitiesFromWFTsHandle {
 
     /// Queue new activity tasks for dispatch received from non-polling sources (ex: eager returns
     /// from WFT completion)
-    pub(crate) fn add_tasks(&self, tasks: impl IntoIterator<Item = TrackedPermittedTqResp>) {
+    pub(crate) fn add_tasks(
+        &self,
+        tasks: impl IntoIterator<Item = TrackedPermittedTqResp<PollActivityTaskQueueResponse>>,
+    ) {
         for t in tasks.into_iter() {
             // Technically we should be reporting `activity_task_received` here, but for simplicity
             // and time insensitivity, that metric is tracked in `about_to_issue_task`.
@@ -684,18 +684,6 @@ impl ActivitiesFromWFTsHandle {
     }
 }
 
-#[derive(Debug)]
-pub(crate) struct PermittedTqResp {
-    pub(crate) permit: OwnedMeteredSemPermit<ActivitySlotKind>,
-    pub(crate) resp: PollActivityTaskQueueResponse,
-}
-
-#[derive(Debug)]
-pub(crate) struct TrackedPermittedTqResp {
-    pub(crate) permit: TrackedOwnedMeteredSemPermit<ActivitySlotKind>,
-    pub(crate) resp: PollActivityTaskQueueResponse,
-}
-
 fn worker_shutdown_failure() -> Failure {
     Failure {
         message: "Worker is shutting down and this activity did not complete in time".to_string(),
@@ -794,7 +782,7 @@ mod tests {
         )
         .await;
         atm.initiate_shutdown();
-        assert_matches!(atm.poll().await.unwrap_err(), PollActivityError::ShutDown);
+        assert_matches!(atm.poll().await.unwrap_err(), PollError::ShutDown);
         atm.shutdown().await;
     }
 
@@ -882,7 +870,7 @@ mod tests {
         }
 
         atm.initiate_shutdown();
-        assert_matches!(atm.poll().await.unwrap_err(), PollActivityError::ShutDown);
+        assert_matches!(atm.poll().await.unwrap_err(), PollError::ShutDown);
         atm.shutdown().await;
     }
 
@@ -967,7 +955,7 @@ mod tests {
         .await;
 
         atm.initiate_shutdown();
-        assert_matches!(atm.poll().await.unwrap_err(), PollActivityError::ShutDown);
+        assert_matches!(atm.poll().await.unwrap_err(), PollError::ShutDown);
         atm.shutdown().await;
     }
 }

package/sdk-core/core/src/worker/client/mocks.rs

@@ -1,7 +1,6 @@
 use super::*;
 use futures_util::Future;
-use std::sync::Arc;
-use std::sync::LazyLock;
+use std::sync::{Arc, LazyLock};
 use temporal_client::SlotManager;
 
 pub(crate) static DEFAULT_WORKERS_REGISTRY: LazyLock<Arc<SlotManager>> =
@@ -32,6 +31,8 @@ pub(crate) fn mock_workflow_client() -> MockWorkerClient {
     r.expect_is_mock().returning(|| true);
     r.expect_shutdown_worker()
         .returning(|_| Ok(ShutdownWorkerResponse {}));
+    r.expect_sdk_name_and_version()
+        .returning(|| ("test-core".to_string(), "0.0.0".to_string()));
     r
 }
 
@@ -43,6 +44,8 @@ pub(crate) fn mock_manual_workflow_client() -> MockManualWorkerClient {
     r.expect_workers()
         .returning(|| DEFAULT_WORKERS_REGISTRY.clone());
     r.expect_is_mock().returning(|| true);
+    r.expect_sdk_name_and_version()
+        .returning(|| ("test-core".to_string(), "0.0.0".to_string()));
     r
 }
 
@@ -61,6 +64,10 @@ mockall::mock! {
             -> impl Future<Output = Result<PollActivityTaskQueueResponse>> + Send + 'b
             where 'a: 'b, Self: 'b;
 
+        fn poll_nexus_task<'a, 'b>(&self, task_queue: String)
+            -> impl Future<Output = Result<PollNexusTaskQueueResponse>> + Send + 'b
+            where 'a: 'b, Self: 'b;
+
         fn complete_workflow_task<'a, 'b>(
             &self,
             request: WorkflowTaskCompletion,
@@ -74,6 +81,13 @@ mockall::mock! {
         ) -> impl Future<Output = Result<RespondActivityTaskCompletedResponse>> + Send + 'b
             where 'a: 'b, Self: 'b;
 
+        fn complete_nexus_task<'a, 'b>(
+            &self,
+            task_token: TaskToken,
+            response: nexus::v1::Response,
+        ) -> impl Future<Output = Result<RespondNexusTaskCompletedResponse>> + Send + 'b
+            where 'a: 'b, Self: 'b;
+
         fn cancel_activity_task<'a, 'b>(
             &self,
             task_token: TaskToken,
@@ -96,6 +110,13 @@ mockall::mock! {
         ) -> impl Future<Output = Result<RespondWorkflowTaskFailedResponse>> + Send + 'b
             where 'a: 'b, Self: 'b;
 
+        fn fail_nexus_task<'a, 'b>(
+            &self,
+            task_token: TaskToken,
+            error: nexus::v1::HandlerError,
+        ) -> impl Future<Output = Result<RespondNexusTaskFailedResponse>> + Send + 'b
+            where 'a: 'b, Self: 'b;
+
         fn record_activity_heartbeat<'a, 'b>(
            &self,
            task_token: TaskToken,
@@ -129,5 +150,6 @@ mockall::mock! {
         fn capabilities(&self) -> Option<Capabilities>;
         fn workers(&self) -> Arc<SlotManager>;
         fn is_mock(&self) -> bool;
+        fn sdk_name_and_version(&self) -> (String, String);
     }
 }

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

@@ -3,8 +3,12 @@
 pub(crate) mod mocks;
 use parking_lot::RwLock;
 use std::sync::Arc;
-use temporal_client::{Client, Namespace, RetryClient, SlotManager, WorkflowService};
+use temporal_client::{
+    Client, IsWorkerTaskLongPoll, Namespace, NamespacedClient, RetryClient, SlotManager,
+    WorkflowService,
+};
 use temporal_sdk_core_protos::{
+    TaskToken,
     coresdk::workflow_commands::QueryResult,
     temporal::api::{
         command::v1::Command,
@@ -14,14 +18,15 @@ use temporal_sdk_core_protos::{
         },
         enums::v1::{TaskQueueKind, WorkflowTaskFailedCause},
         failure::v1::Failure,
+        nexus,
         protocol::v1::Message as ProtocolMessage,
         query::v1::WorkflowQueryResult,
         sdk::v1::WorkflowTaskCompletedMetadata,
         taskqueue::v1::{StickyExecutionAttributes, TaskQueue, TaskQueueMetadata},
         workflowservice::v1::{get_system_info_response::Capabilities, *},
     },
-    TaskToken,
 };
+use tonic::IntoRequest;
 
 type Result<T, E = tonic::Status> = std::result::Result<T, E>;
 
@@ -72,6 +77,8 @@ impl WorkerClientBag {
             Some(WorkerVersionCapabilities {
                 build_id: self.worker_build_id.clone(),
                 use_versioning: self.use_versioning,
+                // TODO: https://github.com/temporalio/sdk-core/issues/866
+                deployment_series_name: "".to_string(),
             })
         } else {
             None
@@ -104,6 +111,7 @@ pub(crate) trait WorkerClient: Sync + Send {
         task_queue: String,
         max_tasks_per_sec: Option<f64>,
     ) -> Result<PollActivityTaskQueueResponse>;
+    async fn poll_nexus_task(&self, task_queue: String) -> Result<PollNexusTaskQueueResponse>;
     async fn complete_workflow_task(
         &self,
         request: WorkflowTaskCompletion,
@@ -113,6 +121,11 @@ pub(crate) trait WorkerClient: Sync + Send {
         task_token: TaskToken,
         result: Option<Payloads>,
     ) -> Result<RespondActivityTaskCompletedResponse>;
+    async fn complete_nexus_task(
+        &self,
+        task_token: TaskToken,
+        response: nexus::v1::Response,
+    ) -> Result<RespondNexusTaskCompletedResponse>;
     async fn record_activity_heartbeat(
         &self,
         task_token: TaskToken,
@@ -134,6 +147,11 @@ pub(crate) trait WorkerClient: Sync + Send {
         cause: WorkflowTaskFailedCause,
         failure: Option<Failure>,
     ) -> Result<RespondWorkflowTaskFailedResponse>;
+    async fn fail_nexus_task(
+        &self,
+        task_token: TaskToken,
+        error: nexus::v1::HandlerError,
+    ) -> Result<RespondNexusTaskFailedResponse>;
     async fn get_workflow_execution_history(
         &self,
         workflow_id: String,
@@ -152,6 +170,8 @@ pub(crate) trait WorkerClient: Sync + Send {
     fn capabilities(&self) -> Option<Capabilities>;
     fn workers(&self) -> Arc<SlotManager>;
     fn is_mock(&self) -> bool;
+    /// Return (sdk_name, sdk_version) from the underlying client configuration
+    fn sdk_name_and_version(&self) -> (String, String);
 }
 
 #[async_trait::async_trait]
@@ -160,13 +180,17 @@ impl WorkerClient for WorkerClientBag {
         &self,
         task_queue: TaskQueue,
     ) -> Result<PollWorkflowTaskQueueResponse> {
-        let request = PollWorkflowTaskQueueRequest {
+        #[allow(deprecated)] // want to list all fields explicitly
+        let mut request = PollWorkflowTaskQueueRequest {
             namespace: self.namespace.clone(),
             task_queue: Some(task_queue),
             identity: self.identity.clone(),
             binary_checksum: self.binary_checksum(),
             worker_version_capabilities: self.worker_version_capabilities(),
-        };
+            deployment_options: None,
+        }
+        .into_request();
+        request.extensions_mut().insert(IsWorkerTaskLongPoll);
 
         Ok(self
             .cloned_client()
@@ -180,7 +204,8 @@ impl WorkerClient for WorkerClientBag {
         task_queue: String,
         max_tasks_per_sec: Option<f64>,
     ) -> Result<PollActivityTaskQueueResponse> {
-        let request = PollActivityTaskQueueRequest {
+        #[allow(deprecated)] // want to list all fields explicitly
+        let mut request = PollActivityTaskQueueRequest {
             namespace: self.namespace.clone(),
             task_queue: Some(TaskQueue {
                 name: task_queue,
@@ -192,7 +217,10 @@ impl WorkerClient for WorkerClientBag {
                 max_tasks_per_second: Some(tps),
             }),
             worker_version_capabilities: self.worker_version_capabilities(),
-        };
+            deployment_options: None,
+        }
+        .into_request();
+        request.extensions_mut().insert(IsWorkerTaskLongPoll);
 
         Ok(self
             .cloned_client()
@@ -201,10 +229,34 @@ impl WorkerClient for WorkerClientBag {
             .into_inner())
     }
 
+    async fn poll_nexus_task(&self, task_queue: String) -> Result<PollNexusTaskQueueResponse> {
+        #[allow(deprecated)] // want to list all fields explicitly
+        let mut request = PollNexusTaskQueueRequest {
+            namespace: self.namespace.clone(),
+            task_queue: Some(TaskQueue {
+                name: task_queue,
+                kind: TaskQueueKind::Normal as i32,
+                normal_name: "".to_string(),
+            }),
+            identity: self.identity.clone(),
+            worker_version_capabilities: self.worker_version_capabilities(),
+            deployment_options: None,
+        }
+        .into_request();
+        request.extensions_mut().insert(IsWorkerTaskLongPoll);
+
+        Ok(self
+            .cloned_client()
+            .poll_nexus_task_queue(request)
+            .await?
+            .into_inner())
+    }
+
     async fn complete_workflow_task(
         &self,
         request: WorkflowTaskCompletion,
     ) -> Result<RespondWorkflowTaskCompletedResponse> {
+        #[allow(deprecated)] // want to list all fields explicitly
         let request = RespondWorkflowTaskCompletedRequest {
             task_token: request.task_token.into(),
             commands: request.commands,
@@ -226,6 +278,8 @@ impl WorkerClient for WorkerClientBag {
                             result_type: completed_type as i32,
                             answer: query_result,
                             error_message,
+                            // TODO: https://github.com/temporalio/sdk-core/issues/867
+                            failure: None,
                         },
                     )
                 })
@@ -233,7 +287,13 @@ impl WorkerClient for WorkerClientBag {
             namespace: self.namespace.clone(),
             sdk_metadata: Some(request.sdk_metadata),
             metering_metadata: Some(request.metering_metadata),
-            capabilities: None,
+            capabilities: Some(respond_workflow_task_completed_request::Capabilities {
+                discard_speculative_workflow_task_with_events: true,
+            }),
+            // TODO: https://github.com/temporalio/sdk-core/issues/866
+            deployment: None,
+            versioning_behavior: 0,
+            deployment_options: None,
         };
         Ok(self
             .cloned_client()
@@ -249,12 +309,35 @@ impl WorkerClient for WorkerClientBag {
     ) -> Result<RespondActivityTaskCompletedResponse> {
         Ok(self
             .cloned_client()
-            .respond_activity_task_completed(RespondActivityTaskCompletedRequest {
-                task_token: task_token.0,
-                result,
-                identity: self.identity.clone(),
+            .respond_activity_task_completed(
+                #[allow(deprecated)] // want to list all fields explicitly
+                RespondActivityTaskCompletedRequest {
+                    task_token: task_token.0,
+                    result,
+                    identity: self.identity.clone(),
+                    namespace: self.namespace.clone(),
+                    worker_version: self.worker_version_stamp(),
+                    // TODO: https://github.com/temporalio/sdk-core/issues/866
+                    deployment: None,
+                    deployment_options: None,
+                },
+            )
+            .await?
+            .into_inner())
+    }
+
+    async fn complete_nexus_task(
+        &self,
+        task_token: TaskToken,
+        response: nexus::v1::Response,
+    ) -> Result<RespondNexusTaskCompletedResponse> {
+        Ok(self
+            .cloned_client()
+            .respond_nexus_task_completed(RespondNexusTaskCompletedRequest {
                 namespace: self.namespace.clone(),
-                worker_version: self.worker_version_stamp(),
+                identity: self.identity.clone(),
+                task_token: task_token.0,
+                response: Some(response),
             })
             .await?
             .into_inner())
@@ -284,13 +367,19 @@ impl WorkerClient for WorkerClientBag {
     ) -> Result<RespondActivityTaskCanceledResponse> {
         Ok(self
             .cloned_client()
-            .respond_activity_task_canceled(RespondActivityTaskCanceledRequest {
-                task_token: task_token.0,
-                details,
-                identity: self.identity.clone(),
-                namespace: self.namespace.clone(),
-                worker_version: self.worker_version_stamp(),
-            })
+            .respond_activity_task_canceled(
+                #[allow(deprecated)] // want to list all fields explicitly
+                RespondActivityTaskCanceledRequest {
+                    task_token: task_token.0,
+                    details,
+                    identity: self.identity.clone(),
+                    namespace: self.namespace.clone(),
+                    worker_version: self.worker_version_stamp(),
+                    // TODO: https://github.com/temporalio/sdk-core/issues/866
+                    deployment: None,
+                    deployment_options: None,
+                },
+            )
             .await?
             .into_inner())
     }
@@ -302,15 +391,21 @@ impl WorkerClient for WorkerClientBag {
     ) -> Result<RespondActivityTaskFailedResponse> {
         Ok(self
             .cloned_client()
-            .respond_activity_task_failed(RespondActivityTaskFailedRequest {
-                task_token: task_token.0,
-                failure,
-                identity: self.identity.clone(),
-                namespace: self.namespace.clone(),
-                // TODO: Implement - https://github.com/temporalio/sdk-core/issues/293
-                last_heartbeat_details: None,
-                worker_version: self.worker_version_stamp(),
-            })
+            .respond_activity_task_failed(
+                #[allow(deprecated)] // want to list all fields explicitly
+                RespondActivityTaskFailedRequest {
+                    task_token: task_token.0,
+                    failure,
+                    identity: self.identity.clone(),
+                    namespace: self.namespace.clone(),
+                    // TODO: Implement - https://github.com/temporalio/sdk-core/issues/293
+                    last_heartbeat_details: None,
+                    worker_version: self.worker_version_stamp(),
+                    // TODO: https://github.com/temporalio/sdk-core/issues/866
+                    deployment: None,
+                    deployment_options: None,
+                },
+            )
             .await?
             .into_inner())
     }
@@ -321,6 +416,7 @@ impl WorkerClient for WorkerClientBag {
         cause: WorkflowTaskFailedCause,
         failure: Option<Failure>,
     ) -> Result<RespondWorkflowTaskFailedResponse> {
+        #[allow(deprecated)] // want to list all fields explicitly
         let request = RespondWorkflowTaskFailedRequest {
             task_token: task_token.0,
             cause: cause as i32,
@@ -330,6 +426,9 @@ impl WorkerClient for WorkerClientBag {
             namespace: self.namespace.clone(),
             messages: vec![],
             worker_version: self.worker_version_stamp(),
+            // TODO: https://github.com/temporalio/sdk-core/issues/866
+            deployment: None,
+            deployment_options: None,
         };
         Ok(self
             .cloned_client()
@@ -338,6 +437,23 @@ impl WorkerClient for WorkerClientBag {
             .into_inner())
     }
 
+    async fn fail_nexus_task(
+        &self,
+        task_token: TaskToken,
+        error: nexus::v1::HandlerError,
+    ) -> Result<RespondNexusTaskFailedResponse> {
+        Ok(self
+            .cloned_client()
+            .respond_nexus_task_failed(RespondNexusTaskFailedRequest {
+                namespace: self.namespace.clone(),
+                identity: self.identity.clone(),
+                task_token: task_token.0,
+                error: Some(error),
+            })
+            .await?
+            .into_inner())
+    }
+
     async fn get_workflow_execution_history(
         &self,
         workflow_id: String,
@@ -373,17 +489,21 @@ impl WorkerClient for WorkerClientBag {
                 query_result,
                 error_message,
                 namespace: self.namespace.clone(),
+                // TODO: https://github.com/temporalio/sdk-core/issues/867
+                failure: None,
             })
             .await?
             .into_inner())
     }
 
     async fn describe_namespace(&self) -> Result<DescribeNamespaceResponse> {
-        temporal_client::WorkflowClientTrait::describe_namespace(
-            &self.cloned_client(),
-            Namespace::Name(self.namespace.clone()),
-        )
-        .await
+        Ok(self
+            .cloned_client()
+            .describe_namespace(
+                Namespace::Name(self.namespace.clone()).into_describe_namespace_request(),
+            )
+            .await?
+            .into_inner())
     }
 
     async fn shutdown_worker(&self, sticky_task_queue: String) -> Result<ShutdownWorkerResponse> {
@@ -419,6 +539,22 @@ impl WorkerClient for WorkerClientBag {
     fn is_mock(&self) -> bool {
         false
     }
+
+    fn sdk_name_and_version(&self) -> (String, String) {
+        let lock = self.replaceable_client.read();
+        let opts = lock.get_client().inner().options();
+        (opts.client_name.clone(), opts.client_version.clone())
+    }
+}
+
+impl NamespacedClient for WorkerClientBag {
+    fn namespace(&self) -> &str {
+        &self.namespace
+    }
+
+    fn get_identity(&self) -> &str {
+        &self.identity
+    }
 }
 
 /// A version of [RespondWorkflowTaskCompletedRequest] that will finish being filled out by the