@temporalio/core-bridge 1.7.1 → 1.7.3

package/sdk-core/core/src/internal_flags.rs

@@ -1,7 +1,11 @@
 //! Utilities for and tracking of internal versions which alter history in incompatible ways
 //! so that we can use older code paths for workflows executed on older core versions.
 
-use std::collections::{BTreeSet, HashSet};
+use itertools::Either;
+use std::{
+    collections::{BTreeSet, HashSet},
+    iter,
+};
 use temporal_sdk_core_protos::temporal::api::{
     history::v1::WorkflowTaskCompletedEventAttributes, sdk::v1::WorkflowTaskCompletedMetadata,
     workflowservice::v1::get_system_info_response,
@@ -15,7 +19,7 @@ use temporal_sdk_core_protos::temporal::api::{
 /// that removing older variants does not create any change in existing values. Removed flag
 /// variants must be reserved forever (a-la protobuf), and should be called out in a comment.
 #[repr(u32)]
-#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Copy, Clone, Debug)]
+#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Copy, Clone, Debug, enum_iterator::Sequence)]
 pub(crate) enum CoreInternalFlags {
     /// In this flag additional checks were added to a number of state machines to ensure that
     /// the ID and type of activities, local activities, and child workflows match during replay.
@@ -28,64 +32,85 @@ pub(crate) enum CoreInternalFlags {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct InternalFlags {
-    enabled: bool,
-    core: BTreeSet<CoreInternalFlags>,
-    lang: BTreeSet<u32>,
-    core_since_last_complete: HashSet<CoreInternalFlags>,
-    lang_since_last_complete: HashSet<u32>,
+pub(crate) enum InternalFlags {
+    Enabled {
+        core: BTreeSet<CoreInternalFlags>,
+        lang: BTreeSet<u32>,
+        core_since_last_complete: HashSet<CoreInternalFlags>,
+        lang_since_last_complete: HashSet<u32>,
+    },
+    Disabled,
 }
 
 impl InternalFlags {
     pub fn new(server_capabilities: &get_system_info_response::Capabilities) -> Self {
-        Self {
-            enabled: server_capabilities.sdk_metadata,
-            core: Default::default(),
-            lang: Default::default(),
-            core_since_last_complete: Default::default(),
-            lang_since_last_complete: Default::default(),
+        match server_capabilities.sdk_metadata {
+            true => Self::Enabled {
+                core: Default::default(),
+                lang: Default::default(),
+                core_since_last_complete: Default::default(),
+                lang_since_last_complete: Default::default(),
+            },
+            false => Self::Disabled,
         }
     }
 
     pub fn add_from_complete(&mut self, e: &WorkflowTaskCompletedEventAttributes) {
-        if !self.enabled {
-            return;
-        }
-
-        if let Some(metadata) = e.sdk_metadata.as_ref() {
-            self.core.extend(
-                metadata
-                    .core_used_flags
-                    .iter()
-                    .map(|u| CoreInternalFlags::from_u32(*u)),
-            );
-            self.lang.extend(metadata.lang_used_flags.iter());
+        if let Self::Enabled { core, lang, .. } = self {
+            if let Some(metadata) = e.sdk_metadata.as_ref() {
+                core.extend(
+                    metadata
+                        .core_used_flags
+                        .iter()
+                        .map(|u| CoreInternalFlags::from_u32(*u)),
+                );
+                lang.extend(metadata.lang_used_flags.iter());
+            }
         }
     }
 
     pub fn add_lang_used(&mut self, flags: impl IntoIterator<Item = u32>) {
-        if !self.enabled {
-            return;
+        if let Self::Enabled {
+            lang_since_last_complete,
+            ..
+        } = self
+        {
+            lang_since_last_complete.extend(flags.into_iter());
         }
-
-        self.lang_since_last_complete.extend(flags.into_iter());
     }
 
     /// Returns true if this flag may currently be used. If `should_record` is true, always returns
     /// true and records the flag as being used, for taking later via
     /// [Self::gather_for_wft_complete].
     pub fn try_use(&mut self, core_patch: CoreInternalFlags, should_record: bool) -> bool {
-        if !self.enabled {
+        match self {
+            Self::Enabled {
+                core,
+                core_since_last_complete,
+                ..
+            } => {
+                if should_record {
+                    core_since_last_complete.insert(core_patch);
+                    true
+                } else {
+                    core.contains(&core_patch)
+                }
+            }
             // If the server does not support the metadata field, we must assume we can never use
             // any internal flags since they can't be recorded for future use
-            return false;
+            Self::Disabled => false,
         }
+    }
 
-        if should_record {
-            self.core_since_last_complete.insert(core_patch);
-            true
-        } else {
-            self.core.contains(&core_patch)
+    /// Writes all known core flags to the set which should be recorded in the current WFT if not
+    /// already known. Must only be called if not replaying.
+    pub fn write_all_known(&mut self) {
+        if let Self::Enabled {
+            core_since_last_complete,
+            ..
+        } = self
+        {
+            core_since_last_complete.extend(CoreInternalFlags::all_except_too_high());
         }
     }
 
@@ -93,18 +118,39 @@ impl InternalFlags {
     /// sdk metadata message that can be combined with any existing data before sending the WFT
     /// complete
     pub fn gather_for_wft_complete(&mut self) -> WorkflowTaskCompletedMetadata {
-        WorkflowTaskCompletedMetadata {
-            core_used_flags: self
-                .core_since_last_complete
-                .drain()
-                .map(|p| p as u32)
-                .collect(),
-            lang_used_flags: self.lang_since_last_complete.drain().collect(),
+        match self {
+            Self::Enabled {
+                core_since_last_complete,
+                lang_since_last_complete,
+                core,
+                lang,
+            } => {
+                let core_newly_used: Vec<_> = core_since_last_complete
+                    .iter()
+                    .filter(|f| !core.contains(f))
+                    .map(|p| *p as u32)
+                    .collect();
+                let lang_newly_used: Vec<_> = lang_since_last_complete
+                    .iter()
+                    .filter(|f| !lang.contains(f))
+                    .copied()
+                    .collect();
+                core.extend(core_since_last_complete.iter());
+                lang.extend(lang_since_last_complete.iter());
+                WorkflowTaskCompletedMetadata {
+                    core_used_flags: core_newly_used,
+                    lang_used_flags: lang_newly_used,
+                }
+            }
+            Self::Disabled => WorkflowTaskCompletedMetadata::default(),
         }
     }
 
-    pub fn all_lang(&self) -> &BTreeSet<u32> {
-        &self.lang
+    pub fn all_lang(&self) -> impl Iterator<Item = u32> + '_ {
+        match self {
+            Self::Enabled { lang, .. } => Either::Left(lang.iter().copied()),
+            Self::Disabled => Either::Right(iter::empty()),
+        }
     }
 }
 
@@ -116,6 +162,11 @@ impl CoreInternalFlags {
             _ => Self::TooHigh,
         }
     }
+
+    pub fn all_except_too_high() -> impl Iterator<Item = CoreInternalFlags> {
+        enum_iterator::all::<CoreInternalFlags>()
+            .filter(|f| !matches!(f, CoreInternalFlags::TooHigh))
+    }
 }
 
 #[cfg(test)]
@@ -138,4 +189,39 @@ mod tests {
         assert_matches!(gathered.core_used_flags.as_slice(), &[]);
         assert_matches!(gathered.lang_used_flags.as_slice(), &[]);
     }
+
+    #[test]
+    fn all_have_u32_from_impl() {
+        let all_known = CoreInternalFlags::all_except_too_high();
+        for flag in all_known {
+            let as_u32 = flag as u32;
+            assert_eq!(CoreInternalFlags::from_u32(as_u32), flag);
+        }
+    }
+
+    #[test]
+    fn only_writes_new_flags() {
+        let mut f = InternalFlags::new(&Capabilities {
+            sdk_metadata: true,
+            ..Default::default()
+        });
+        f.add_lang_used([1]);
+        f.try_use(CoreInternalFlags::IdAndTypeDeterminismChecks, true);
+        let gathered = f.gather_for_wft_complete();
+        assert_matches!(gathered.core_used_flags.as_slice(), &[1]);
+        assert_matches!(gathered.lang_used_flags.as_slice(), &[1]);
+
+        f.add_from_complete(&WorkflowTaskCompletedEventAttributes {
+            sdk_metadata: Some(WorkflowTaskCompletedMetadata {
+                core_used_flags: vec![2],
+                lang_used_flags: vec![2],
+            }),
+            ..Default::default()
+        });
+        f.add_lang_used([2]);
+        f.try_use(CoreInternalFlags::UpsertSearchAttributeOnPatch, true);
+        let gathered = f.gather_for_wft_complete();
+        assert_matches!(gathered.core_used_flags.as_slice(), &[]);
+        assert_matches!(gathered.lang_used_flags.as_slice(), &[]);
+    }
 }

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

@@ -1,11 +1,14 @@
-use crate::abstractions::MeteredSemaphore;
-use crate::worker::activities::PermittedTqResp;
-use crate::{pollers::BoxedActPoller, MetricsContext};
+use crate::{
+    abstractions::MeteredSemaphore, pollers::BoxedActPoller, worker::activities::PermittedTqResp,
+    MetricsContext,
+};
 use futures::{stream, Stream};
-use governor::clock::DefaultClock;
-use governor::middleware::NoOpMiddleware;
-use governor::state::{InMemoryState, NotKeyed};
-use governor::RateLimiter;
+use governor::{
+    clock::DefaultClock,
+    middleware::NoOpMiddleware,
+    state::{InMemoryState, NotKeyed},
+    RateLimiter,
+};
 use std::sync::Arc;
 use temporal_sdk_core_protos::temporal::api::workflowservice::v1::PollActivityTaskQueueResponse;
 use tokio::select;

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

@@ -37,7 +37,10 @@ use governor::{Quota, RateLimiter};
 use std::{
     convert::TryInto,
     future,
-    sync::Arc,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
     time::{Duration, Instant},
 };
 use temporal_sdk_core_protos::{
@@ -117,8 +120,8 @@ impl RemoteInFlightActInfo {
 }
 
 pub(crate) struct WorkerActivityTasks {
-    /// Token used to signal the server task poller that shutdown is beginning
-    poller_shutdown_token: CancellationToken,
+    /// Token which is cancelled once shutdown is beginning
+    shutdown_initiated_token: CancellationToken,
     /// Centralizes management of heartbeat issuing / throttling
     heartbeat_manager: ActivityHeartbeatManager,
     /// Combined stream for any ActivityTask producing source (polls, eager activities,
@@ -169,7 +172,7 @@ impl WorkerActivityTasks {
             metrics.with_new_attrs([activity_worker_type()]),
             MetricsContext::available_task_slots,
         ));
-        let poller_shutdown_token = CancellationToken::new();
+        let shutdown_initiated_token = CancellationToken::new();
         let rate_limiter = max_worker_act_per_sec.and_then(|ps| {
             Quota::with_period(Duration::from_secs_f64(ps.recip())).map(RateLimiter::direct)
         });
@@ -179,7 +182,7 @@ impl WorkerActivityTasks {
             semaphore.clone(),
             rate_limiter,
             metrics.clone(),
-            poller_shutdown_token.clone(),
+            shutdown_initiated_token.clone(),
         );
         let (eager_activities_tx, eager_activities_rx) = unbounded_channel();
         let eager_activities_semaphore = ClosableMeteredSemaphore::new_arc(semaphore);
@@ -199,22 +202,21 @@ impl WorkerActivityTasks {
             starts_stream.map(ActivityTaskSource::from),
             |_: &mut ()| PollNext::Left,
         );
-        // Create a task stream composed of (in poll preference order):
-        //  cancels_stream ------------------------------+--- activity_task_stream
-        //  eager_activities_rx ---+--- starts_stream ---|
-        //  server_poll_stream  ---|
-        let activity_task_stream = Self::merge_source_streams(
+
+        let activity_task_stream = ActivityTaskStream {
             source_stream,
-            outstanding_activity_tasks.clone(),
+            outstanding_tasks: outstanding_activity_tasks.clone(),
             start_tasks_stream_complete,
-            complete_notify.clone(),
-            graceful_shutdown,
+            complete_notify: complete_notify.clone(),
+            grace_period: graceful_shutdown,
             cancels_tx,
-            metrics.clone(),
-        );
+            shutdown_initiated_token: shutdown_initiated_token.clone(),
+            metrics: metrics.clone(),
+        }
+        .streamify();
 
         Self {
-            poller_shutdown_token,
+            shutdown_initiated_token,
             eager_activities_tx,
             heartbeat_manager,
             activity_task_stream: Mutex::new(activity_task_stream.boxed()),
@@ -263,9 +265,7 @@ impl WorkerActivityTasks {
 
         // Prefer eager activities over polling the server
         stream::select_with_strategy(non_poll_stream, poller_stream, |_: &mut ()| PollNext::Left)
-            .map(|res| res.map_err(|err| err.into()))
-            // This map, chain, filter_map sequence is here to cancel the token when this stream ends.
-            .map(Some)
+            .map(|res| Some(res.map_err(Into::into)))
             .chain(futures::stream::once(async move {
                 on_complete_token.cancel();
                 None
@@ -273,98 +273,8 @@ impl WorkerActivityTasks {
             .filter_map(future::ready)
     }
 
-    /// Builds an [ActivityTask] stream for both cancellation tasks from cancels delivered from
-    /// heartbeats as well as new activity starts
-    fn merge_source_streams(
-        source_stream: impl Stream<Item = ActivityTaskSource>,
-        outstanding_tasks: Arc<DashMap<TaskToken, RemoteInFlightActInfo>>,
-        start_tasks_stream_complete: CancellationToken,
-        complete_notify: Arc<Notify>,
-        grace_period: Option<Duration>,
-        cancels_tx: UnboundedSender<PendingActivityCancel>,
-        metrics: MetricsContext,
-    ) -> impl Stream<Item = Result<ActivityTask, PollActivityError>> {
-        let outstanding_tasks_clone = outstanding_tasks.clone();
-        source_stream
-            .filter_map(move |source| {
-                let outstanding_tasks = outstanding_tasks.clone();
-                let metrics = metrics.clone();
-                async move {
-                    match source {
-                        ActivityTaskSource::PendingCancel(next_pc) => {
-                            // It's possible that activity has been completed and we no longer have
-                            // an outstanding activity task. This is fine because it means that we
-                            // no longer need to cancel this activity, so we'll just ignore such
-                            // orphaned cancellations.
-                            if let Some(mut details) =
-                                outstanding_tasks.get_mut(&next_pc.task_token)
-                            {
-                                if details.issued_cancel_to_lang.is_some() {
-                                    // Don't double-issue cancellations
-                                    return None;
-                                }
-
-                                details.issued_cancel_to_lang = Some(next_pc.reason);
-                                if next_pc.reason == ActivityCancelReason::NotFound {
-                                    details.known_not_found = true;
-                                }
-                                Some(Ok(ActivityTask::cancel_from_ids(
-                                    next_pc.task_token.0,
-                                    next_pc.reason,
-                                )))
-                            } else {
-                                debug!(task_token = ?next_pc.task_token,
-                                   "Unknown activity task when issuing cancel");
-                                // If we can't find the activity here, it's already been completed,
-                                // in which case issuing a cancel again is pointless.
-                                None
-                            }
-                        }
-                        ActivityTaskSource::PendingStart(res) => {
-                            Some(res.map(|(task, is_eager)| {
-                                Self::about_to_issue_task(
-                                    outstanding_tasks,
-                                    task,
-                                    is_eager,
-                                    metrics,
-                                )
-                            }))
-                        }
-                    }
-                }
-            })
-            .take_until(async move {
-                start_tasks_stream_complete.cancelled().await;
-                // Issue cancels for any still-living act tasks after the grace period
-                let (grace_killer, stop_grace) = futures_util::future::abortable(async {
-                    if let Some(gp) = grace_period {
-                        // Make sure we've waited at least the grace period. This way if waiting for
-                        // starts to finish took a while, we subtract that from the grace period.
-                        tokio::time::sleep(gp).await;
-                        for mapref in outstanding_tasks_clone.iter() {
-                            let _ = cancels_tx.send(PendingActivityCancel::new(
-                                mapref.key().clone(),
-                                ActivityCancelReason::WorkerShutdown,
-                            ));
-                        }
-                    }
-                });
-                join!(
-                    async {
-                        while !outstanding_tasks_clone.is_empty() {
-                            complete_notify.notified().await
-                        }
-                        // If we were waiting for the grace period but everything already finished,
-                        // we don't need to keep waiting.
-                        stop_grace.abort();
-                    },
-                    grace_killer
-                )
-            })
-    }
-
     pub(crate) fn initiate_shutdown(&self) {
-        self.poller_shutdown_token.cancel();
+        self.shutdown_initiated_token.cancel();
         self.eager_activities_semaphore.close();
     }
 
@@ -518,42 +428,142 @@ impl WorkerActivityTasks {
         }
     }
 
-    /// Called when there is a new [ActivityTask] about to be bubbled up out of the poller
-    fn about_to_issue_task(
-        outstanding_tasks: Arc<DashMap<TaskToken, RemoteInFlightActInfo>>,
-        task: PermittedTqResp,
-        is_eager: bool,
-        metrics: MetricsContext,
-    ) -> ActivityTask {
-        if let Some(ref act_type) = task.resp.activity_type {
-            if let Some(ref wf_type) = task.resp.workflow_type {
-                metrics
-                    .with_new_attrs([
-                        activity_type(act_type.name.clone()),
-                        workflow_type(wf_type.name.clone()),
-                        eager(is_eager),
-                    ])
-                    .act_task_received();
-            }
-        }
-        // There could be an else statement here but since the response should always contain both
-        // activity_type and workflow_type, we won't bother.
+    #[cfg(test)]
+    pub(crate) fn remaining_activity_capacity(&self) -> usize {
+        self.eager_activities_semaphore.available_permits()
+    }
+}
 
-        if let Some(dur) = task.resp.sched_to_start() {
-            metrics.act_sched_to_start_latency(dur);
-        };
+struct ActivityTaskStream<SrcStrm> {
+    source_stream: SrcStrm,
+    outstanding_tasks: Arc<DashMap<TaskToken, RemoteInFlightActInfo>>,
+    start_tasks_stream_complete: CancellationToken,
+    complete_notify: Arc<Notify>,
+    grace_period: Option<Duration>,
+    cancels_tx: UnboundedSender<PendingActivityCancel>,
+    /// Token which is cancelled once shutdown is beginning
+    shutdown_initiated_token: CancellationToken,
+    metrics: MetricsContext,
+}
 
-        outstanding_tasks.insert(
-            task.resp.task_token.clone().into(),
-            RemoteInFlightActInfo::new(&task.resp, task.permit.into_used()),
-        );
+impl<SrcStrm> ActivityTaskStream<SrcStrm>
+where
+    SrcStrm: Stream<Item = ActivityTaskSource>,
+{
+    /// Create a task stream composed of (in poll preference order):
+    ///  cancels_stream ------------------------------+--- activity_task_stream
+    ///  eager_activities_rx ---+--- starts_stream ---|
+    ///  server_poll_stream  ---|
+    fn streamify(self) -> impl Stream<Item = Result<ActivityTask, PollActivityError>> {
+        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();
+        let cancels_tx = self.cancels_tx.clone();
+        self.source_stream
+            .filter_map(move |source| {
+                let res = match source {
+                    ActivityTaskSource::PendingCancel(next_pc) => {
+                        // It's possible that activity has been completed and we no longer have
+                        // an outstanding activity task. This is fine because it means that we
+                        // no longer need to cancel this activity, so we'll just ignore such
+                        // orphaned cancellations.
+                        if let Some(mut details) =
+                            self.outstanding_tasks.get_mut(&next_pc.task_token)
+                        {
+                            if details.issued_cancel_to_lang.is_some() {
+                                // Don't double-issue cancellations
+                                None
+                            } else {
+                                details.issued_cancel_to_lang = Some(next_pc.reason);
+                                if next_pc.reason == ActivityCancelReason::NotFound {
+                                    details.known_not_found = true;
+                                }
+                                Some(Ok(ActivityTask::cancel_from_ids(
+                                    next_pc.task_token.0,
+                                    next_pc.reason,
+                                )))
+                            }
+                        } else {
+                            debug!(task_token = ?next_pc.task_token,
+                                   "Unknown activity task when issuing cancel");
+                            // If we can't find the activity here, it's already been completed,
+                            // in which case issuing a cancel again is pointless.
+                            None
+                        }
+                    }
+                    ActivityTaskSource::PendingStart(res) => {
+                        Some(res.map(|(task, is_eager)| {
+                            if let Some(ref act_type) = task.resp.activity_type {
+                                if let Some(ref wf_type) = task.resp.workflow_type {
+                                    self.metrics
+                                        .with_new_attrs([
+                                            activity_type(act_type.name.clone()),
+                                            workflow_type(wf_type.name.clone()),
+                                            eager(is_eager),
+                                        ])
+                                        .act_task_received();
+                                }
+                            }
+                            // There could be an else statement here but since the response
+                            // should always contain both activity_type and workflow_type, we
+                            // won't bother.
 
-        ActivityTask::start_from_poll_resp(task.resp)
-    }
+                            if let Some(dur) = task.resp.sched_to_start() {
+                                self.metrics.act_sched_to_start_latency(dur);
+                            };
 
-    #[cfg(test)]
-    pub(crate) fn remaining_activity_capacity(&self) -> usize {
-        self.eager_activities_semaphore.available_permits()
+                            let tt: TaskToken = task.resp.task_token.clone().into();
+                            self.outstanding_tasks.insert(
+                                tt.clone(),
+                                RemoteInFlightActInfo::new(&task.resp, task.permit.into_used()),
+                            );
+                            // If we have already waited the grace period and issued cancels,
+                            // this will have been set true, indicating anything that happened
+                            // to be buffered/in-flight/etc should get an immediate cancel. This
+                            // is to allow the user to potentially decide to ignore cancels and
+                            // do work on polls that got received during shutdown.
+                            if should_issue_immediate_cancel.load(Ordering::Acquire) {
+                                let _ = cancels_tx.send(PendingActivityCancel::new(
+                                    tt,
+                                    ActivityCancelReason::WorkerShutdown,
+                                ));
+                            }
+
+                            ActivityTask::start_from_poll_resp(task.resp)
+                        }))
+                    }
+                };
+                async move { res }
+            })
+            .take_until(async move {
+                // Once we've been told to begin cancelling, wait the grace period and then start
+                // cancelling anything outstanding.
+                let (grace_killer, stop_grace) = futures_util::future::abortable(async {
+                    if let Some(gp) = self.grace_period {
+                        self.shutdown_initiated_token.cancelled().await;
+                        tokio::time::sleep(gp).await;
+                        should_issue_immediate_cancel_clone.store(true, Ordering::Release);
+                        for mapref in outstanding_tasks_clone.iter() {
+                            let _ = self.cancels_tx.send(PendingActivityCancel::new(
+                                mapref.key().clone(),
+                                ActivityCancelReason::WorkerShutdown,
+                            ));
+                        }
+                    }
+                });
+                join!(
+                    async {
+                        self.start_tasks_stream_complete.cancelled().await;
+                        while !outstanding_tasks_clone.is_empty() {
+                            self.complete_notify.notified().await
+                        }
+                        // If we were waiting for the grace period but everything already finished,
+                        // we don't need to keep waiting.
+                        stop_grace.abort();
+                    },
+                    grace_killer
+                )
+            })
     }
 }
 

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

@@ -7,12 +7,15 @@ use temporal_sdk_core_protos::{
     coresdk::workflow_commands::QueryResult,
     temporal::api::{
         command::v1::Command,
-        common::v1::{MeteringMetadata, Payloads, WorkflowExecution},
+        common::v1::{
+            MeteringMetadata, Payloads, WorkerVersionCapabilities, WorkerVersionStamp,
+            WorkflowExecution,
+        },
         enums::v1::{TaskQueueKind, WorkflowTaskFailedCause},
         failure::v1::Failure,
         query::v1::WorkflowQueryResult,
         sdk::v1::WorkflowTaskCompletedMetadata,
-        taskqueue::v1::{StickyExecutionAttributes, TaskQueue, TaskQueueMetadata, VersionId},
+        taskqueue::v1::{StickyExecutionAttributes, TaskQueue, TaskQueueMetadata},
         workflowservice::v1::{get_system_info_response::Capabilities, *},
     },
     TaskToken,
@@ -138,8 +141,8 @@ impl WorkerClient for WorkerClientBag {
             } else {
                 self.worker_build_id.clone()
             },
-            worker_versioning_id: Some(VersionId {
-                worker_build_id: self.versioning_build_id(),
+            worker_version_capabilities: Some(WorkerVersionCapabilities {
+                build_id: self.versioning_build_id(),
             }),
         };
 
@@ -166,8 +169,8 @@ impl WorkerClient for WorkerClientBag {
             task_queue_metadata: max_tasks_per_sec.map(|tps| TaskQueueMetadata {
                 max_tasks_per_second: Some(tps),
             }),
-            worker_versioning_id: Some(VersionId {
-                worker_build_id: self.versioning_build_id(),
+            worker_version_capabilities: Some(WorkerVersionCapabilities {
+                build_id: self.versioning_build_id(),
             }),
         };
 
@@ -190,8 +193,9 @@ impl WorkerClient for WorkerClientBag {
             sticky_attributes: request.sticky_attributes,
             return_new_workflow_task: request.return_new_workflow_task,
             force_create_new_workflow_task: request.force_create_new_workflow_task,
-            worker_versioning_id: Some(VersionId {
-                worker_build_id: self.versioning_build_id(),
+            worker_version_stamp: Some(WorkerVersionStamp {
+                build_id: self.versioning_build_id(),
+                bundle_id: "".to_string(),
             }),
             messages: vec![],
             binary_checksum: self.worker_build_id.clone(),