@temporalio/core-bridge 1.5.2 → 1.7.0

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

@@ -2,7 +2,8 @@ use super::{
     workflow_machines::MachineResponse, Cancellable, EventInfo, NewMachineWithCommand,
     OnEventWrapper, WFMachinesAdapter, WFMachinesError,
 };
-use rustfsm::{fsm, MachineError, TransitionResult};
+use crate::worker::workflow::machines::HistEventData;
+use rustfsm::{fsm, MachineError, StateMachine, TransitionResult};
 use std::convert::TryFrom;
 use temporal_sdk_core_protos::{
     coresdk::{
@@ -85,10 +86,8 @@ pub(super) fn new_external_signal(
         Some(sig_we::Target::WorkflowExecution(we)) => (we, false),
     };
 
-    let mut s = SignalExternalMachine {
-        state: Created {}.into(),
-        shared_state: SharedState { seq: attrs.seq },
-    };
+    let mut s =
+        SignalExternalMachine::from_parts(Created {}.into(), SharedState { seq: attrs.seq });
     OnEventWrapper::on_event_mut(&mut s, SignalExternalMachineEvents::Schedule)
         .expect("Scheduling signal external wf command doesn't fail");
     let cmd_attrs = command::Attributes::SignalExternalWorkflowExecutionCommandAttributes(
@@ -183,10 +182,11 @@ impl TryFrom<CommandType> for SignalExternalMachineEvents {
         })
     }
 }
