@temporalio/core-bridge 1.7.0 → 1.7.2

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

@@ -38,7 +38,7 @@ fsm! {
     // upon observing a history event indicating that the command has been recorded. Note that this
     // does not imply that the command has been _executed_, only that it _will be_ executed at some
     // point in the future.
-    CommandIssued --(CommandRecorded(CmdRecDat), shared on_command_recorded) --> Done;
+    CommandIssued --(CommandRecorded, on_command_recorded) --> Done;
 }
 
 /// Instantiates an UpsertSearchAttributesMachine and packs it together with an initial command
@@ -62,37 +62,21 @@ pub(super) fn upsert_search_attrs(
         );
         // We must still create the command to preserve compatability with anyone previously doing
         // this.
-        create_new(Default::default(), true, internal_flags)
+        create_new(Default::default())
     } else {
-        create_new(attribs.search_attributes.into(), false, internal_flags)
+        create_new(attribs.search_attributes.into())
     }
 }
 
 /// May be used by other state machines / internal needs which desire upserting search attributes.
 pub(super) fn upsert_search_attrs_internal(
     attribs: UpsertWorkflowSearchAttributesCommandAttributes,
-    internal_flags: InternalFlagsRef,
 ) -> NewMachineWithCommand {
-    create_new(
-        attribs.search_attributes.unwrap_or_default(),
-        true,
-        internal_flags,
-    )
+    create_new(attribs.search_attributes.unwrap_or_default())
 }
 
