@temporalio/core-bridge 1.13.1 → 1.14.0

package/sdk-core/{core → crates/sdk-core}/src/worker/workflow/machines/update_state_machine.rs

@@ -1,13 +1,19 @@
-use super::{EventInfo, WFMachinesAdapter, WFMachinesError, workflow_machines::MachineResponse};
+use super::{
+    EventInfo, MachineError, StateMachine, TransitionResult, WFMachinesAdapter, WFMachinesError,
+    fsm, workflow_machines::MachineResponse,
+};
 use crate::{
     protosext::protocol_messages::UpdateRequest,
-    worker::workflow::machines::{HistEventData, NewMachineWithResponse},
+    worker::workflow::{
+        fatal,
+        machines::{HistEventData, NewMachineWithResponse},
+        nondeterminism,
+    },
 };
 use itertools::Itertools;
 use prost::EncodeError;
-use rustfsm::{MachineError, StateMachine, TransitionResult, fsm};
 use std::convert::TryFrom;
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
     coresdk::{
         workflow_activation::DoUpdate,
         workflow_commands::{UpdateResponse, update_response},
@@ -119,10 +125,10 @@ impl UpdateMachine {
     ) -> Result<Vec<MachineResponse>, WFMachinesError> {
         let cmds = match resp.response {
             None => {
-                return Err(WFMachinesError::Fatal(format!(
+                return Err(fatal!(
                     "Update response for update {} had an empty result, this is a lang layer bug.",
                     &self.shared_state.meta.update_id
-                )));
+                ));
             }
             Some(update_response::Response::Accepted(_)) => {
                 self.on_event(UpdateMachineEvents::Accept)
@@ -135,11 +141,11 @@ impl UpdateMachine {
             }
         }
         .map_err(|e| match e {
-            MachineError::InvalidTransition => WFMachinesError::Nondeterminism(format!(
+            MachineError::InvalidTransition => nondeterminism!(
                 "Invalid transition while handling update response (id {}) in state {}",
                 &self.shared_state.meta.update_id,
                 self.state(),
-            )),
+            ),
             MachineError::Underlying(e) => e,
         })?;
         cmds.into_iter()
@@ -172,9 +178,9 @@ impl UpdateMachine {
         outgoing_id: String,
         msg: UpdateMsg,
     ) -> Result<MachineResponse, WFMachinesError> {
-        let accept_body = msg.pack().map_err(|e| {
-            WFMachinesError::Fatal(format!("Failed to serialize update response: {e:?}"))
-        })?;
+        let accept_body = msg
+            .pack()
+            .map_err(|e| fatal!("Failed to serialize update response: {e:?}"))?;
         Ok(MachineResponse::IssueNewMessage(ProtocolMessage {
             id: outgoing_id.clone(),
             protocol_instance_id: self.shared_state.instance_id.clone(),
@@ -221,9 +227,9 @@ impl TryFrom<HistEventData> for UpdateMachineEvents {
                 UpdateMachineEvents::WorkflowExecutionUpdateCompleted
             }
             _ => {
-                return Err(WFMachinesError::Nondeterminism(format!(
+                return Err(nondeterminism!(
                     "Update machine does not handle this event: {e}"
-                )));
+                ));
             }
         })
     }

package/sdk-core/{core → crates/sdk-core}/src/worker/workflow/machines/upsert_search_attributes_state_machine.rs

@@ -1,16 +1,15 @@
-use super::{NewMachineWithCommand, workflow_machines::MachineResponse};
+use super::{
+    NewMachineWithCommand, StateMachine, TransitionResult, fsm, workflow_machines::MachineResponse,
+};
 use crate::{
     internal_flags::CoreInternalFlags,
     worker::workflow::{
         InternalFlagsRef, WFMachinesError,
-        machines::{
-            EventInfo, HistEventData, WFMachinesAdapter,
-            patch_state_machine::VERSION_SEARCH_ATTR_KEY,
-        },
+        machines::{EventInfo, HistEventData, WFMachinesAdapter},
     },
 };
-use rustfsm::{StateMachine, TransitionResult, fsm};
-use temporal_sdk_core_protos::{
+use temporalio_common::protos::{
+    VERSION_SEARCH_ATTR_KEY,
     coresdk::workflow_commands::UpsertWorkflowSearchAttributes,
     temporal::api::{
         command::v1::{UpsertWorkflowSearchAttributesCommandAttributes, command},
@@ -178,86 +177,32 @@ impl From<Created> for CommandIssued {
 
 #[cfg(test)]
 mod tests {
-    use super::{super::OnEventWrapper, *};
+    use super::{super::OnEventWrapper, StateMachine, *};
     use crate::{
         replay::TestHistoryBuilder,
-        test_help::{MockPollCfg, ResponseType, build_fake_sdk, build_mock_pollers, mock_worker},
-        worker::{
-            client::mocks::mock_worker_client,
-            workflow::machines::patch_state_machine::VERSION_SEARCH_ATTR_KEY,
+        test_help::{
+            MockPollCfg, ResponseType, WorkerTestHelpers, build_mock_pollers, mock_worker,
         },
+        worker::client::mocks::mock_worker_client,
     };
-    use rustfsm::StateMachine;
     use std::collections::HashMap;
-    use temporal_sdk::WfContext;
-    use temporal_sdk_core_api::Worker;
-    use temporal_sdk_core_protos::{
-        DEFAULT_WORKFLOW_TYPE,
-        coresdk::{
-            AsJsonPayloadExt,
-            workflow_activation::{WorkflowActivationJob, workflow_activation_job},
-            workflow_commands::SetPatchMarker,
-            workflow_completion::WorkflowActivationCompletion,
-        },
-        temporal::api::{
-            command::v1::{Command, command::Attributes},
-            common::v1::Payload,
-            enums::v1::EventType,
-            history::v1::{HistoryEvent, UpsertWorkflowSearchAttributesEventAttributes},
+    use temporalio_common::{
+        Worker,
+        protos::{
+            coresdk::{
+                AsJsonPayloadExt,
+                workflow_activation::{WorkflowActivationJob, workflow_activation_job},
+                workflow_commands::SetPatchMarker,
+                workflow_completion::WorkflowActivationCompletion,
+            },
+            temporal::api::{
+                command::v1::command::Attributes,
+                common::v1::Payload,
+                enums::v1::EventType,
+                history::v1::{HistoryEvent, UpsertWorkflowSearchAttributesEventAttributes},
+            },
         },
     };
-    use temporal_sdk_core_test_utils::WorkerTestHelpers;
-
-    #[tokio::test]
-    async fn upsert_search_attrs_from_workflow() {
-        let mut t = TestHistoryBuilder::default();
-        t.add_by_type(EventType::WorkflowExecutionStarted);
-        t.add_full_wf_task();
-        t.add_workflow_execution_completed();
-
-        let (k1, k2) = ("foo", "bar");
-
-        let mut mock_cfg = MockPollCfg::from_hist_builder(t);
-        mock_cfg.completion_asserts_from_expectations(|mut asserts| {
-            asserts.then(|wft| {
-                assert_matches!(
-                    wft.commands.as_slice(),
-                    [Command { attributes: Some(
-                          command::Attributes::UpsertWorkflowSearchAttributesCommandAttributes(msg)
-                        ), .. }, ..] => {
-                        let fields = &msg.search_attributes.as_ref().unwrap().indexed_fields;
-                        let payload1 = fields.get(k1).unwrap();
-                        let payload2 = fields.get(k2).unwrap();
-                        assert_eq!(payload1.data[0], 0x01);
-                        assert_eq!(payload2.data[0], 0x02);
-                        assert_eq!(fields.len(), 2);
-                    }
-                );
-            });
-        });
-
-        let mut worker = build_fake_sdk(mock_cfg);
-        worker.register_wf(DEFAULT_WORKFLOW_TYPE, move |ctx: WfContext| async move {
-            ctx.upsert_search_attributes([
-                (
-                    String::from(k1),
-                    Payload {
-                        data: vec![0x01],
-                        ..Default::default()
-                    },
-                ),
-                (
-                    String::from(k2),
-                    Payload {
-                        data: vec![0x02],
-                        ..Default::default()
-                    },
-                ),
-            ]);
-            Ok(().into())
-        });
-        worker.run().await.unwrap();
-    }
 
     #[rstest::rstest]
     fn upsert_search_attrs_sm() {

package/sdk-core/{core → crates/sdk-core}/src/worker/workflow/machines/workflow_machines/local_acts.rs

@@ -7,7 +7,7 @@ use std::{
     collections::{HashMap, HashSet},
     time::SystemTime,
 };
-use temporal_sdk_core_protos::temporal::api::common::v1::WorkflowExecution;
+use temporalio_common::protos::temporal::api::common::v1::WorkflowExecution;
 
 #[derive(Default)]
 pub(super) struct LocalActivityData {

package/sdk-core/{core → crates/sdk-core}/src/worker/workflow/machines/workflow_machines.rs

@@ -25,16 +25,17 @@ use crate::{
         workflow::{
             CommandID, DrivenWorkflow, HistoryUpdate, InternalFlagsRef, LocalResolution,
             OutgoingJob, RunBasics, WFCommand, WFCommandVariant, WFMachinesError,
-            WorkflowStartedInfo,
+            WorkflowStartedInfo, fatal,
             history_update::NextWFT,
             machines::{
                 HistEventData, activity_state_machine::ActivityMachine,
                 child_workflow_state_machine::ChildWorkflowMachine,
                 modify_workflow_properties_state_machine::modify_workflow_properties,
                 nexus_operation_state_machine::NexusOperationMachine,
-                patch_state_machine::VERSION_SEARCH_ATTR_KEY, update_state_machine::UpdateMachine,
+                update_state_machine::UpdateMachine,
                 upsert_search_attributes_state_machine::upsert_search_attrs_internal,
             },
+            nondeterminism,
         },
     },
 };
@@ -51,25 +52,27 @@ use std::{
     sync::Arc,
     time::{Duration, Instant, SystemTime},
 };
-use temporal_sdk_core_api::worker::{WorkerConfig, WorkerDeploymentVersion};
-use temporal_sdk_core_protos::{
-    coresdk::{
-        common::{NamespacedWorkflowExecution, VersioningIntent},
-        workflow_activation,
-        workflow_activation::{
-            NotifyHasPatch, UpdateRandomSeed, WorkflowActivation, workflow_activation_job,
+use temporalio_common::{
+    protos::{
+        VERSION_SEARCH_ATTR_KEY,
+        coresdk::{
+            common::{NamespacedWorkflowExecution, VersioningIntent},
+            workflow_activation::{
+                self, NotifyHasPatch, UpdateRandomSeed, WorkflowActivation, workflow_activation_job,
+            },
+            workflow_commands::ContinueAsNewWorkflowExecution,
         },
-        workflow_commands::ContinueAsNewWorkflowExecution,
-    },
-    temporal::api::{
-        command::v1::{
-            Command as ProtoCommand, CommandAttributesExt, command::Attributes as ProtoCmdAttrs,
+        temporal::api::{
+            command::v1::{
+                Command as ProtoCommand, CommandAttributesExt, command::Attributes as ProtoCmdAttrs,
+            },
+            enums::v1::EventType,
+            history::v1::{HistoryEvent, history_event},
+            protocol::v1::{Message as ProtocolMessage, message::SequencingId},
+            sdk::v1::{UserMetadata, WorkflowTaskCompletedMetadata},
         },
-        enums::v1::EventType,
-        history::v1::{HistoryEvent, history_event},
-        protocol::v1::{Message as ProtocolMessage, message::SequencingId},
-        sdk::v1::{UserMetadata, WorkflowTaskCompletedMetadata},
     },
+    worker::{WorkerConfig, WorkerDeploymentVersion},
 };
 
 type Result<T, E = WFMachinesError> = std::result::Result<T, E>;
@@ -244,11 +247,11 @@ macro_rules! cancel_machine {
         let machine = if let Machines::$machine_variant(m) = $self.machine_mut(m_key) {
             m
         } else {
-            return Err(WFMachinesError::Nondeterminism(format!(
+            return Err(nondeterminism!(
                 "Machine was not a {} when it should have been during cancellation: {:?}",
                 stringify!($machine_variant),
                 $cmd_id
-            )));
+            ));
         };
         let machine_resps = machine.$cancel_method($($args),*)?;
         $self.process_machine_responses(m_key, machine_resps)?
@@ -364,10 +367,10 @@ impl WorkflowMachines {
                     }
                     self.process_machine_responses(mk, resps)?;
                 } else {
-                    return Err(WFMachinesError::Nondeterminism(format!(
+                    return Err(nondeterminism!(
                         "Command matching activity with seq num {seq} existed but was not a \
                         local activity!"
-                    )));
+                    ));
                 }
                 self.local_activity_data.done_executing(seq);
             }
@@ -463,6 +466,11 @@ impl WorkflowMachines {
             continue_as_new_suggested: self.continue_as_new_suggested,
             deployment_version_for_current_task: deployment_version_for_current_task
                 .map(Into::into),
+            last_sdk_version: (*self.observed_internal_flags)
+                .borrow()
+                .last_sdk_version()
+                .unwrap_or_default()
+                .to_owned(),
         }
     }
 
@@ -566,10 +574,9 @@ impl WorkflowMachines {
                 (evts, has_final_event)
             }
             NextWFT::NeedFetch => {
-                return Err(WFMachinesError::Fatal(
+                return Err(fatal!(
                     "Need to fetch history events to continue applying workflow task, but this \
                      should be prevented ahead of time! This is a Core SDK bug."
-                        .to_string(),
                 ));
             }
         };
@@ -642,10 +649,11 @@ impl WorkflowMachines {
         while let Some(event) = history.next() {
             let eid = event.event_id;
             if eid != self.last_processed_event + 1 {
-                return Err(WFMachinesError::Fatal(format!(
+                return Err(fatal!(
                     "History is out of order. Last processed event: {}, event id: {}",
-                    self.last_processed_event, eid
-                )));
+                    self.last_processed_event,
+                    eid
+                ));
             }
             let next_event = history.peek();
 
@@ -775,9 +783,7 @@ impl WorkflowMachines {
                         self.local_activity_data.insert_peeked_marker(la_dat);
                     }
                 } else {
-                    return Err(WFMachinesError::Fatal(format!(
-                        "Local activity marker was unparsable: {e:?}"
-                    )));
+                    return Err(fatal!("Local activity marker was unparsable: {e:?}"));
                 }
             } else if let Some(
                 history_event::Attributes::WorkflowExecutionUpdateAcceptedEventAttributes(ref atts),
@@ -849,10 +855,9 @@ impl WorkflowMachines {
             let are_more_events =
                 next_event.is_some() || !event_dat.current_task_is_last_in_history;
             return if are_more_events {
-                Err(WFMachinesError::Fatal(
+                Err(fatal!(
                     "Machines were fed a history which has an event after workflow execution was \
                      terminated!"
-                        .to_string(),
                 ))
             } else {
                 Ok(EventHandlingOutcome::Normal)
@@ -860,9 +865,9 @@ impl WorkflowMachines {
         }
         if event.event_type() == EventType::Unspecified || event.attributes.is_none() {
             return if !event.worker_may_ignore {
-                Err(WFMachinesError::Fatal(format!(
+                Err(fatal!(
                     "Event type is unspecified! This history is invalid. Event detail: {event:?}"
-                )))
+                ))
             } else {
                 debug!("Event is ignorable");
                 Ok(EventHandlingOutcome::SkipEvent {
@@ -887,10 +892,10 @@ impl WorkflowMachines {
                 .machines_by_event_id
                 .get(&initial_cmd_id)
                 .ok_or_else(|| {
-                    WFMachinesError::Nondeterminism(format!(
+                    nondeterminism!(
                         "During event handling, this event had an initial command ID but we \
                          could not find a matching command for it: {event:?}"
-                    ))
+                    )
                 })?;
             self.submachine_handle_event(*mkey, event_dat)?;
         } else {
@@ -917,9 +922,9 @@ impl WorkflowMachines {
         let event = &event_dat.event;
 
         if event.is_local_activity_marker() {
-            let deets = event.extract_local_activity_marker_data().ok_or_else(|| {
-                WFMachinesError::Fatal(format!("Local activity marker was unparsable: {event:?}"))
-            })?;
+            let deets = event
+                .extract_local_activity_marker_data()
+                .ok_or_else(|| fatal!("Local activity marker was unparsable: {event:?}"))?;
             let cmdid = CommandID::LocalActivity(deets.seq);
             let mkey = self.get_machine_key(cmdid)?;
             if let Machines::LocalActivityMachine(lam) = self.machine(mkey) {
@@ -928,10 +933,10 @@ impl WorkflowMachines {
                     return Ok(EventHandlingOutcome::Normal);
                 }
             } else {
-                return Err(WFMachinesError::Fatal(format!(
+                return Err(fatal!(
                     "Encountered local activity marker but the associated machine was of the \
                      wrong type! {event:?}"
-                )));
+                ));
             }
         }
 
@@ -952,9 +957,7 @@ impl WorkflowMachines {
             let command = if let Some(c) = maybe_command {
                 c
             } else {
-                return Err(WFMachinesError::Nondeterminism(format!(
-                    "No command scheduled for event {event}"
-                )));
+                return Err(nondeterminism!("No command scheduled for event {event}"));
             };
 
             let canceled_before_sent = self
@@ -1001,9 +1004,9 @@ impl WorkflowMachines {
                         attrs,
                     );
                 } else {
-                    return Err(WFMachinesError::Fatal(format!(
+                    return Err(fatal!(
                         "WorkflowExecutionStarted event did not have appropriate attributes: {event_dat}"
-                    )));
+                    ));
                 }
             }
             Ok(EventType::WorkflowTaskScheduled) => {
@@ -1037,9 +1040,9 @@ impl WorkflowMachines {
                 }
             }
             _ => {
-                return Err(WFMachinesError::Fatal(format!(
+                return Err(fatal!(
                     "The event is not a non-stateful event, but we tried to handle it as one: {event_dat}"
-                )));
+                ));
             }
         }
         Ok(())
@@ -1075,13 +1078,12 @@ impl WorkflowMachines {
 
         match message.body {
             IncomingProtocolMessageBody::UpdateRequest(ur) => {
-                let seq_id = if let SequencingId::EventId(eid) = message
-                    .sequencing_id
-                    .ok_or_else(|| WFMachinesError::Fatal(SEQIDERR.to_string()))?
+                let seq_id = if let SequencingId::EventId(eid) =
+                    message.sequencing_id.ok_or_else(|| fatal!("{SEQIDERR}"))?
                 {
                     eid
                 } else {
-                    return Err(WFMachinesError::Fatal(SEQIDERR.to_string()));
+                    return Err(fatal!("{SEQIDERR}"));
                 };
                 let um = UpdateMachine::init(
                     message.id,
@@ -1206,9 +1208,9 @@ impl WorkflowMachines {
                         );
                     }
                     c => {
-                        return Err(WFMachinesError::Fatal(format!(
+                        return Err(fatal!(
                             "A machine requested to create a new command of an unsupported type: {c:?}"
-                        )));
+                        ));
                     }
                 },
                 MachineResponse::IssueFakeLocalActivityMarker(seq) => {
@@ -1352,10 +1354,8 @@ impl WorkflowMachines {
                 WFCommandVariant::AddLocalActivity(attrs) => {
                     let seq = attrs.seq;
                     let attrs: ValidScheduleLA =
-                        ValidScheduleLA::from_schedule_la(attrs).map_err(|e| {
-                            WFMachinesError::Fatal(format!(
-                                "Invalid schedule local activity request (seq {seq}): {e}"
-                            ))
+                        ValidScheduleLA::from_schedule_la(attrs, cmd.metadata).map_err(|e| {
+                            fatal!("Invalid schedule local activity request (seq {seq}): {e}")
                         })?;
                     let (la, mach_resp) = new_local_activity(
                         attrs,
@@ -1463,10 +1463,7 @@ impl WorkflowMachines {
                 }
                 WFCommandVariant::RequestCancelExternalWorkflow(attrs) => {
                     let we = attrs.workflow_execution.ok_or_else(|| {
-                        WFMachinesError::Fatal(
-                            "Cancel external workflow command had no workflow_execution field"
-                                .to_string(),
-                        )
+                        fatal!("Cancel external workflow command had no workflow_execution field")
                     })?;
                     self.add_cmd_to_wf_task(
                         new_external_cancel(
@@ -1514,11 +1511,11 @@ impl WorkflowMachines {
                     let m = if let Machines::UpdateMachine(m) = self.machine_mut(m_key) {
                         m
                     } else {
-                        return Err(WFMachinesError::Nondeterminism(format!(
+                        return Err(nondeterminism!(
                             "Tried to handle an update response for \
                              update with instance id {} but it was not found!",
                             &ur.protocol_instance_id
-                        )));
+                        ));
                     };
                     let resps = m.handle_response(ur)?;
                     self.process_machine_responses(m_key, resps)?;
@@ -1546,9 +1543,10 @@ impl WorkflowMachines {
     }
 
     fn get_machine_key(&self, id: CommandID) -> Result<MachineKey> {
-        Ok(*self.id_to_machine.get(&id).ok_or_else(|| {
-            WFMachinesError::Nondeterminism(format!("Missing associated machine for {id:?}"))
-        })?)
+        Ok(*self
+            .id_to_machine
+            .get(&id)
+            .ok_or_else(|| nondeterminism!("Missing associated machine for {id:?}"))?)
     }
 
     fn get_machine_by_msg(&self, protocol_instance_id: &str) -> Result<MachineKey> {
@@ -1556,9 +1554,7 @@ impl WorkflowMachines {
             .machines_by_protocol_instance_id
             .get(protocol_instance_id)
             .ok_or_else(|| {
-                WFMachinesError::Fatal(format!(
-                    "Missing associated machine for protocol message {protocol_instance_id}"
-                ))
+                fatal!("Missing associated machine for protocol message {protocol_instance_id}")
             })?)
     }
 
@@ -1751,10 +1747,10 @@ fn patch_marker_handling(
                 debug!("Deprecated patch marker tried against non-patch machine, skipping.");
                 skip_one_or_two_events(next_event)
             } else {
-                Err(WFMachinesError::Nondeterminism(format!(
+                Err(nondeterminism!(
                     "Non-deprecated patch marker encountered for change {patch_name}, but there is \
                      no corresponding change command!"
-                )))
+                ))
             }
         }
     } else if patch_machine.is_some() {

package/sdk-core/{core → crates/sdk-core}/src/worker/workflow/machines/workflow_task_state_machine.rs

@@ -1,13 +1,15 @@
 #![allow(clippy::enum_variant_names)]
 
-use super::{EventInfo, WFMachinesAdapter, WFMachinesError, workflow_machines::MachineResponse};
-use crate::worker::workflow::machines::HistEventData;
-use rustfsm::{StateMachine, TransitionResult, fsm};
+use super::{
+    EventInfo, StateMachine, TransitionResult, WFMachinesAdapter, WFMachinesError, fsm,
+    workflow_machines::MachineResponse,
+};
+use crate::worker::workflow::{fatal, machines::HistEventData, nondeterminism};
 use std::{
     convert::{TryFrom, TryInto},
     time::SystemTime,
 };
-use temporal_sdk_core_protos::temporal::api::{
+use temporalio_common::protos::temporal::api::{
     enums::v1::{CommandType, EventType, WorkflowTaskFailedCause},
     history::v1::history_event::Attributes::WorkflowTaskFailedEventAttributes,
 };
@@ -65,10 +67,9 @@ impl WFMachinesAdapter for WorkflowTaskMachine {
                 let (event_id, event_type) = if let Some(ei) = event_info {
                     (ei.event_id, ei.event_type)
                 } else {
-                    return Err(WFMachinesError::Fatal(
+                    return Err(fatal!(
                         "WF Task machine should never issue a task started trigger \
                         command in response to non-history events"
-                            .to_string(),
                     ));
                 };
 
@@ -100,16 +101,15 @@ impl TryFrom<HistEventData> for WorkflowTaskMachineEvents {
                     match time.try_into() {
                         Ok(t) => t,
                         Err(_) => {
-                            return Err(WFMachinesError::Fatal(
+                            return Err(fatal!(
                                 "Workflow task started event timestamp was inconvertible"
-                                    .to_string(),
                             ));
                         }
                     }
                 } else {
-                    return Err(WFMachinesError::Fatal(format!(
+                    return Err(fatal!(
                         "Workflow task started event must contain timestamp: {e}"
-                    )));
+                    ));
                 };
                 WFTStartedDat {
                     started_event_id: e.event_id,
@@ -135,15 +135,13 @@ impl TryFrom<HistEventData> for WorkflowTaskMachineEvents {
                         },
                     })
                 } else {
-                    return Err(WFMachinesError::Fatal(format!(
-                        "Workflow task failed is missing attributes: {e}"
-                    )));
+                    return Err(fatal!("Workflow task failed is missing attributes: {e}"));
                 }
             }
             _ => {
-                return Err(WFMachinesError::Nondeterminism(format!(
+                return Err(nondeterminism!(
                     "Event does not apply to a wf task machine: {e}"
-                )));
+                ));
             }
         })
     }