-impl TryFrom<HistoryEvent> for SignalExternalMachineEvents {
+impl TryFrom<HistEventData> for SignalExternalMachineEvents {
     type Error = WFMachinesError;
 
-    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
+    fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
+        let e = e.event;
         Ok(match e.event_type() {
             EventType::ExternalWorkflowExecutionSignaled => Self::ExternalWorkflowExecutionSignaled,
             EventType::SignalExternalWorkflowExecutionInitiated => {
@@ -202,15 +202,13 @@ impl TryFrom<HistoryEvent> for SignalExternalMachineEvents {
                     Self::SignalExternalWorkflowExecutionFailed(attrs.cause())
                 } else {
                     return Err(WFMachinesError::Fatal(format!(
-                        "Signal workflow failed attributes were unset: {}",
-                        e
+                        "Signal workflow failed attributes were unset: {e}"
                     )));
                 }
             }
             _ => {
                 return Err(WFMachinesError::Nondeterminism(format!(
-                    "Signal external WF machine does not handle this event: {}",
-                    e
+                    "Signal external WF machine does not handle this event: {e}"
                 )))
             }
         })
@@ -242,7 +240,7 @@ impl WFMachinesAdapter for SignalExternalMachine {
                     seq: self.shared_state.seq,
                     // TODO: Create new failure type upstream for this
                     failure: Some(Failure {
-                        message: format!("Unable to signal external workflow because {}", reason),
+                        message: format!("Unable to signal external workflow because {reason}"),
                         failure_info: Some(FailureInfo::ApplicationFailureInfo(
                             ApplicationFailureInfo {
                                 r#type: f.to_string(),
@@ -297,7 +295,7 @@ impl Cancellable for SignalExternalMachine {
     fn was_cancelled_before_sent_to_server(&self) -> bool {
         // We are only ever in the cancelled state if cancelled before sent to server, there is no
         // after sent cancellation here.
-        matches!(self.state, SignalExternalMachineState::Cancelled(_))
+        matches!(self.state(), SignalExternalMachineState::Cancelled(_))
     }
 }
 
@@ -427,13 +425,10 @@ mod tests {
             SignalExternalMachineState::Cancelled(Cancelled {}),
             Signaled {}.into(),
         ] {
-            let mut s = SignalExternalMachine {
-                state: state.clone(),
-                shared_state: Default::default(),
-            };
+            let mut s = SignalExternalMachine::from_parts(state.clone(), Default::default());
             let cmds = s.cancel().unwrap();
             assert_eq!(cmds.len(), 0);
-            assert_eq!(discriminant(&state), discriminant(&s.state));
+            assert_eq!(discriminant(&state), discriminant(s.state()));
         }
     }
 }

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

@@ -1,9 +1,10 @@
 #![allow(clippy::large_enum_variant)]
 
 use super::{
-    workflow_machines::{MachineResponse, WFMachinesError},
-    Cancellable, EventInfo, NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter,
+    workflow_machines::MachineResponse, Cancellable, EventInfo, NewMachineWithCommand,
+    OnEventWrapper, WFMachinesAdapter,
 };
+use crate::worker::workflow::{machines::HistEventData, WFMachinesError};
 use rustfsm::{fsm, MachineError, StateMachine, TransitionResult};
 use std::convert::TryFrom;
 use temporal_sdk_core_protos::{
@@ -83,20 +84,21 @@ impl TimerMachine {
     }
 
     fn new(attribs: StartTimer) -> Self {
-        Self {
-            state: Created {}.into(),
-            shared_state: SharedState {
+        Self::from_parts(
+            Created {}.into(),
+            SharedState {
                 attrs: attribs,
                 cancelled_before_sent: false,
             },
-        }
+        )
     }
 }
 
-impl TryFrom<HistoryEvent> for TimerMachineEvents {
+impl TryFrom<HistEventData> for TimerMachineEvents {
     type Error = WFMachinesError;
 
-    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
+    fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
+        let e = e.event;
         Ok(match e.event_type() {
             EventType::TimerStarted => Self::TimerStarted(e.event_id),
             EventType::TimerCanceled => Self::TimerCanceled,
@@ -107,15 +109,13 @@ impl TryFrom<HistoryEvent> for TimerMachineEvents {
                     Self::TimerFired(attrs)
                 } else {
                     return Err(WFMachinesError::Fatal(format!(
-                        "Timer fired attribs were unset: {}",
-                        e
+                        "Timer fired attribs were unset: {e}"
                     )));
                 }
             }
             _ => {
                 return Err(WFMachinesError::Nondeterminism(format!(
-                    "Timer machine does not handle this event: {}",
-                    e
+                    "Timer machine does not handle this event: {e}"
                 )))
             }
         })
@@ -178,15 +178,9 @@ impl StartCommandCreated {
         TransitionResult::default()
     }
 
-    pub(super) fn on_cancel(self, dat: SharedState) -> TimerMachineTransition<Canceled> {
-        TransitionResult::ok_shared(
-            vec![],
-            Canceled::default(),
-            SharedState {
-                cancelled_before_sent: true,
-                ..dat
-            },
-        )
+    pub(super) fn on_cancel(self, dat: &mut SharedState) -> TimerMachineTransition<Canceled> {
+        dat.cancelled_before_sent = true;
+        TransitionResult::default()
     }
 }
 
@@ -196,7 +190,7 @@ pub(super) struct StartCommandRecorded {}
 impl StartCommandRecorded {
     pub(super) fn on_timer_fired(
         self,
-        dat: SharedState,
+        dat: &mut SharedState,
         attrs: TimerFiredEventAttributes,
     ) -> TimerMachineTransition<Fired> {
         if dat.attrs.seq.to_string() == attrs.timer_id {
@@ -211,7 +205,7 @@ impl StartCommandRecorded {
 
     pub(super) fn on_cancel(
         self,
-        dat: SharedState,
+        dat: &mut SharedState,
     ) -> TimerMachineTransition<CancelTimerCommandCreated> {
         let cmd = Command {
             command_type: CommandType::CancelTimer as i32,
@@ -256,7 +250,7 @@ impl Cancellable for TimerMachine {
                     vec![MachineResponse::IssueNewCommand(cmd)]
                 }
                 None => vec![],
-                x => panic!("Invalid cancel event response {:?}", x),
+                x => panic!("Invalid cancel event response {x:?}"),
             },
         )
     }
@@ -423,13 +417,10 @@ mod test {
     #[test]
     fn cancels_ignored_terminal() {
         for state in [TimerMachineState::Canceled(Canceled {}), Fired {}.into()] {
-            let mut s = TimerMachine {
-                state: state.clone(),
-                shared_state: Default::default(),
-            };
+            let mut s = TimerMachine::from_parts(state.clone(), Default::default());
             let cmds = s.cancel().unwrap();
             assert_eq!(cmds.len(), 0);
-            assert_eq!(discriminant(&state), discriminant(&s.state));
+            assert_eq!(discriminant(&state), discriminant(s.state()));
         }
     }
 }

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

@@ -144,7 +144,7 @@ mod machine_coverage_report {
                 m @ "ModifyWorkflowPropertiesMachine" => {
                     cover_transitions(m, &mut modify_wf_props, coverage)
                 }
-                m => panic!("Unknown machine {}", m),
+                m => panic!("Unknown machine {m}"),
             }
         }
     }
@@ -168,7 +168,7 @@ mod machine_coverage_report {
         let mut d = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
         d.push("machine_coverage");
         std::fs::create_dir_all(&d).unwrap();
-        d.push(format!("{}_Coverage.puml", machine));
+        d.push(format!("{machine}_Coverage.puml"));
         let mut file = File::create(d).unwrap();
         file.write_all(viz.as_bytes()).unwrap();
     }

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

@@ -1,18 +1,28 @@
-use super::{
-    workflow_machines::{MachineResponse, WFMachinesError},
-    NewMachineWithCommand,
+use super::{workflow_machines::MachineResponse, NewMachineWithCommand};
+use crate::{
+    internal_flags::CoreInternalFlags,
+    worker::workflow::{
+        machines::{
+            patch_state_machine::VERSION_SEARCH_ATTR_KEY, Cancellable, EventInfo, HistEventData,
+            WFMachinesAdapter,
+        },
+        InternalFlagsRef, WFMachinesError,
+    },
 };
-use crate::worker::workflow::machines::{Cancellable, EventInfo, WFMachinesAdapter};
-use rustfsm::{fsm, TransitionResult};
+use rustfsm::{fsm, StateMachine, TransitionResult};
 use temporal_sdk_core_protos::{
     coresdk::workflow_commands::UpsertWorkflowSearchAttributes,
     temporal::api::{
-        command::v1::Command,
+        command::v1::{command, Command, UpsertWorkflowSearchAttributesCommandAttributes},
+        common::v1::SearchAttributes,
         enums::v1::{CommandType, EventType},
-        history::v1::HistoryEvent,
+        history::v1::{history_event, HistoryEvent},
     },
 };
 
+/// By default the server permits SA values under 2k.
+pub(crate) const MAX_SEARCH_ATTR_PAYLOAD_SIZE: usize = 2048;
+
 fsm! {
     pub(super) name UpsertSearchAttributesMachine;
     command UpsertSearchAttributesMachineCommand;
@@ -28,18 +38,70 @@ 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) --> Done;
+    CommandIssued --(CommandRecorded(CmdRecDat), shared on_command_recorded) --> Done;
 }
 
 /// Instantiates an UpsertSearchAttributesMachine and packs it together with an initial command
 /// to apply the provided search attribute update.
 pub(super) fn upsert_search_attrs(
     attribs: UpsertWorkflowSearchAttributes,
+    internal_flags: InternalFlagsRef,
+    replaying: bool,
+) -> NewMachineWithCommand {
+    let has_flag = internal_flags
+        .borrow_mut()
+        .try_use(CoreInternalFlags::UpsertSearchAttributeOnPatch, !replaying);
+    if has_flag
+        && attribs
+            .search_attributes
+            .contains_key(VERSION_SEARCH_ATTR_KEY)
+    {
+        warn!(
+            "Upserting the {VERSION_SEARCH_ATTR_KEY} search attribute directly from workflow code \
+             is not permitted and has no effect!"
+        );
+        // We must still create the command to preserve compatability with anyone previously doing
+        // this.
+        create_new(Default::default(), true, internal_flags)
+    } else {
+        create_new(attribs.search_attributes.into(), false, internal_flags)
+    }
+}
+
+/// 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 {
-    let sm = UpsertSearchAttributesMachine::new();
+    create_new(
+        attribs.search_attributes.unwrap_or_default(),
+        true,
+        internal_flags,
+    )
+}
+
+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,
+        },
+    );
     let cmd = Command {
         command_type: CommandType::UpsertWorkflowSearchAttributes as i32,
-        attributes: Some(attribs.into()),
+        attributes: Some(
+            command::Attributes::UpsertWorkflowSearchAttributesCommandAttributes(
+                UpsertWorkflowSearchAttributesCommandAttributes {
+                    search_attributes: Some(sa_map),
+                },
+            ),
+        ),
     };
     NewMachineWithCommand {
         command: cmd,
@@ -47,8 +109,12 @@ pub(super) fn upsert_search_attrs(
     }
 }
 
-/// Unused but must exist
-type SharedState = ();
+#[derive(Clone)]
+pub(super) struct SharedState {
+    should_skip_determinism: bool,
+    sa_map: SearchAttributes,
+    internal_flags: InternalFlagsRef,
+}
 
 /// 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
@@ -65,21 +131,39 @@ 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
+                )));
+            }
+        }
+        TransitionResult::default()
+    }
+}
 
 /// Once the server has recorded its receipt of the search attribute update, the
 /// UpsertSearchAttributesMachine transitions into this terminal state.
 #[derive(Debug, Default, Clone, derive_more::Display)]
 pub(super) struct Done {}
 