-fn create_new(
-    sa_map: SearchAttributes,
-    should_skip_determinism: bool,
-    internal_flags: InternalFlagsRef,
-) -> NewMachineWithCommand {
-    let sm = UpsertSearchAttributesMachine::from_parts(
-        Created {}.into(),
-        SharedState {
-            sa_map: sa_map.clone(),
-            should_skip_determinism,
-            internal_flags,
-        },
-    );
+fn create_new(sa_map: SearchAttributes) -> NewMachineWithCommand {
+    let sm = UpsertSearchAttributesMachine::from_parts(Created {}.into(), SharedState {});
     let cmd = Command {
         command_type: CommandType::UpsertWorkflowSearchAttributes as i32,
         attributes: Some(
@@ -110,11 +94,7 @@ fn create_new(
 }
 
 #[derive(Clone)]
-pub(super) struct SharedState {
-    should_skip_determinism: bool,
-    sa_map: SearchAttributes,
-    internal_flags: InternalFlagsRef,
-}
+pub(super) struct SharedState {}
 
 /// The state-machine-specific set of commands that are the results of state transition in the
 /// UpsertSearchAttributesMachine. There are none of these because this state machine emits the
@@ -131,30 +111,9 @@ pub(super) struct Created {}
 /// higher-level machinery, it transitions into this state.
 #[derive(Debug, Default, Clone, derive_more::Display)]
 pub(super) struct CommandIssued {}
-pub(super) struct CmdRecDat {
-    sa_map: Option<SearchAttributes>,
-    replaying: bool,
-}
 
 impl CommandIssued {
-    pub(super) fn on_command_recorded(
-        self,
-        shared: &mut SharedState,
-        dat: CmdRecDat,
-    ) -> UpsertSearchAttributesMachineTransition<Done> {
-        if shared.internal_flags.borrow_mut().try_use(
-            CoreInternalFlags::UpsertSearchAttributeOnPatch,
-            !dat.replaying,
-        ) {
-            let sa = dat.sa_map.unwrap_or_default();
-            if !shared.should_skip_determinism && shared.sa_map != sa {
-                return TransitionResult::Err(WFMachinesError::Nondeterminism(format!(
-                    "Search attribute upsert calls must remain deterministic, but {:?} does not \
-                 match the attributes from history: {:?}",
-                    shared.sa_map, sa
-                )));
-            }
-        }
+    pub(super) fn on_command_recorded(self) -> UpsertSearchAttributesMachineTransition<Done> {
         TransitionResult::default()
     }
 }
@@ -198,14 +157,9 @@ impl TryFrom<HistEventData> for UpsertSearchAttributesMachineEvents {
 
     fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
         match e.event.attributes {
-            Some(history_event::Attributes::UpsertWorkflowSearchAttributesEventAttributes(
-                attrs,
-            )) => Ok(UpsertSearchAttributesMachineEvents::CommandRecorded(
-                CmdRecDat {
-                    sa_map: attrs.search_attributes,
-                    replaying: e.replaying,
-                },
-            )),
+            Some(history_event::Attributes::UpsertWorkflowSearchAttributesEventAttributes(_)) => {
+                Ok(UpsertSearchAttributesMachineEvents::CommandRecorded)
+            }
             _ => Err(Self::Error::Nondeterminism(format!(
                 "UpsertWorkflowSearchAttributesMachine does not handle {e}"
             ))),
@@ -241,7 +195,6 @@ impl From<Created> for CommandIssued {
 mod tests {
     use super::{super::OnEventWrapper, *};
     use crate::{
-        internal_flags::InternalFlags,
         replay::TestHistoryBuilder,
         test_help::{build_mock_pollers, mock_worker, MockPollCfg, ResponseType},
         worker::{
@@ -249,8 +202,8 @@ mod tests {
             workflow::{machines::patch_state_machine::VERSION_SEARCH_ATTR_KEY, ManagedWFFunc},
         },
     };
-    use rustfsm::{MachineError, StateMachine};
-    use std::{cell::RefCell, collections::HashMap, rc::Rc};
+    use rustfsm::StateMachine;
+    use std::collections::HashMap;
     use temporal_sdk::{WfContext, WorkflowFunction};
     use temporal_sdk_core_api::Worker;
     use temporal_sdk_core_protos::{
@@ -317,25 +270,14 @@ mod tests {
     }
 
     #[rstest::rstest]
-    fn upsert_search_attrs_sm(#[values(true, false)] nondetermistic: bool) {
-        let mut sm = UpsertSearchAttributesMachine::from_parts(
-            Created {}.into(),
-            SharedState {
-                sa_map: Default::default(),
-                should_skip_determinism: false,
-                internal_flags: Rc::new(RefCell::new(InternalFlags::all_core_enabled())),
-            },
-        );
-
-        let sa_attribs = if nondetermistic {
-            UpsertWorkflowSearchAttributesEventAttributes {
-                workflow_task_completed_event_id: 0,
-                search_attributes: Some(SearchAttributes {
-                    indexed_fields: HashMap::from([("Yo".to_string(), Payload::default())]),
-                }),
-            }
-        } else {
-            Default::default()
+    fn upsert_search_attrs_sm() {
+        let mut sm = UpsertSearchAttributesMachine::from_parts(Created {}.into(), SharedState {});
+
+        let sa_attribs = UpsertWorkflowSearchAttributesEventAttributes {
+            workflow_task_completed_event_id: 0,
+            search_attributes: Some(SearchAttributes {
+                indexed_fields: HashMap::from([("Yo".to_string(), Payload::default())]),
+            }),
         };
         let recorded_history_event = HistoryEvent {
             event_type: EventType::UpsertWorkflowSearchAttributes as i32,
@@ -365,15 +307,8 @@ mod tests {
         assert_eq!(CommandIssued {}.to_string(), sm.state().to_string());
 
         let recorded_res = OnEventWrapper::on_event_mut(&mut sm, cmd_recorded_sm_event);
-        if nondetermistic {
-            assert_matches!(
-                recorded_res.unwrap_err(),
-                MachineError::Underlying(WFMachinesError::Nondeterminism(_))
-            );
-        } else {
-            recorded_res.expect("CommandRecorded should transition CommandIssued -> Done");
-            assert_eq!(Done {}.to_string(), sm.state().to_string());
-        }
+        recorded_res.expect("CommandRecorded should transition CommandIssued -> Done");
+        assert_eq!(Done {}.to_string(), sm.state().to_string());
     }
 
     #[rstest::rstest]

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

@@ -331,6 +331,11 @@ impl WorkflowMachines {
     /// sent off to the server. They are not removed from the internal queue, that happens when
     /// corresponding history events from the server are being handled.
     pub(crate) fn get_commands(&self) -> Vec<ProtoCommand> {
+        // Since we're about to write a WFT, record any internal flags we know about which aren't
+        // already recorded.
+        (*self.observed_internal_flags)
+            .borrow_mut()
+            .write_all_known();
         self.commands
             .iter()
             .filter_map(|c| {
@@ -363,8 +368,6 @@ impl WorkflowMachines {
             available_internal_flags: (*self.observed_internal_flags)
                 .borrow()
                 .all_lang()
-                .iter()
-                .copied()
                 .collect(),
         }
     }
@@ -924,10 +927,7 @@ impl WorkflowMachines {
                     }
                     ProtoCmdAttrs::UpsertWorkflowSearchAttributesCommandAttributes(attrs) => {
                         self.add_cmd_to_wf_task(
-                            upsert_search_attrs_internal(
-                                attrs,
-                                self.observed_internal_flags.clone(),
-                            ),
+                            upsert_search_attrs_internal(attrs),
                             CommandIdKind::NeverResolves,
                         );
                     }

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

@@ -550,8 +550,15 @@ impl ManagedRun {
 
     /// Delete the currently tracked workflow activation and return it, if any. Should be called
     /// after the processing of the activation completion, and WFT reporting.
-    pub(super) fn delete_activation(&mut self) -> Option<OutstandingActivation> {
-        self.activation.take()
+    pub(super) fn delete_activation(
+        &mut self,
+        pred: impl FnOnce(&OutstandingActivation) -> bool,
+    ) -> Option<OutstandingActivation> {
+        if self.activation().map(pred).unwrap_or_default() {
+            self.activation.take()
+        } else {
+            None
+        }
     }
 
     /// Called when local activities resolve

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

@@ -23,8 +23,8 @@ pub(crate) use managed_run::ManagedWFFunc;
 
 use crate::{
     abstractions::{
-        stream_when_allowed, take_cell::TakeCell, MeteredSemaphore, TrackedOwnedMeteredSemPermit,
-        UsedMeteredSemPermit,
+        dbg_panic, stream_when_allowed, take_cell::TakeCell, MeteredSemaphore,
+        TrackedOwnedMeteredSemPermit, UsedMeteredSemPermit,
     },
     internal_flags::InternalFlags,
     protosext::{legacy_query_failure, ValidPollWFTQResponse},
@@ -294,6 +294,7 @@ impl Workflows {
                                 workflow_completion::Success::from_variants(vec![]).into(),
                             ),
                         },
+                        true,
                         // We need to say a type, but the type is irrelevant, so imagine some
                         // boxed function we'll never call.
                         Option::<Box<dyn Fn(PostActivateHookData) + Send>>::None,
@@ -309,6 +310,7 @@ impl Workflows {
                             run_id,
                             status: Some(auto_fail_to_complete_status(machines_err)),
                         },
+                        true,
                         Option::<Box<dyn Fn(PostActivateHookData) + Send>>::None,
                     )
                     .await?;
@@ -324,8 +326,9 @@ impl Workflows {
     pub(super) async fn activation_completed(
         &self,
         completion: WorkflowActivationCompletion,
+        is_autocomplete: bool,
         post_activate_hook: Option<impl Fn(PostActivateHookData)>,
-    ) -> Result<usize, CompleteWfError> {
+    ) -> Result<(), CompleteWfError> {
         let is_empty_completion = completion.is_empty();
         let completion = validate_completion(completion)?;
         let run_id = completion.run_id().to_string();
@@ -337,7 +340,7 @@ impl Workflows {
         if !was_sent {
             if is_empty_completion {
                 // Empty complete which is likely an evict reply, we can just ignore.
-                return Ok(0);
+                return Ok(());
             }
             panic!(
                 "A non-empty completion was not processed. Workflow processing may have \
@@ -345,9 +348,18 @@ impl Workflows {
             );
         }
 
-        let completion_outcome = rx
-            .await
-            .expect("Send half of activation complete response not dropped");
+        let completion_outcome = if let Ok(c) = rx.await {
+            c
+        } else {
+            dbg_panic!("Send half of activation complete response channel went missing");
+            self.request_eviction(
+                run_id,
+                "Send half of activation complete response channel went missing",
+                EvictionReason::Fatal,
+            );
+            return Ok(());
+        };
+
         let mut wft_from_complete = None;
         let wft_report_status = match completion_outcome.outcome {
             ActivationCompleteOutcome::ReportWFTSuccess(report) => match report {
@@ -460,9 +472,10 @@ impl Workflows {
             run_id,
             wft_report_status,
             wft_from_complete: maybe_pwft,
+            is_autocomplete,
         });
 
-        Ok(completion_outcome.most_recently_processed_event)
+        Ok(())
     }
 
     /// Tell workflow that a local activity has finished with the provided result
@@ -932,6 +945,7 @@ struct PostActivationMsg {
     run_id: String,
     wft_report_status: WFTReportStatus,
     wft_from_complete: Option<(PreparedWFT, HistoryPaginator)>,
+    is_autocomplete: bool,
 }
 #[derive(Debug, Clone)]
 #[cfg_attr(

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

@@ -338,37 +338,39 @@ impl WFStream {
 
         // If we reported to server, we always want to mark it complete.
         let maybe_t = self.complete_wft(run_id, report.wft_report_status);
-        // Delete the activation
-        let activation = self
-            .runs
-            .get_mut(run_id)
-            .and_then(|rh| rh.delete_activation());
-
-        // Evict the run if the activation contained an eviction
-        let mut applied_buffered_poll_for_this_run = false;
-        if activation.map(|a| a.has_eviction()).unwrap_or_default() {
-            debug!(run_id=%run_id, "Evicting run");
-
-            if let Some(mut rh) = self.runs.remove(run_id) {
-                if let Some(buff) = rh.take_buffered_wft() {
-                    // Don't try to apply a buffered poll for this run if we just got a new WFT
-                    // from completing, because by definition that buffered poll is now an
-                    // out-of-date WFT.
-                    if wft_from_complete.is_none() {
-                        res = self.instantiate_or_update(buff);
-                        applied_buffered_poll_for_this_run = true;
+        // Delete the activation, but only if the report came from lang, or we know the outstanding
+        // activation is expected to be completed internally.
+        if let Some(activation) = self.runs.get_mut(run_id).and_then(|rh| {
+            rh.delete_activation(|act| {
+                !report.is_autocomplete || matches!(act, OutstandingActivation::Autocomplete)
+            })
+        }) {
+            // Evict the run if the activation contained an eviction
+            let mut applied_buffered_poll_for_this_run = false;
+            if activation.has_eviction() {
+                debug!(run_id=%run_id, "Evicting run");
+
+                if let Some(mut rh) = self.runs.remove(run_id) {
+                    if let Some(buff) = rh.take_buffered_wft() {
+                        // Don't try to apply a buffered poll for this run if we just got a new WFT
+                        // from completing, because by definition that buffered poll is now an
+                        // out-of-date WFT.
+                        if wft_from_complete.is_none() {
+                            res = self.instantiate_or_update(buff);
+                            applied_buffered_poll_for_this_run = true;
+                        }
                     }
                 }
-            }
 
-            // Attempt to apply a buffered poll for some *other* run, if we didn't have a wft
-            // from complete or a buffered poll for *this* run.
-            if wft_from_complete.is_none() && !applied_buffered_poll_for_this_run {
-                if let Some(buff) = self.buffered_polls_need_cache_slot.pop_front() {
-                    res = self.instantiate_or_update(buff);
+                // Attempt to apply a buffered poll for some *other* run, if we didn't have a wft
+                // from complete or a buffered poll for *this* run.
+                if wft_from_complete.is_none() && !applied_buffered_poll_for_this_run {
+                    if let Some(buff) = self.buffered_polls_need_cache_slot.pop_front() {
+                        res = self.instantiate_or_update(buff);
+                    }
                 }
-            }
-        };
+            };
+        }
 
         if let Some((wft, pag)) = wft_from_complete {
             debug!(run_id=%wft.execution.run_id, "New WFT from completion");

package/sdk-core/protos/api_upstream/.github/workflows/publish-docs.yml

@@ -0,0 +1,23 @@
+name: Publish docs
+
+on:
+  push:
+    branches:
+      - master
+
+env:
+  VERCEL_ORG_ID: ${{ secrets.VERCEL_ORG_ID }}
+  VERCEL_PROJECT_ID: ${{ secrets.VERCEL_PROJECT_ID }}
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v3
+      - name: Generate docs
+        run: |
+          docker run -v $(pwd)/docs:/out -v $(pwd)/:/protos pseudomuto/protoc-gen-doc --doc_opt=html,index.html $(find temporal/api -type f -name "*.proto")
+      - name: Deploy
+        run: npx vercel deploy docs/ --prod --token=${{ secrets.VERCEL_TOKEN }}

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 buf-breaking gogo-grpc fix-path
+grpc: buf-lint api-linter gogo-grpc fix-path
 
 go-grpc: clean $(PROTO_OUT)
 	printf $(COLOR) "Compile for go-gRPC..."

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

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

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

@@ -121,3 +121,20 @@ message MeteringMetadata {
     //     aip.dev/not-precedent: Negative values make no sense to represent. --)
     uint32 nonfirst_local_activity_execution_attempts = 13;
 }
+
+// Identifies the version(s) of a worker that processed a task
+message WorkerVersionStamp {
+    // An opaque whole-worker identifier
+    string build_id = 1;
+    // Set if the worker used a dynamically loadable bundle to process
+    // the task. The bundle could be a WASM blob, JS bundle, etc.
+    string bundle_id = 2;
+}
+
+// Identifies the version(s) that a worker is compatible with when polling or identifying itself
+message WorkerVersionCapabilities {
+    // An opaque whole-worker identifier
+    string build_id = 1;
+
+    // Later, may include info like "I can process WASM and/or JS bundles"
+}

package/sdk-core/protos/api_upstream/temporal/api/enums/v1/failed_cause.proto

@@ -108,6 +108,8 @@ enum SignalExternalWorkflowExecutionFailedCause {
     SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_UNSPECIFIED = 0;
     SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_EXTERNAL_WORKFLOW_EXECUTION_NOT_FOUND = 1;
     SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_NAMESPACE_NOT_FOUND = 2;
+    // Signal count limit is per workflow and controlled by server dynamic config "history.maximumSignalsPerExecution"
+    SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_SIGNAL_COUNT_LIMIT_EXCEEDED = 3;
 }
 
 enum ResourceExhaustedCause {

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

@@ -193,9 +193,10 @@ message WorkflowTaskCompletedEventAttributes {
     string identity = 3;
     // Binary ID of the worker who completed this task
     string binary_checksum = 4;
-    // ID of the worker who picked up this workflow task, or missing if worker
-    // is not using versioning.
-    temporal.api.taskqueue.v1.VersionId worker_versioning_id = 5;
+    // Version info of the worker who processed this workflow task, or missing if worker is not
+    // using versioning. If present, the `build_id` field within is also used as `binary_checksum`,
+    // which may be omitted in that case (it may also be populated to preserve compatibility).
+    temporal.api.common.v1.WorkerVersionStamp worker_version = 5;
     // Data the SDK wishes to record for itself, but server need not interpret, and does not
     // directly impact workflow state.
     temporal.api.sdk.v1.WorkflowTaskCompletedMetadata sdk_metadata = 6;
@@ -409,6 +410,8 @@ message WorkflowExecutionSignaledEventAttributes {
     // Headers that were passed by the sender of the signal and copied by temporal 
     // server into the workflow task.
     temporal.api.common.v1.Header header = 4;
+    // Indicates the signal did not generate a new workflow task when received.
+    bool skip_generate_workflow_task = 5;
 }
 
 message WorkflowExecutionTerminatedEventAttributes {

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

@@ -29,7 +29,7 @@ option java_package = "io.temporal.api.protocol.v1";
 option java_multiple_files = true;
 option java_outer_classname = "MessageProto";
 option ruby_package = "Temporalio::Api::Protocol::V1";
-option csharp_namespace = "Temporalt.Api.Protocol.V1";
+option csharp_namespace = "Temporalio.Api.Protocol.V1";
 
 import "google/protobuf/any.proto";
 

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

@@ -38,6 +38,7 @@ import "google/protobuf/wrappers.proto";
 import "dependencies/gogoproto/gogo.proto";
 
 import "temporal/api/enums/v1/task_queue.proto";
+import "temporal/api/common/v1/message.proto";
 
 // See https://docs.temporal.io/docs/concepts/task-queues/
 message TaskQueue {
@@ -71,13 +72,12 @@ message TaskQueuePartitionMetadata {
 }
 
 message PollerInfo {
-    // Unix Nano
     google.protobuf.Timestamp last_access_time = 1 [(gogoproto.stdtime) = true];
     string identity = 2;
     double rate_per_second = 3;
-    // If a worker has specified an ID for use with the worker versioning feature while polling,
-    // that id must appear here.
-    VersionId worker_versioning_id = 4;
+    // If a worker has opted into the worker versioning feature while polling, its capabilities will
+    // appear here.
+    temporal.api.common.v1.WorkerVersionCapabilities worker_version_capabilities = 4;
 }
 
 message StickyExecutionAttributes {
@@ -87,22 +87,12 @@ message StickyExecutionAttributes {
     google.protobuf.Duration schedule_to_start_timeout = 2 [(gogoproto.stdduration) = true];
 }
 
-// Used by the worker versioning APIs, represents a node in the version graph for a particular
-// task queue
-message VersionIdNode {
-    VersionId version = 1;
-    // A pointer to the previous version this version is considered to be compatible with
-    VersionIdNode previous_compatible = 2;
-    // A pointer to the last incompatible version (previous major version)
-    VersionIdNode previous_incompatible = 3;
+// Used by the worker versioning APIs, represents an ordering of one or more versions which are
+// considered to be compatible with each other. Currently the versions are always worker build ids.
+message CompatibleVersionSet {
+    // A unique identifier for this version set. Users don't need to understand or care about this
+    // value, but it has value for debugging purposes.
+    string version_set_id = 1;
+    // All the compatible versions, ordered from oldest to newest
+    repeated string build_ids = 2;
 }
-
-// Used by the worker versioning APIs, represents a specific version of something
-// Currently, that's just a whole-worker id. In the future, if we support
-// WASM workflow bundle based versioning, for example, then the inside of this
-// message may become a oneof of different version types.
-message VersionId {
-    // An opaque whole-worker identifier
-    string worker_build_id = 1;
-}
-

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

@@ -35,8 +35,8 @@ import "temporal/api/common/v1/message.proto";
 import "temporal/api/enums/v1/update.proto";
 import "temporal/api/failure/v1/message.proto";
 
-// Sepcifies to the gRPC server how the client wants the UpdateWorkflowExecution
-// call to wait before returning control to the caller.
+// Specifies to the gRPC server how long the client wants the an update-related
+// RPC call to wait before returning control to the caller.
 message WaitPolicy {
 
     // Indicates the update lifecycle stage that the gRPC call should wait for

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

@@ -57,6 +57,8 @@ message WorkflowExecutionInfo {
     string task_queue = 13;
     int64 state_transition_count = 14;
     int64 history_size_bytes = 15;
+    // If set, the most recent worker version stamp that appeared in a workflow task completion
+    temporal.api.common.v1.WorkerVersionStamp most_recent_worker_version_stamp = 16;
 }
 
 message WorkflowExecutionConfig {