@temporalio/core-bridge 1.7.4 → 1.8.1

package/sdk-core/core/src/worker/workflow/machines/workflow_machines.rs

@@ -47,7 +47,7 @@ use std::{
 };
 use temporal_sdk_core_protos::{
     coresdk::{
-        common::NamespacedWorkflowExecution,
+        common::{NamespacedWorkflowExecution, VersioningIntent},
         workflow_activation,
         workflow_activation::{
             workflow_activation_job, NotifyHasPatch, UpdateRandomSeed, WorkflowActivation,
@@ -95,6 +95,11 @@ pub(crate) struct WorkflowMachines {
     pub workflow_type: String,
     /// Identifies the current run
     pub run_id: String,
+    /// The task queue this workflow is operating within
+    pub task_queue: String,
+    /// Is set to true once we've seen the final event in workflow history, to avoid accidentally
+    /// re-applying the final workflow task.
+    pub have_seen_terminal_event: bool,
     /// The time the workflow execution began, as told by the WEStarted event
     workflow_start_time: Option<SystemTime>,
     /// The time the workflow execution finished, as determined by when the machines handled
@@ -108,6 +113,10 @@ pub(crate) struct WorkflowMachines {
     /// The internal flags which have been seen so far during this run's execution and thus are
     /// usable during replay.
     observed_internal_flags: InternalFlagsRef,
+    /// Set on each WFT started event, the most recent size of history in bytes
+    history_size_bytes: u64,
+    /// Set on each WFT started event
+    continue_as_new_suggested: bool,
 
     all_machines: SlotMap<MachineKey, Machines>,
     /// If a machine key is in this map, that machine was created internally by core, not as a
@@ -137,10 +146,6 @@ pub(crate) struct WorkflowMachines {
     /// The workflow that is being driven by this instance of the machines
     drive_me: DrivenWorkflow,
 
-    /// Is set to true once we've seen the final event in workflow history, to avoid accidentally
-    /// re-applying the final workflow task.
-    pub have_seen_terminal_event: bool,
-
     /// Metrics context
     pub metrics: MetricsContext,
 }
@@ -229,6 +234,7 @@ impl WorkflowMachines {
             workflow_id: basics.workflow_id,
             workflow_type: basics.workflow_type,
             run_id: basics.run_id,
+            task_queue: basics.task_queue,
             drive_me: driven_wf,
             replaying,
             metrics: basics.metrics,
@@ -241,6 +247,8 @@ impl WorkflowMachines {
             wft_start_time: None,
             current_wf_time: None,
             observed_internal_flags: Rc::new(RefCell::new(observed_internal_flags)),
+            history_size_bytes: 0,
+            continue_as_new_suggested: false,
             all_machines: Default::default(),
             machine_is_core_created: Default::default(),
             machines_by_event_id: Default::default(),
@@ -369,6 +377,8 @@ impl WorkflowMachines {
                 .borrow()
                 .all_lang()
                 .collect(),
+            history_size_bytes: self.history_size_bytes,
+            continue_as_new_suggested: self.continue_as_new_suggested,
         }
     }
 
@@ -635,6 +645,13 @@ impl WorkflowMachines {
             return self.handle_command_event(event_dat, next_event);
         }
 
+        if let Some(history_event::Attributes::WorkflowTaskStartedEventAttributes(ref attrs)) =
+            event.attributes
+        {
+            self.history_size_bytes = u64::try_from(attrs.history_size_bytes).unwrap_or_default();
+            self.continue_as_new_suggested = attrs.suggest_continue_as_new;
+        }
+
         if let Some(initial_cmd_id) = event.get_initial_command_event_id() {
             // We remove the machine while we it handles events, then return it, to avoid
             // borrowing from ourself mutably.
@@ -1050,24 +1067,27 @@ impl WorkflowMachines {
                 }
                 WFCommand::AddActivity(attrs) => {
                     let seq = attrs.seq;
+                    let use_compat = self.determine_use_compatible_flag(
+                        attrs.versioning_intent(),
+                        &attrs.task_queue,
+                    );
                     self.add_cmd_to_wf_task(
-                        ActivityMachine::new_scheduled(attrs, self.observed_internal_flags.clone()),
+                        ActivityMachine::new_scheduled(
+                            attrs,
+                            self.observed_internal_flags.clone(),
+                            use_compat,
+                        ),
                         CommandID::Activity(seq).into(),
                     );
                 }
                 WFCommand::AddLocalActivity(attrs) => {
                     let seq = attrs.seq;
-                    let attrs: ValidScheduleLA = ValidScheduleLA::from_schedule_la(
-                        attrs,
-                        self.get_started_info()
-                            .as_ref()
-                            .and_then(|x| x.workflow_execution_timeout),
-                    )
-                    .map_err(|e| {
-                        WFMachinesError::Fatal(format!(
-                            "Invalid schedule local activity request (seq {seq}): {e}"
-                        ))
-                    })?;
+                    let attrs: ValidScheduleLA =
+                        ValidScheduleLA::from_schedule_la(attrs).map_err(|e| {
+                            WFMachinesError::Fatal(format!(
+                                "Invalid schedule local activity request (seq {seq}): {e}"
+                            ))
+                        })?;
                     let (la, mach_resp) = new_local_activity(
                         attrs,
                         self.replaying,
@@ -1087,20 +1107,32 @@ impl WorkflowMachines {
                     self.process_cancellation(CommandID::LocalActivity(attrs.seq))?;
                 }
                 WFCommand::CompleteWorkflow(attrs) => {
-                    self.metrics.wf_completed();
+                    if !self.replaying {
+                        self.metrics.wf_completed();
+                    }
                     self.add_terminal_command(complete_workflow(attrs));
                 }
                 WFCommand::FailWorkflow(attrs) => {
-                    self.metrics.wf_failed();
+                    if !self.replaying {
+                        self.metrics.wf_failed();
+                    }
                     self.add_terminal_command(fail_workflow(attrs));
                 }
                 WFCommand::ContinueAsNew(attrs) => {
-                    self.metrics.wf_continued_as_new();
+                    if !self.replaying {
+                        self.metrics.wf_continued_as_new();
+                    }
                     let attrs = self.augment_continue_as_new_with_current_values(attrs);
-                    self.add_terminal_command(continue_as_new(attrs));
+                    let use_compat = self.determine_use_compatible_flag(
+                        attrs.versioning_intent(),
+                        &attrs.task_queue,
+                    );
+                    self.add_terminal_command(continue_as_new(attrs, use_compat));
                 }
                 WFCommand::CancelWorkflow(attrs) => {
-                    self.metrics.wf_canceled();
+                    if !self.replaying {
+                        self.metrics.wf_canceled();
+                    }
                     self.add_terminal_command(cancel_workflow(attrs));
                 }
                 WFCommand::SetPatchMarker(attrs) => {
@@ -1136,10 +1168,15 @@ impl WorkflowMachines {
                 }
                 WFCommand::AddChildWorkflow(attrs) => {
                     let seq = attrs.seq;
+                    let use_compat = self.determine_use_compatible_flag(
+                        attrs.versioning_intent(),
+                        &attrs.task_queue,
+                    );
                     self.add_cmd_to_wf_task(
                         ChildWorkflowMachine::new_scheduled(
                             attrs,
                             self.observed_internal_flags.clone(),
+                            use_compat,
                         ),
                         CommandID::ChildWorkflowStart(seq).into(),
                     );
@@ -1289,6 +1326,21 @@ impl WorkflowMachines {
         }
         attrs
     }
+
+    /// Given a user's versioning intent for a command and that command's target task queue,
+    /// returns whether or not the command should set the flag for attempting to stick within the
+    /// compatible version set
+    fn determine_use_compatible_flag(&self, intent: VersioningIntent, target_tq: &str) -> bool {
+        match intent {
+            VersioningIntent::Compatible => true,
+            VersioningIntent::Default => false,
+            VersioningIntent::Unspecified => {
+                // If the target TQ is empty, that means use same TQ.
+                // When TQs match, use compat by default
+                target_tq.is_empty() || target_tq == self.task_queue
+            }
+        }
+    }
 }
 
 fn str_to_randomness_seed(run_id: &str) -> u64 {

package/sdk-core/core/src/worker/workflow/managed_run/managed_wf_test.rs

@@ -61,7 +61,7 @@ pub struct ManagedWFFunc {
     activation_tx: UnboundedSender<WorkflowActivation>,
     completions_rx: UnboundedReceiver<WorkflowActivationCompletion>,
     completions_sync_tx: crossbeam::channel::Sender<WorkflowActivationCompletion>,
-    future_handle: Option<JoinHandle<WorkflowResult<()>>>,
+    future_handle: Option<JoinHandle<WorkflowResult<Payload>>>,
     was_shutdown: bool,
 }
 
@@ -93,6 +93,7 @@ impl ManagedWFFunc {
                 workflow_id: "wfid".to_string(),
                 workflow_type: "wftype".to_string(),
                 run_id: "runid".to_string(),
+                task_queue: TEST_Q.to_string(),
                 history: hist,
                 metrics: MetricsContext::no_op(),
                 capabilities: DEFAULT_TEST_CAPABILITIES,
@@ -175,7 +176,7 @@ impl ManagedWFFunc {
         Ok(last_act)
     }
 
-    pub async fn shutdown(&mut self) -> WorkflowResult<()> {
+    pub async fn shutdown(&mut self) -> WorkflowResult<Payload> {
         self.was_shutdown = true;
         // Send an eviction to ensure wf exits if it has not finished (ex: feeding partial hist)
         let _ = self.activation_tx.send(create_evict_activation(

package/sdk-core/core/src/worker/workflow/managed_run.rs

@@ -1039,13 +1039,26 @@ impl ManagedRun {
     }
 
     fn reply_to_complete(
-        &self,
+        &mut self,
         outcome: ActivationCompleteOutcome,
         chan: Option<oneshot::Sender<ActivationCompleteResult>>,
     ) {
         if let Some(chan) = chan {
-            chan.send(self.build_activation_complete_result(outcome))
-                .expect("Rcv half of activation reply not dropped");
+            if chan
+                .send(self.build_activation_complete_result(outcome))
+                .is_err()
+            {
+                let warnstr = "The workflow task completer went missing! This likely indicates an \
+                               SDK bug, please report."
+                    .to_string();
+                warn!(run_id=%self.run_id(), "{}", warnstr);
+                self.request_eviction(RequestEvictMsg {
+                    run_id: self.run_id().to_string(),
+                    message: warnstr,
+                    reason: EvictionReason::Fatal,
+                    auto_reply_fail_tt: None,
+                });
+            }
         }
     }
 

package/sdk-core/core/src/worker/workflow/mod.rs

@@ -23,22 +23,19 @@ pub(crate) use managed_run::ManagedWFFunc;
 
 use crate::{
     abstractions::{
-        dbg_panic, stream_when_allowed, take_cell::TakeCell, MeteredSemaphore,
-        TrackedOwnedMeteredSemPermit, UsedMeteredSemPermit,
+        dbg_panic, take_cell::TakeCell, MeteredSemaphore, TrackedOwnedMeteredSemPermit,
+        UsedMeteredSemPermit,
     },
     internal_flags::InternalFlags,
-    protosext::{legacy_query_failure, ValidPollWFTQResponse},
-    telemetry::{
-        metrics::workflow_worker_type, set_trace_subscriber_for_current_thread, TelemetryInstance,
-        VecDisplayer,
-    },
+    protosext::legacy_query_failure,
+    telemetry::{set_trace_subscriber_for_current_thread, TelemetryInstance, VecDisplayer},
     worker::{
         activities::{ActivitiesFromWFTsHandle, LocalActivityManager, TrackedPermittedTqResp},
         client::{WorkerClient, WorkflowTaskCompletion},
         workflow::{
             history_update::HistoryPaginator,
             managed_run::RunUpdateAct,
-            wft_extraction::{HistoryFetchReq, WFTExtractor},
+            wft_extraction::{HistoryFetchReq, WFTExtractor, WFTStreamIn},
             wft_poller::validate_wft,
             workflow_stream::{LocalInput, LocalInputs, WFStream},
         },
@@ -127,14 +124,13 @@ pub(crate) struct Workflows {
     /// If set, can be used to reserve activity task slots for eager-return of new activity tasks.
     activity_tasks_handle: Option<ActivitiesFromWFTsHandle>,
     /// Ensures we stay at or below this worker's maximum concurrent workflow task limit
-    wft_semaphore: MeteredSemaphore,
+    wft_semaphore: Arc<MeteredSemaphore>,
     local_act_mgr: Arc<LocalActivityManager>,
     ever_polled: AtomicBool,
 }
 
 pub(crate) struct WorkflowBasics {
     pub max_cached_workflows: usize,
-    pub max_outstanding_wfts: usize,
     pub shutdown_token: CancellationToken,
     pub metrics: MetricsContext,
     pub namespace: String,
@@ -151,6 +147,7 @@ pub(crate) struct RunBasics<'a> {
     pub workflow_id: String,
     pub workflow_type: String,
     pub run_id: String,
+    pub task_queue: String,
     pub history: HistoryUpdate,
     pub metrics: MetricsContext,
     pub capabilities: &'a get_system_info_response::Capabilities,
@@ -162,7 +159,8 @@ impl Workflows {
         basics: WorkflowBasics,
         sticky_attrs: Option<StickyExecutionAttributes>,
         client: Arc<dyn WorkerClient>,
-        wft_stream: impl Stream<Item = Result<ValidPollWFTQResponse, tonic::Status>> + Send + 'static,
+        wft_semaphore: Arc<MeteredSemaphore>,
+        wft_stream: impl Stream<Item = WFTStreamIn> + Send + 'static,
         local_activity_request_sink: impl LocalActivityRequestSink,
         local_act_mgr: Arc<LocalActivityManager>,
         heartbeat_timeout_rx: UnboundedReceiver<HeartbeatTimeoutMsg>,
@@ -173,16 +171,6 @@ impl Workflows {
         let (fetch_tx, fetch_rx) = unbounded_channel();
         let shutdown_tok = basics.shutdown_token.clone();
         let task_queue = basics.task_queue.clone();
-        let wft_semaphore = MeteredSemaphore::new(
-            basics.max_outstanding_wfts,
-            basics.metrics.with_new_attrs([workflow_worker_type()]),
-            MetricsContext::available_task_slots,
-        );
-        // Only allow polling of the new WFT stream if there are available task slots
-        let proceeder = stream::unfold(wft_semaphore.clone(), |sem| async move {
-            Some((sem.acquire_owned().await.unwrap(), sem))
-        });
-        let wft_stream = stream_when_allowed(wft_stream, proceeder);
         let extracted_wft_stream = WFTExtractor::build(
             client.clone(),
             basics.fetching_concurrency,
@@ -515,6 +503,10 @@ impl Workflows {
     pub(super) fn available_wft_permits(&self) -> usize {
         self.wft_semaphore.available_permits()
     }
+    #[cfg(test)]
+    pub(super) fn unused_wft_permits(&self) -> usize {
+        self.wft_semaphore.unused_permits()
+    }
 
     pub(super) async fn shutdown(&self) -> Result<(), anyhow::Error> {
         if let Some(jh) = self.processing_task.take_once() {
@@ -1235,7 +1227,6 @@ enum CommandID {
 #[derive(Debug, Clone)]
 pub struct WorkflowStartedInfo {
     workflow_task_timeout: Option<Duration>,
-    workflow_execution_timeout: Option<Duration>,
     memo: Option<Memo>,
     search_attrs: Option<SearchAttributes>,
     retry_policy: Option<RetryPolicy>,

package/sdk-core/core/src/worker/workflow/run_cache.rs

@@ -13,6 +13,7 @@ use temporal_sdk_core_protos::temporal::api::workflowservice::v1::get_system_inf
 pub(super) struct RunCache {
     max: usize,
     namespace: String,
+    task_queue: String,
     server_capabilities: get_system_info_response::Capabilities,
     /// Run id -> Data
     runs: LruCache<String, ManagedRun>,
@@ -25,6 +26,7 @@ impl RunCache {
     pub fn new(
         max_cache_size: usize,
         namespace: String,
+        task_queue: String,
         server_capabilities: get_system_info_response::Capabilities,
         local_activity_request_sink: impl LocalActivityRequestSink,
         metrics: MetricsContext,
@@ -39,6 +41,7 @@ impl RunCache {
         Self {
             max: max_cache_size,
             namespace,
+            task_queue,
             server_capabilities,
             runs: LruCache::new(
                 NonZeroUsize::new(lru_size).expect("LRU size is guaranteed positive"),
@@ -72,6 +75,7 @@ impl RunCache {
                 workflow_id: pwft.work.execution.workflow_id.clone(),
                 workflow_type: pwft.work.workflow_type.clone(),
                 run_id: pwft.work.execution.run_id.clone(),
+                task_queue: self.task_queue.clone(),
                 history: history_update,
                 metrics,
                 capabilities: &self.server_capabilities,
@@ -89,6 +93,7 @@ impl RunCache {
     pub fn remove(&mut self, k: &str) -> Option<ManagedRun> {
         let r = self.runs.pop(k);
         self.metrics.cache_size(self.len() as u64);
+        self.metrics.cache_eviction();
         r
     }
 

package/sdk-core/core/src/worker/workflow/wft_extraction.rs

@@ -36,10 +36,7 @@ pub(super) enum WFTExtractorOutput {
     PollerDead,
 }
 
-type WFTStreamIn = (
-    Result<ValidPollWFTQResponse, tonic::Status>,
-    OwnedMeteredSemPermit,
-);
+pub(crate) type WFTStreamIn = Result<(ValidPollWFTQResponse, OwnedMeteredSemPermit), tonic::Status>;
 #[derive(derive_more::From, Debug)]
 pub(super) enum HistoryFetchReq {
     Full(CacheMissFetchReq, Arc<HistfetchRC>),
@@ -58,11 +55,11 @@ impl WFTExtractor {
     ) -> impl Stream<Item = Result<WFTExtractorOutput, tonic::Status>> + Send + 'static {
         let fetch_client = client.clone();
         let wft_stream = wft_stream
-            .map(move |(wft, permit)| {
+            .map(move |stream_in| {
                 let client = client.clone();
                 async move {
-                    match wft {
-                        Ok(wft) => {
+                    match stream_in {
+                        Ok((wft, permit)) => {
                             let run_id = wft.workflow_execution.run_id.clone();
                             let tt = wft.task_token.clone();
                             Ok(match HistoryPaginator::from_poll(wft, client).await {

package/sdk-core/core/src/worker/workflow/wft_poller.rs

@@ -1,15 +1,20 @@
-use crate::{pollers::BoxedWFPoller, protosext::ValidPollWFTQResponse, MetricsContext};
+use crate::{
+    abstractions::OwnedMeteredSemPermit,
+    pollers::{BoxedWFPoller, Poller},
+    protosext::ValidPollWFTQResponse,
+    MetricsContext,
+};
 use futures::{stream, Stream};
 use temporal_sdk_core_protos::temporal::api::workflowservice::v1::PollWorkflowTaskQueueResponse;
 
 pub(crate) fn new_wft_poller(
     poller: BoxedWFPoller,
     metrics: MetricsContext,
-) -> impl Stream<Item = Result<ValidPollWFTQResponse, tonic::Status>> {
+) -> impl Stream<Item = Result<(ValidPollWFTQResponse, OwnedMeteredSemPermit), tonic::Status>> {
     stream::unfold((poller, metrics), |(poller, metrics)| async move {
         loop {
             return match poller.poll().await {
-                Some(Ok(wft)) => {
+                Some(Ok((wft, permit))) => {
                     if wft == PollWorkflowTaskQueueResponse::default() {
                         // We get the default proto in the event that the long poll times out.
                         debug!("Poll wft timeout");
@@ -27,7 +32,7 @@ pub(crate) fn new_wft_poller(
                         }
                     };
                     metrics.wf_tq_poll_ok();
-                    Some((Ok(work), (poller, metrics)))
+                    Some((Ok((work, permit)), (poller, metrics)))
                 }
                 Some(Err(e)) => {
                     warn!(error=?e, "Error while polling for workflow tasks");
@@ -35,7 +40,12 @@ pub(crate) fn new_wft_poller(
                 }
                 // If poller returns None, it's dead, thus we also return None to terminate this
                 // stream.
-                None => None,
+                None => {
+                    // Make sure we call the actual shutdown function here to propagate any panics
+                    // inside the polling tasks as errors.
+                    poller.shutdown_box().await;
+                    None
+                }
             };
         }
     })
@@ -55,8 +65,11 @@ pub(crate) fn validate_wft(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test_help::mock_poller;
+    use crate::{
+        abstractions::MeteredSemaphore, pollers::MockPermittedPollBuffer, test_help::mock_poller,
+    };
     use futures::{pin_mut, StreamExt};
+    use std::sync::Arc;
 
     #[tokio::test]
     async fn poll_timeouts_do_not_produce_responses() {
@@ -66,7 +79,16 @@ mod tests {
             .times(1)
             .returning(|| Some(Ok(PollWorkflowTaskQueueResponse::default())));
         mock_poller.expect_poll().times(1).returning(|| None);
-        let stream = new_wft_poller(Box::new(mock_poller), MetricsContext::no_op());
+        mock_poller.expect_shutdown().times(1).returning(|| ());
+        let sem = Arc::new(MeteredSemaphore::new(
+            10,
+            MetricsContext::no_op(),
+            MetricsContext::available_task_slots,
+        ));
+        let stream = new_wft_poller(
+            Box::new(MockPermittedPollBuffer::new(sem, mock_poller)),
+            MetricsContext::no_op(),
+        );
         pin_mut!(stream);
         assert_matches!(stream.next().await, None);
     }
@@ -78,7 +100,15 @@ mod tests {
             .expect_poll()
             .times(1)
             .returning(|| Some(Err(tonic::Status::internal("ahhh"))));
-        let stream = new_wft_poller(Box::new(mock_poller), MetricsContext::no_op());
+        let sem = Arc::new(MeteredSemaphore::new(
+            10,
+            MetricsContext::no_op(),
+            MetricsContext::available_task_slots,
+        ));
+        let stream = new_wft_poller(
+            Box::new(MockPermittedPollBuffer::new(sem, mock_poller)),
+            MetricsContext::no_op(),
+        );
         pin_mut!(stream);
         assert_matches!(stream.next().await, Some(Err(_)));
     }

package/sdk-core/core/src/worker/workflow/workflow_stream.rs

@@ -97,6 +97,7 @@ impl WFStream {
             runs: RunCache::new(
                 basics.max_cached_workflows,
                 basics.namespace.clone(),
+                basics.task_queue.clone(),
                 basics.server_capabilities.clone(),
                 local_activity_request_sink,
                 basics.metrics.clone(),

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

@@ -1,6 +1,9 @@
 use std::time::Duration;
 use tokio::sync::mpsc::UnboundedSender;
 
+const MAX_OUTSTANDING_WFT_DEFAULT: usize = 100;
+const MAX_CONCURRENT_WFT_POLLS_DEFAULT: usize = 5;
+
 /// Defines per-worker configuration options
 #[derive(Debug, Clone, derive_builder::Builder, serde::Serialize, serde::Deserialize)]
 #[builder(setter(into), build_fn(validate = "Self::validate"))]
@@ -31,7 +34,7 @@ pub struct WorkerConfig {
     /// "outstanding" until all activations it requires have been completed.
     ///
     /// Cannot be larger than `max_cached_workflows`.
-    #[builder(default = "100")]
+    #[builder(default = "MAX_OUTSTANDING_WFT_DEFAULT")]
     pub max_outstanding_workflow_tasks: usize,
     /// The maximum number of activity tasks that will ever be given to this worker concurrently
     #[builder(default = "100")]
@@ -43,7 +46,7 @@ pub struct WorkerConfig {
     /// Maximum number of concurrent poll workflow task requests we will perform at a time on this
     /// worker's task queue. See also [WorkerConfig::nonsticky_to_sticky_poll_ratio]. Must be at
     /// least 1.
-    #[builder(default = "5")]
+    #[builder(default = "MAX_CONCURRENT_WFT_POLLS_DEFAULT")]
     pub max_concurrent_wft_polls: usize,
     /// [WorkerConfig::max_concurrent_wft_polls] * this number = the number of max pollers that will
     /// be allowed for the nonsticky queue when sticky tasks are enabled. If both defaults are used,
@@ -161,6 +164,44 @@ impl WorkerConfigBuilder {
                 );
             }
         }
+        if matches!(self.max_concurrent_wft_polls, Some(1))
+            && self.max_cached_workflows > Some(0)
+            && self
+                .max_outstanding_workflow_tasks
+                .unwrap_or(MAX_OUTSTANDING_WFT_DEFAULT)
+                <= 1
+        {
+            return Err(
+                "`max_outstanding_workflow_tasks` must be at at least 2 when \
+                 `max_cached_workflows` is nonzero"
+                    .to_owned(),
+            );
+        }
+        if self
+            .max_concurrent_wft_polls
+            .unwrap_or(MAX_CONCURRENT_WFT_POLLS_DEFAULT)
+            > self
+                .max_outstanding_workflow_tasks
+                .unwrap_or(MAX_OUTSTANDING_WFT_DEFAULT)
+        {
+            return Err(
+                "`max_concurrent_wft_polls` cannot exceed `max_outstanding_workflow_tasks`"
+                    .to_owned(),
+            );
+        }
+
+        if self.use_worker_versioning.unwrap_or_default()
+            && self
+                .worker_build_id
+                .as_ref()
+                .map(|s| s.is_empty())
+                .unwrap_or_default()
+        {
+            return Err(
+                "`worker_build_id` must be non-empty when `use_worker_versioning` is true"
+                    .to_owned(),
+            );
+        }
         Ok(())
     }
 }

package/sdk-core/protos/api_upstream/Makefile

@@ -29,7 +29,7 @@ $(PROTO_OUT):
 	mkdir $(PROTO_OUT)
 
 ##### Compile proto files for go #####
-grpc: buf-lint api-linter gogo-grpc fix-path
+grpc: buf-lint api-linter buf-breaking gogo-grpc fix-path
 
 go-grpc: clean $(PROTO_OUT)
 	printf $(COLOR) "Compile for go-gRPC..."

package/sdk-core/protos/api_upstream/buf.yaml

@@ -1,12 +1,7 @@
 version: v1
 breaking:
-  ignore:
-    # TODO: Remove after PR 237
-    - temporal/api/taskqueue/v1
-    - temporal/api/workflowservice/v1
-    - temporal/api/history/v1
   use:
-    - PACKAGE
+    - WIRE_JSON
 lint:
   use:
     - DEFAULT

package/sdk-core/protos/api_upstream/temporal/api/batch/v1/message.proto

@@ -37,6 +37,7 @@ import "google/protobuf/timestamp.proto";
 
 import "temporal/api/common/v1/message.proto";
 import "temporal/api/enums/v1/batch_operation.proto";
+import "temporal/api/enums/v1/reset.proto";
 
 message BatchOperationInfo {
   // Batch job ID
@@ -86,4 +87,15 @@ message BatchOperationCancellation {
 message BatchOperationDeletion {
   // The identity of the worker/client
   string identity = 1;
+}
+
+// BatchOperationReset sends reset requests to batch workflows.
+// Keep the parameter in sync with temporal.api.workflowservice.v1.ResetWorkflowExecutionRequest.
+message BatchOperationReset {
+  // Reset type.
+  temporal.api.enums.v1.ResetType reset_type = 1; 
+  // History event reapply options.
+  temporal.api.enums.v1.ResetReapplyType reset_reapply_type = 2; 
+  // The identity of the worker/client.
+  string identity = 3;
 }

package/sdk-core/protos/api_upstream/temporal/api/command/v1/message.proto

@@ -83,6 +83,10 @@ message ScheduleActivityTaskCommandAttributes {
     // Request to start the activity directly bypassing matching service and worker polling
     // The slot for executing the activity should be reserved when setting this field to true.
     bool request_eager_execution = 12;
+    // If this is set, the workflow executing this command wishes to start the activity using
+    // a version compatible with the version that this workflow most recently ran on, if such
+    // behavior is possible.
+    bool use_compatible_version = 13;
 }
 
 message RequestCancelActivityTaskCommandAttributes {
@@ -191,6 +195,9 @@ message ContinueAsNewWorkflowExecutionCommandAttributes {
     temporal.api.common.v1.Header header = 12;
     temporal.api.common.v1.Memo memo = 13;
     temporal.api.common.v1.SearchAttributes search_attributes = 14;
+    // If this is set, the workflow executing this command wishes to continue as new using a version
+    // compatible with the version that this workflow most recently ran on.
+    bool use_compatible_version = 15;
 
     // `workflow_execution_timeout` is omitted as it shouldn't be overridden from within a workflow.
 }
@@ -218,6 +225,10 @@ message StartChildWorkflowExecutionCommandAttributes {
     temporal.api.common.v1.Header header = 14;
     temporal.api.common.v1.Memo memo = 15;
     temporal.api.common.v1.SearchAttributes search_attributes = 16;
+    // If this is set, the workflow executing this command wishes to start the child workflow using
+    // a version compatible with the version that this workflow most recently ran on, if such
+    // behavior is possible.
+    bool use_compatible_version = 17;
 }
 
 message ProtocolMessageCommandAttributes {