-impl UpsertSearchAttributesMachine {
-    fn new() -> Self {
-        Self {
-            state: Created {}.into(),
-            shared_state: (),
-        }
-    }
-}
-
 impl WFMachinesAdapter for UpsertSearchAttributesMachine {
     /// Transforms an UpsertSearchAttributesMachine-specific command (i.e. an instance of the type
     /// UpsertSearchAttributesMachineCommand) to a more generic form supported by the abstract
@@ -109,14 +193,19 @@ impl Cancellable for UpsertSearchAttributesMachine {}
 // Converts the generic history event with type EventType::UpsertWorkflowSearchAttributes into the
 // UpsertSearchAttributesMachine-specific event type
 // UpsertSearchAttributesMachineEvents::CommandRecorded.
-impl TryFrom<HistoryEvent> for UpsertSearchAttributesMachineEvents {
+impl TryFrom<HistEventData> for UpsertSearchAttributesMachineEvents {
     type Error = WFMachinesError;
 
-    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
-        match e.event_type() {
-            EventType::UpsertWorkflowSearchAttributes => {
-                Ok(UpsertSearchAttributesMachineEvents::CommandRecorded)
-            }
+    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,
+                },
+            )),
             _ => Err(Self::Error::Nondeterminism(format!(
                 "UpsertWorkflowSearchAttributesMachine does not handle {e}"
             ))),
@@ -141,13 +230,6 @@ impl TryFrom<CommandType> for UpsertSearchAttributesMachineEvents {
     }
 }
 
-// There is no Command/Response associated with this transition
-impl From<CommandIssued> for Done {
-    fn from(_: CommandIssued) -> Self {
-        Self {}
-    }
-}
-
 // There is no Command/Response associated with this transition
 impl From<Created> for CommandIssued {
     fn from(_: Created) -> Self {
@@ -158,12 +240,30 @@ impl From<Created> for CommandIssued {
 #[cfg(test)]
 mod tests {
     use super::{super::OnEventWrapper, *};
-    use crate::{replay::TestHistoryBuilder, worker::workflow::ManagedWFFunc};
-    use rustfsm::StateMachine;
+    use crate::{
+        internal_flags::InternalFlags,
+        replay::TestHistoryBuilder,
+        test_help::{build_mock_pollers, mock_worker, MockPollCfg, ResponseType},
+        worker::{
+            client::mocks::mock_workflow_client,
+            workflow::{machines::patch_state_machine::VERSION_SEARCH_ATTR_KEY, ManagedWFFunc},
+        },
+    };
+    use rustfsm::{MachineError, StateMachine};
+    use std::{cell::RefCell, collections::HashMap, rc::Rc};
     use temporal_sdk::{WfContext, WorkflowFunction};
-    use temporal_sdk_core_protos::temporal::api::{
-        command::v1::command::Attributes, common::v1::Payload,
+    use temporal_sdk_core_api::Worker;
+    use temporal_sdk_core_protos::{
+        coresdk::{
+            workflow_commands::SetPatchMarker, workflow_completion::WorkflowActivationCompletion,
+            AsJsonPayloadExt,
+        },
+        temporal::api::{
+            command::v1::command::Attributes, common::v1::Payload,
+            history::v1::UpsertWorkflowSearchAttributesEventAttributes,
+        },
     };
+    use temporal_sdk_core_test_utils::WorkerTestHelpers;
 
     #[tokio::test]
     async fn upsert_search_attrs_from_workflow() {
@@ -216,27 +316,133 @@ mod tests {
         wfm.shutdown().await.unwrap();
     }
 
-    #[tokio::test]
-    async fn upsert_search_attrs_sm() {
-        let mut sm = UpsertSearchAttributesMachine::new();
-        assert_eq!(Created {}.to_string(), sm.state().to_string());
+    #[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 cmd_scheduled_sm_event = CommandType::UpsertWorkflowSearchAttributes
-            .try_into()
-            .unwrap();
+        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()
+        };
         let recorded_history_event = HistoryEvent {
             event_type: EventType::UpsertWorkflowSearchAttributes as i32,
+            attributes: Some(
+                history_event::Attributes::UpsertWorkflowSearchAttributesEventAttributes(
+                    sa_attribs,
+                ),
+            ),
             ..Default::default()
         };
         assert!(sm.matches_event(&recorded_history_event));
-        let cmd_recorded_sm_event = recorded_history_event.try_into().unwrap();
+        let cmd_recorded_sm_event = HistEventData {
+            event: recorded_history_event,
+            replaying: false,
+            current_task_is_last_in_history: true,
+        }
+        .try_into()
+        .unwrap();
 
-        OnEventWrapper::on_event_mut(&mut sm, cmd_scheduled_sm_event)
-            .expect("CommandScheduled should transition Created -> CommandIssued");
+        OnEventWrapper::on_event_mut(
+            &mut sm,
+            CommandType::UpsertWorkflowSearchAttributes
+                .try_into()
+                .unwrap(),
+        )
+        .expect("CommandScheduled should transition Created -> CommandIssued");
         assert_eq!(CommandIssued {}.to_string(), sm.state().to_string());
 
-        OnEventWrapper::on_event_mut(&mut sm, cmd_recorded_sm_event)
-            .expect("CommandRecorded should transition CommandIssued -> Done");
-        assert_eq!(Done {}.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());
+        }
+    }
+
+    #[rstest::rstest]
+    #[tokio::test]
+    async fn upserting_change_version_directly(
+        #[values(true, false)] flag_in_history: bool,
+        #[values(true, false)] with_patched_cmd: bool,
+    ) {
+        let patch_id = "whatever".to_string();
+        let mut t = TestHistoryBuilder::default();
+        t.add_by_type(EventType::WorkflowExecutionStarted);
+        t.add_full_wf_task();
+        if flag_in_history {
+            t.set_flags_first_wft(
+                &[CoreInternalFlags::UpsertSearchAttributeOnPatch as u32],
+                &[],
+            );
+        }
+        if with_patched_cmd {
+            t.add_has_change_marker(&patch_id, false);
+        }
+        t.add_upsert_search_attrs_for_patch(&[patch_id.clone()]);
+        t.add_full_wf_task();
+        t.add_workflow_execution_completed();
+
+        let mut mp = MockPollCfg::from_resp_batches(
+            "fakeid",
+            t,
+            [ResponseType::ToTaskNum(1), ResponseType::AllHistory],
+            mock_workflow_client(),
+        );
+        // Ensure the upsert command has an empty map when not using the patched command
+        if !with_patched_cmd {
+            mp.completion_asserts = Some(Box::new(|wftc| {
+                assert_matches!(wftc.commands.get(0).and_then(|c| c.attributes.as_ref()).unwrap(),
+            Attributes::UpsertWorkflowSearchAttributesCommandAttributes(attrs)
+            if attrs.search_attributes.as_ref().unwrap().indexed_fields.is_empty())
+            }));
+        }
+        let core = mock_worker(build_mock_pollers(mp));
+
+        let mut ver_upsert = HashMap::new();
+        ver_upsert.insert(
+            VERSION_SEARCH_ATTR_KEY.to_string(),
+            "hi".as_json_payload().unwrap(),
+        );
+        let act = core.poll_workflow_activation().await.unwrap();
+        let mut cmds = if with_patched_cmd {
+            vec![SetPatchMarker {
+                patch_id,
+                deprecated: false,
+            }
+            .into()]
+        } else {
+            vec![]
+        };
+        cmds.push(
+            UpsertWorkflowSearchAttributes {
+                search_attributes: ver_upsert,
+            }
+            .into(),
+        );
+        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
+            act.run_id, cmds,
+        ))
+        .await
+        .unwrap();
+        // Now ensure that encountering the upsert in history works fine
+        let act = core.poll_workflow_activation().await.unwrap();
+        core.complete_execution(&act.run_id).await;
     }
 }

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

@@ -1,15 +1,13 @@
-use super::super::{local_activity_state_machine::ResolveDat, WFMachinesError};
+use super::super::local_activity_state_machine::ResolveDat;
 use crate::{
-    protosext::{HistoryEventExt, ValidScheduleLA},
+    protosext::{CompleteLocalActivityData, ValidScheduleLA},
     worker::{ExecutingLAId, LocalActRequest, NewLocalAct},
 };
 use std::{
     collections::{HashMap, HashSet},
     time::SystemTime,
 };
-use temporal_sdk_core_protos::temporal::api::{
-    common::v1::WorkflowExecution, history::v1::HistoryEvent,
-};
+use temporal_sdk_core_protos::temporal::api::common::v1::WorkflowExecution;
 
 #[derive(Default)]
 pub(super) struct LocalActivityData {
@@ -53,7 +51,7 @@ impl LocalActivityData {
             .chain(self.new_requests.drain(..).map(|sa| {
                 self.executing.insert(sa.seq);
                 LocalActRequest::New(NewLocalAct {
-                    schedule_time: sa.original_schedule_time.unwrap_or_else(SystemTime::now),
+                    schedule_time: SystemTime::now(),
                     schedule_cmd: sa,
                     workflow_type: wf_type.to_string(),
                     workflow_exec_info: WorkflowExecution {
@@ -70,17 +68,8 @@ impl LocalActivityData {
         self.executing.len() + self.new_requests.len()
     }
 
-    pub(super) fn process_peekahead_marker(&mut self, e: &HistoryEvent) -> super::Result<()> {
-        if let Some(la_dat) = e.clone().into_local_activity_marker_details() {
-            self.preresolutions
-                .insert(la_dat.marker_dat.seq, la_dat.into());
-        } else {
-            return Err(WFMachinesError::Fatal(format!(
-                "Local activity marker was unparsable: {:?}",
-                e
-            )));
-        }
-        Ok(())
+    pub(super) fn insert_peeked_marker(&mut self, dat: CompleteLocalActivityData) {
+        self.preresolutions.insert(dat.marker_dat.seq, dat.into());
     }
 
     pub(super) fn take_preresolution(&mut self, seq: u32) -> Option<ResolveDat> {